Welcome!

Microservices Expo Authors: Liz McMillan, Yeshim Deniz, Reinhard Brandstädter, Elizabeth White, Pat Romanski

Related Topics: Java IoT, Industrial IoT, Microservices Expo, IBM Cloud, Weblogic, IoT User Interface, Apache

Java IoT: Article

Componentizing a Monolithic Application in Java

Using a simple homegrown component model and framework

Component-oriented development has many architectural advantages. In spite of this, many developers tend to solve problems the monolithic way on the first go. This article demonstrates how a monolithic design can be modified to achieve component-based design. During this conversion process, the necessity of Component Models and Frameworks are highlighted. The article demonstrates the componentization of an example monolithic application using a simple homegrown component model and framework developed by the authors.

Introducing E-Store - A Business Application
Let us assume that we need to implement a simple E-store business application. The application needs to cater to the following simple business use cases for a single actor - the consumer.

  • Browse the catalog of products - Consumer can browse through the items in the store. E-store app displays the different products available in the store along with their price
  • Buy one or more products - User adds one or more quantities of a product to the shopping cart. If sufficient stock is available, E-Store app adds the selected items to the shopping cart
  • Check-out - User can checkout with the items in the shopping cart. E-store app displays the total price of all the items in the shopping cart. Subsequently, stock quantities of the purchased items are reduced

Monolithic Implementation of E-Store
The E-Store application explained above can be realized with the help of the classes shown in Figure 1.

Figure 1: Class Diagram for E-Store Application

The implementation of the above design in source code and binary code form can be obtained from the links provided at the end of the article. The implementation of the monolithic application is explained briefly in the sections below.

Application Startup - UI
The monolithic E-Store application starts up with the UI class main method. During its startup, the UI class instantiates the Store (E-Store) class. The code snippet corresponding to this is shown in Listing 1.

public class UI {

static Store estore = new Store();

public static void main(String[] args) {
int userChoice = mainMenu();
...
}
...
}

Listing 1: Startup Code - UI Class

The E-Store class instantiates the Inventory and ShoppingCart classes during its startup as shown in Listing 2.

public class Store {

Inventory inventory = new Inventory();
ShoppingCart shoppingCart = new ShoppingCart();
...
}

Listing 2: Startup Code - E-Store Class

The inventory class initializes the stock during its instantiation, by creating instances of Product class objects. The code snippet is shown in Listing 3

public class Inventory {

private Map<Product, Integer> stock = new HashMap<Product, Integer>();

public Inventory() {initStock();}

private void initStock() {
Product newIPad = new Product("NewIPad", 400.00);
stock.put(newIPad, 50);

Product galaxyTab2 = new Product("GalaxyTab2", 300.00);
stock.put(galaxyTab2, 75);

Product kindleFire = new Product("KindleFire", 250.00);
stock.put(kindleFire, 30);
}
...

}

Listing 3: Startup Code - Inventory Initialization

Once the startup is done, the UI class presents a console based menu as shown in Listing 4.

Welcome to eStore!
------------------------

1. Browse Catalog
2. Buy Items
3. Check Out
4. Exit

Choose an option:
1

Listing 4: Console based UI Menu

When the user chooses any one of the options, the UI class calls upon its implementation in the E-Store business class. The implementation of each of these is explained briefly in next few sections.

Browse Catalog Use case Realization
The getCatalog() method in the E-Store class implements this use case. When the getCatalog() method in E-Store class is called, it fetches the list of products from Inventory and returns the same. Code snippet is shown in Listing 5.

public Collection<Product> getCatalog() {

return inventory.getProducts();

}

Listing 5: E-Store Class - getCatalog() implementation

Buy Items Use case Realization
The buyItem() method in the E-Store class implements this use case. The UI class calls this method by passing the name of the product chosen by the user, and the quantity he wants to buy. If sufficient quantity is available in stock, the item is added to the shopping cart and the method returns success; otherwise, the method returns failure and no item is added to shopping cart. The code snippet is presented in Listing 6.

public boolean buyItem(String name, int quantity) {
Product product = inventory.getProduct(name);
if (product == null) return false;

if (inventory.getStock(product) >= quantity) {
shoppingCart.addItem(product, quantity);
return true;
}
return false;
}

Listing 6: E-Store Class - buyItem() implementation

Check Out Use Case Realization
The checkout() method in the E-Store class implements this use case. It reduces the stock in the inventory by the quantity bought. It also returns the total price to be paid by the user. This implementation is shown in Listing 7.

public double checkOut() {
for(Product product : shoppingCart.getItems()) {
int quantity = shoppingCart.getCount(product);
inventory.reduceStock(product, quantity);
}
double price = shoppingCart.getTotalPrice();
shoppingCart.clearItems();
return price;

}

