Java IoT Authors: David Paquette, Liz McMillan, Pat Romanski, Carmen Gonzalez, Elizabeth White

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:

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();
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



Depends On

# of Dependencies

Dependency Depth


















Inventory, ShoppingCart, Product





EStore, Product








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();
stock.put(iPad, 50);

IProduct gTab = productFactory.createInstance();
stock.put(gTab, 75);

IProduct kindle = productFactory.createInstance();
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

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.

@ThingsExpo Stories
SYS-CON Events announced today that Hitrons Solutions will exhibit at the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. Hitrons Solutions Inc. is distributor in the North American market for unique products and services of small and medium-size businesses, including cloud services and solutions, SEO marketing platforms, and mobile applications.
Successful digital transformation requires new organizational competencies and capabilities. Research tells us that the biggest impediment to successful transformation is human; consequently, the biggest enabler is a properly skilled and empowered workforce. In the digital age, new individual and collective competencies are required. In his session at 19th Cloud Expo, Bob Newhouse, CEO and founder of Agilitiv, will draw together recent research and lessons learned from emerging and established ...
November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. Penta Security is a leading vendor for data security solutions, including its encryption solution, D’Amo. By using FPE technology, D’Amo allows for the implementation of encryption technology to sensitive data fields without modification to schema in the database environment. With businesses having their data become increasingly more complicated in their mission-critical applications (such as ERP, CRM, HRM), continued ...
SYS-CON Events announced today that Enzu will exhibit at the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. Enzu’s mission is to be the leading provider of enterprise cloud solutions worldwide. Enzu enables online businesses to use its IT infrastructure to their competitive advantage. By offering a suite of proven hosting and management services, Enzu wants companies to focus on the core of their online busine...
For basic one-to-one voice or video calling solutions, WebRTC has proven to be a very powerful technology. Although WebRTC’s core functionality is to provide secure, real-time p2p media streaming, leveraging native platform features and server-side components brings up new communication capabilities for web and native mobile applications, allowing for advanced multi-user use cases such as video broadcasting, conferencing, and media recording.
Established in 1998, Calsoft is a leading software product engineering Services Company specializing in Storage, Networking, Virtualization and Cloud business verticals. Calsoft provides End-to-End Product Development, Quality Assurance Sustenance, Solution Engineering and Professional Services expertise to assist customers in achieving their product development and business goals. The company's deep domain knowledge of Storage, Virtualization, Networking and Cloud verticals helps in delivering ...
SYS-CON Events announced today that Cloudbric, a leading website security provider, will exhibit at the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. Cloudbric is an elite full service website protection solution specifically designed for IT novices, entrepreneurs, and small and medium businesses. First launched in 2015, Cloudbric is based on the enterprise level Web Application Firewall by Penta Security Sys...
The best way to leverage your Cloud Expo presence as a sponsor and exhibitor is to plan your news announcements around our events. The press covering Cloud Expo and @ThingsExpo will have access to these releases and will amplify your news announcements. More than two dozen Cloud companies either set deals at our shows or have announced their mergers and acquisitions at Cloud Expo. Product announcements during our show provide your company with the most reach through our targeted audiences.
In the next five to ten years, millions, if not billions of things will become smarter. This smartness goes beyond connected things in our homes like the fridge, thermostat and fancy lighting, and into heavily regulated industries including aerospace, pharmaceutical/medical devices and energy. “Smartness” will embed itself within individual products that are part of our daily lives. We will engage with smart products - learning from them, informing them, and communicating with them. Smart produc...
SYS-CON Events announced today that 910Telecom will exhibit at the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. Housed in the classic Denver Gas & Electric Building, 910 15th St., 910Telecom is a carrier-neutral telecom hotel located in the heart of Denver. Adjacent to CenturyLink, AT&T, and Denver Main, 910Telecom offers connectivity to all major carriers, Internet service providers, Internet backbones and ...
SYS-CON Events announced today that Coalfire will exhibit at the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. Coalfire is the trusted leader in cybersecurity risk management and compliance services. Coalfire integrates advisory and technical assessments and recommendations to the corporate directors, executives, boards, and IT organizations for global brands and organizations in the technology, cloud, health...
SYS-CON Events announced today that Transparent Cloud Computing (T-Cloud) Consortium will exhibit at the 19th International Cloud Expo®, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. The Transparent Cloud Computing Consortium (T-Cloud Consortium) will conduct research activities into changes in the computing model as a result of collaboration between "device" and "cloud" and the creation of new value and markets through organic data proces...
WebRTC defines no default signaling protocol, causing fragmentation between WebRTC silos. SIP and XMPP provide possibilities, but come with considerable complexity and are not designed for use in a web environment. In his session at @ThingsExpo, Matthew Hodgson, technical co-founder of the Matrix.org, discussed how Matrix is a new non-profit Open Source Project that defines both a new HTTP-based standard for VoIP & IM signaling and provides reference implementations.
The Internet of Things (IoT), in all its myriad manifestations, has great potential. Much of that potential comes from the evolving data management and analytic (DMA) technologies and processes that allow us to gain insight from all of the IoT data that can be generated and gathered. This potential may never be met as those data sets are tied to specific industry verticals and single markets, with no clear way to use IoT data and sensor analytics to fulfill the hype being given the IoT today.
In his general session at 18th Cloud Expo, Lee Atchison, Principal Cloud Architect and Advocate at New Relic, discussed cloud as a ‘better data center’ and how it adds new capacity (faster) and improves application availability (redundancy). The cloud is a ‘Dynamic Tool for Dynamic Apps’ and resource allocation is an integral part of your application architecture, so use only the resources you need and allocate /de-allocate resources on the fly.
We're entering the post-smartphone era, where wearable gadgets from watches and fitness bands to glasses and health aids will power the next technological revolution. With mass adoption of wearable devices comes a new data ecosystem that must be protected. Wearables open new pathways that facilitate the tracking, sharing and storing of consumers’ personal health, location and daily activity data. Consumers have some idea of the data these devices capture, but most don’t realize how revealing and...
A completely new computing platform is on the horizon. They’re called Microservers by some, ARM Servers by others, and sometimes even ARM-based Servers. No matter what you call them, Microservers will have a huge impact on the data center and on server computing in general. Although few people are familiar with Microservers today, their impact will be felt very soon. This is a new category of computing platform that is available today and is predicted to have triple-digit growth rates for some ...
SYS-CON Events announced today that MathFreeOn will exhibit at the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. MathFreeOn is Software as a Service (SaaS) used in Engineering and Math education. Write scripts and solve math problems online. MathFreeOn provides online courses for beginners or amateurs who have difficulties in writing scripts. In accordance with various mathematical topics, there are more tha...
In past @ThingsExpo presentations, Joseph di Paolantonio has explored how various Internet of Things (IoT) and data management and analytics (DMA) solution spaces will come together as sensor analytics ecosystems. This year, in his session at @ThingsExpo, Joseph di Paolantonio from DataArchon, will be adding the numerous Transportation areas, from autonomous vehicles to “Uber for containers.” While IoT data in any one area of Transportation will have a huge impact in that area, combining sensor...
SYS-CON Events announced today that SoftNet Solutions will exhibit at the 19th International Cloud Expo, which will take place on November 1–3, 2016, at the Santa Clara Convention Center in Santa Clara, CA. SoftNet Solutions specializes in Enterprise Solutions for Hadoop and Big Data. It offers customers the most open, robust, and value-conscious portfolio of solutions, services, and tools for the shortest route to success with Big Data. The unique differentiator is the ability to architect and ...