Listing 7: E-Store Class - checkOut() Implementation

What's wrong with the Monolithic implementation?
The initial implementation of E-Store discussed above fulfills all the functional requirements of the application laid down earlier. Still this is not considered as architecturally sound application design because all the classes in the application are tightly coupled to each other. Consider the dependency metrics shown in the table below:

Table 1: Class dependency details

No.

Class

Depends On

# of Dependencies

Dependency Depth

1.

Product

 

0

0

2.

Inventory

Product

1

1

3.

ShoppingCart

Product

1

1

4.

EStore

Inventory, ShoppingCart, Product

3

2

5.

UI

EStore, Product

2

3

 

 

 

 

 

The tight coupling results in high resistance to change in implementation. For example, any change to Product class will require complete change in the application.

Let us say that the E-Store likes to announce promotional sale for three days. During these three days, the total price of the shopping cart should be discounted by 10%. In order to achieve this, we need to change the ShoppingCart class implementation. When the ShoppingCart class is changed, the E-Store class also needs to be recompiled. When the E-Store class is recompiled, the UI class also needs to be recompiled.

What happens at the end of the promotional sale when the E-Store wants to discontinue the discounts? We need to recompile all the 3 classes one more time. Ideally, since the changes affect only the ShoppingCart behavior, rest of the application modules should not have been affected. But due to the tight coupling, other modules are also affected.

Loosening the Coupling through Componentization
Low coupling design principle suggests that there should not be tight coupling among unstable entities. Having dependency on a relatively stable entity does not bring forth the evils of tight coupling.

In order to make the application modules loosely coupled, we need to componentize the application. A component is a deployable piece of software that would be independently developed and independently maintained. Independence here refers to development and maintenance of a component independent of the other components which collaborate with this component in an application assembly. In a component based application, change to one component should not directly affect the application.

We avoid tight coupling between components by introducing the abstraction of Component Interface. A component interface exposes the signature of the functionalities implemented by component. The Component Interface will be a relatively stable entity as compared to the Component Implementation.

A component consumes interfaces that it depends on for fulfilling the required functionality and provides interfaces for the functionality it provides. For collaboration with the other components, the component would work through the interfaces provided by the other components. Practically, the component should not depend on the implementation of the other components; it should depend only on the interfaces provided by those components. This way, the coupling among components is through the relatively stable interfaces and not through the highly instable implementations. Thus the principle of low coupling is upheld.

In addition to the low coupling achieved, componentization of a monolithic application also brings about substitutability of components. This means a component of the application can be substituted by another component without affecting the overall application. The only requirement is that the replacing component must offer the same set of interfaces as was offered by the component being replaced.

Componentizing the E-Store Application
We need to introduce the Component Interface abstraction in the monolithic design shown in Figure 1. Looking at the dependency details represented in the Table 1, the Product, ShoppingCart, Inventory and Store classes should be represented as components. From the implementation classes of Product, Inventory, ShoppingCart, and Store, we can extract Java Interfaces IProduct, IInventory, IShoppingCart, and IStore respectively using the refactoring tools in the IDE. The extracted interfaces are shown in Figure 2. It must be noted in Figure 9 that the method signatures in IInventory, IShoppingCart, and IStore are changed to refer to IProduct interface in place of the Product class in the corresponding methods in Figure 1.

Figure 2: E-Store Interfaces - Class Diagram

In this E-Store application, there are four components represented by their interfaces - IProduct, IInventory, IShoppingCart and IStore. After the interfaces are extracted from the monolithic implementation, it will be a good design to get these interfaces packaged into a separate Java Package called estore.ifce.

The package can also be compiled to a JAR resulting in a deployable and independently maintainable estore.ifce module. This module does not implement any component, but it simply defines ONLY the interfaces which would be implemented by other components in the application. All the components depend ONLY on this common interface module and they need not depend on individual implementation components.

Following the above principle, if we separate the implementation of Product, Inventory, ShoppingCart, and Store into individual packages and into individual JARs, we get the  package structure shown in Figure 3.

Figure 3: Package Diagram separating interface from implementation

When we refactor the code into multiple components as shown above, two code segments fail to compile as shown in Figure 4 and Figure 5. Kindly look at Listings 2 and 3 for reference.

Figure 4: Compilation error in Inventory class post Componentization

Figure 5: Compilation error in Store class post Componentization

The compilation errors occurred due to the fact that above code tried to invoke the implementation code of other components directly. We have arranged our dependencies such that one component would not depend on the internal implementation of the other component. The above code violates this.

This problem can be solved in various ways. This is where all the component models and frameworks come to the rescue. Component models like RMI, EJB, Spring, OSGi and SCA have their own way of creating object references to components from the interfaces. Users can choose to use one of these frameworks or models for initializing the component. However in this article, we will look at a simple component model developed to solve this problem without using any of the component models and frameworks. This component model uses some of the principles of design pattern and best practices which is explained in detail below.

The problem of direct reference to implementation can be resolved by introducing a ‘Factory' object that can be used by the component to obtain an object of the corresponding type. A generalized Factory object could have a signature as below:

public interface IFactory<T> {
public T createInstance();

}

To avoid tight coupling, the Factory object is really useful. So, instead of coupling to a concrete class which implements IProduct, the Inventory implementation can depend on a Factory object of type IFactory<IProduct>. By invoking the createInstance() method on the factory object, the Inventory class can obtain new IProduct objects. Similarly the IInventory and IShoppingCart objects can be obtained from the respective Factory objects using createInstance() method in the Store class.

IProduct iPad = productFactory.createInstance();
.....
IShoppingCart shoppingCart = shoppingCartFactory.createInstance();
IInventory inventory = inventoryFactory.createInstance();

To obtain a factory object, a FactoryRegistry class is used as a common factory registry for registering and retrieving factory objects using the whiteboard pattern. The common registry object can be implemented as shown in Listing 8.

public class FactoryRegistry {

private static Map<Class<?>, IFactory<?>> factoryMap = new HashMap<Class<?>, IFactory<?>>();

public static void registerFactory(Class<?> ifceClazz, IFactory<?> factory) {
factoryMap.put(ifceClazz, factory);
}

public static IFactory<?> getFactory(Class<?> ifceClazz) {
return factoryMap.get(ifceClazz);
}
}

Listing 8: FactoryRegistry Class

The Inventory class can obtain a reference to a product factory object of type IFactory<IProduct> using the whiteboard pattern. Similarly any factory object can be retrieved from the FactoryRegistry.

IFactory<IProduct> productFactory =
(IFactory<IProduct>) FactoryRegistry.getFactory(IProduct.class);

One important question that remains unanswered is how, where and when these factory objects are registered with the FactoryRegistry. All component implementations only try to GET references. As mentioned earlier, component models like RMI, EJB, OSGi have their own service repository where these references are registered and components using these references look up the repository to get an object of the corresponding type. In this simple model, a registry program named ‘ComponentRunner' is handwritten which will look up for IFactory type interfaces and its implementations and register them appropriately so that getFactory method returns an initialized factory object. Kindly refer to the source code provided for details on ComponentRunner.

Implementation of this model will help in resolving the compilation issue highlighted in Figures 4 and 5. The modified code without any compilation error using the factory pattern and registry lookup is shown in Listings 9 and 10.

private void initStock() {

IFactory<IProduct> productFactory = (IFactory<IProduct>) FactoryRegistry.getFactory(IProduct.class);

IProduct iPad = productFactory.createInstance();
iPad.setName("NewIPad");
iPad.setPrice(400.00);
stock.put(iPad, 50);

IProduct gTab = productFactory.createInstance();
gTab.setName("GalaxyTab2");
gTab.setPrice(300.00);
stock.put(gTab, 75);

IProduct kindle = productFactory.createInstance();
kindle.setName("KindleFire");
kindle.setPrice(250.00);
stock.put(kindle, 30);

}

Listing 9: Modified Inventory Class without compilation error

public class Store implements IStore {

IInventory inventory;
IShoppingCart shoppingCart;

public Store() {
IFactory<IInventory> inventoryFactory = (IFactory<IInventory>) FactoryRegistry.getFactory(IInventory.class);
IFactory<IShoppingCart> shoppingCartFactory = (IFactory<IShoppingCart>) FactoryRegistry.getFactory(IShoppingCart.class);

shoppingCart = shoppingCartFactory.createInstance();
inventory = inventoryFactory.createInstance();
}
......

Listing 10: Modified E-Store Class without compilation error

Apart from the above highlighted modifications, the business logic implementation in the components remains the same as before in the monolithic case.

Executing the Sample Application
The sample application demonstrated in this article is available as a zip file for download. The zip file contains a complete Eclipse Workspace with the source as well as binary files. To run the componentized version of this application, it is required to follow the steps below:

  1. Create a folder named ‘run'.
  2. Export the components - store, product, inventory, shopping cart, component model, store app projects from the eclipse workspace to a Jar file in the ‘run' folder, say ‘eStore.jar' for example. In order to reuse these components in other applications, individual projects can be exported as separate jar files.
  3. Copy the contents of ‘bin' folder from comprunner project to the ‘run' folder. The bin folder contains a sub folder named ‘comprunner' which contains the ComponentRunner class.
  4. Open a command prompt and change the directory to ‘run' folder.
  5. To execute the ComponentRunner, type the following in command prompt

Conclusion
The advantage of a component-oriented approach is well explained with a sample application. In this article, we also saw the limitations of having a monolithic application and how the dependencies bring in tight coupling between components. Low coupling between components can be achieved by the abstraction of Component interface. Interfaces also bring in component substitutability. A component can depend on some interfaces and provide interfaces. Interface is the key mechanism in component design principles. Initialization of component implementations can happen using several mechanisms which are different for different component models and frameworks. In this sample, a home grown component model - a factory based model is used for initializing the components and component references are registered with a simple repository - CompRunner for look up.

More Stories By Piram Manickam

Piram Manickam works at Infosys Limited. He would like to acknowledge and thank Sangeetha S, a beloved colleague and friend, for her invaluable contributions in this work.

More Stories By Subrahmanya SV

Subrahmanya SV works at Infosys Limited. He would like to acknowledge and thank Sangeetha S, a beloved colleague and friend, for her invaluable contributions in this work.

More Stories By S Sangeetha

S Sangeetha is a Senior Technical Architect at the E-Commerce Research Labs at Infosys Limited. She has over 15 years of experience in architecture, design and development of enterprise Java applications. She is also involved in enhancing the technical skills of Architects at Infosys. She has co-authored a book on ‘J2EE Architecture’ and also has written numerous articles on Java for various online Java forums like JavaWorld, java.net, DevX.com and internet.com. She can be reached at [email protected]

Comments (1)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.


@MicroservicesExpo Stories
SoftLayer operates a global cloud infrastructure platform built for Internet scale. With a global footprint of data centers and network points of presence, SoftLayer provides infrastructure as a service to leading-edge customers ranging from Web startups to global enterprises. SoftLayer's modular architecture, full-featured API, and sophisticated automation provide unparalleled performance and control. Its flexible unified platform seamlessly spans physical and virtual devices linked via a world...
Just last week a senior Hybris consultant shared the story of a customer engagement on which he was working. This customer had problems, serious problems. We’re talking about response times far beyond the most liberal acceptable standard. They were unable to solve the issue in their eCommerce platform – specifically Hybris. Although the eCommerce project was delivered by a system integrator / implementation partner, the vendor still gets involved when things go really wrong. After all, the vendo...
SYS-CON Events announced today that AppNeta, the leader in performance insight for business-critical web applications, will exhibit and present at SYS-CON's @DevOpsSummit at Cloud Expo New York, which will take place on June 7-9, 2016, at the Javits Center in New York City, NY. AppNeta is the only application performance monitoring (APM) company to provide solutions for all applications – applications you develop internally, business-critical SaaS applications you use and the networks that deli...
SYS-CON Events announced today that EastBanc Technologies will exhibit at SYS-CON's 18th International Cloud Expo®, which will take place on June 7-9, 2016, at the Javits Center in New York City, NY. EastBanc Technologies has been working at the frontier of technology since 1999. Today, the firm provides full-lifecycle software development delivering flexible technology solutions that seamlessly integrate with existing systems – whether on premise or cloud. EastBanc Technologies partners with p...
The initial debate is over: Any enterprise with a serious commitment to IT is migrating to the cloud. But things are not so simple. There is a complex mix of on-premises, colocated, and public-cloud deployments. In this power panel at 18th Cloud Expo, moderated by Conference Chair Roger Strukhoff, panelists will look at the present state of cloud from the C-level view, and how great companies and rock star executives can use cloud computing to meet their most ambitious and disruptive business ...
Many banks and financial institutions are experimenting with containers in development environments, but when will they move into production? Containers are seen as the key to achieving the ultimate in information technology flexibility and agility. Containers work on both public and private clouds, and make it easy to build and deploy applications. The challenge for regulated industries is the cost and complexity of container security compliance. VM security compliance is already challenging, ...
SYS-CON Events announced today that Commvault, a global leader in enterprise data protection and information management, has been named “Bronze Sponsor” of SYS-CON's 18th International Cloud Expo, which will take place on June 7–9, 2016, at the Javits Center in New York City, NY, and the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. Commvault is a leading provider of data protection and information management...
Agile teams report the lowest rate of measuring non-functional requirements. What does this mean for the evolution of quality in this era of Continuous Everything? To explore how the rise of SDLC acceleration trends such as Agile, DevOps, and Continuous Delivery are impacting software quality, Parasoft conducted a survey about measuring and monitoring non-functional requirements (NFRs). Here's a glimpse at what we discovered and what it means for the evolution of quality in this era of Continuo...
Last week I had the pleasure of speaking on a panel at Sapphire Ventures Next-Gen Tech Stack Forum in San Francisco. Obviously, I was excited to join the discussion, but as a participant the event crystallized not only where the larger software development market is relative to microservices, container technologies (like Docker), continuous integration and deployment; but also provided insight into where DevOps is heading in the coming years.
Join us at Cloud Expo | @ThingsExpo 2016 – June 7-9 at the Javits Center in New York City and November 1-3 at the Santa Clara Convention Center in Santa Clara, CA – and deliver your unique message in a way that is striking and unforgettable by taking advantage of SYS-CON's unmatched high-impact, result-driven event / media packages.
In the rush to compete in the digital age, a successful digital transformation is essential, but many organizations are setting themselves up for failure. There’s a common misconception that the process is just about technology, but it’s not. It’s about your business. It shouldn’t be treated as an isolated IT project; it should be driven by business needs with the committed involvement of a range of stakeholders.
SYS-CON Events announced today that BMC Software has been named "Siver Sponsor" of SYS-CON's 18th Cloud Expo, which will take place on June 7-9, 2015 at the Javits Center in New York, New York. BMC is a global leader in innovative software solutions that help businesses transform into digital enterprises for the ultimate competitive advantage. BMC Digital Enterprise Management is a set of innovative IT solutions designed to make digital business fast, seamless, and optimized from mainframe to mo...
18th Cloud Expo, taking place June 7-9, 2016, at the Javits Center in New York City, NY, will feature technical sessions from a rock star conference faculty and the leading industry players in the world. Cloud computing is now being embraced by a majority of enterprises of all sizes. Yesterday's debate about public vs. private has transformed into the reality of hybrid cloud: a recent survey shows that 74% of enterprises have a hybrid cloud strategy. Meanwhile, 94% of enterprises are using some...
SYS-CON Events announced today that Isomorphic Software will exhibit at SYS-CON's [email protected] at Cloud Expo New York, which will take place on June 7-9, 2016, at the Javits Center in New York City, NY. Isomorphic Software provides the SmartClient HTML5/AJAX platform, the most advanced technology for building rich, high-productivity enterprise web applications for any device. SmartClient couples the industry’s broadest, deepest UI component set with a java server framework to deliver an end-...
SYS-CON Events announced today that Tintri Inc., a leading producer of VM-aware storage (VAS) for virtualization and cloud environments, will exhibit at the 18th International CloudExpo®, which will take place on June 7-9, 2016, at the Javits Center in New York City, New York, and the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA.
You might already know them from theagileadmin.com, but let me introduce you to two of the leading minds in the Rugged DevOps movement: James Wickett and Ernest Mueller. Both James and Ernest are active leaders in the DevOps space, in addition to helping organize events such as DevOpsDays Austinand LASCON. Our conversation covered a lot of bases from the founding of Rugged DevOps to aligning organizational silos to lessons learned from W. Edwards Demings.
As AT&Ts VP of Domain 2.0 architecture writes one aspect of their Domain 2.0 strategy is a goal to embrace a Microservices Application Architecture. One page 9 they describe how these envisage them fitting into the ECOMP architecture: "The initial steps of the recipes include a homing and placement task using constraints specified in the requests. ‘Homing and Placement' are micro-services involving orchestration, inventory, and controllers responsible for infrastructure, network, and applicati...
Application development and delivery methods have undergone radical changes in recent years to improve scalability and resiliency. Container images are the new build and deployment artifacts that are used to ship and run software. While startups have long been comfortable experimenting with and embracing new technologies, even large enterprises are now re-architecting their software systems so that they can benefit from container-enabled micro services architectures. With the launch of DC/OS, w...
SYS-CON Events announced today that Alert Logic, Inc., the leading provider of Security-as-a-Service solutions for the cloud, will exhibit at SYS-CON's 18th International Cloud Expo®, which will take place on June 7-9, 2016, at the Javits Center in New York City, NY. Alert Logic, Inc., provides Security-as-a-Service for on-premises, cloud, and hybrid infrastructures, delivering deep security insight and continuous protection for customers at a lower cost than traditional security solutions. Ful...
When I talk about driving innovation with self-organizing teams, I emphasize that such self-organization includes expecting the participants to organize their own teams, give themselves their own goals, and determine for themselves how to measure their success. In contrast, the definition of skunkworks points out that members of such teams are “usually specially selected.” Good thing he added the word usually – because specially selecting such teams throws a wrench in the entire works, limiting...