IoT User Interface Authors: Elizabeth White, Liz McMillan, David Sprott, Don MacVittie, Lori MacVittie

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.

@CloudExpo Stories
In his keynote at 19th Cloud Expo, Sheng Liang, co-founder and CEO of Rancher Labs, will discuss the technological advances and new business opportunities created by the rapid adoption of containers. With the success of Amazon Web Services (AWS) and various open source technologies used to build private clouds, cloud computing has become an essential component of IT strategy. However, users continue to face challenges in implementing clouds, as older technologies evolve and newer ones like Docke...
In his session at 19th Cloud Expo, Claude Remillard, Principal Program Manager in Developer Division at Microsoft, will contrast how his team used config as code and immutable patterns for continuous delivery of microservices and apps to the cloud. He will show the immutable patterns helps developers do away with most of the complexity of config as code-enabling scenarios such as rollback, zero downtime upgrades with far greater simplicity. He will also have live demos of building immutable pipe...
In his keynote at 18th Cloud Expo, Andrew Keys, Co-Founder of ConsenSys Enterprise, provided an overview of the evolution of the Internet and the Database and the future of their combination – the Blockchain. Andrew Keys is Co-Founder of ConsenSys Enterprise. He comes to ConsenSys Enterprise with capital markets, technology and entrepreneurial experience. Previously, he worked for UBS investment bank in equities analysis. Later, he was responsible for the creation and distribution of life sett...
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...
@ThingsExpo has been named the Top 5 Most Influential M2M Brand by Onalytica in the ‘Machine to Machine: Top 100 Influencers and Brands.' Onalytica analyzed the online debate on M2M by looking at over 85,000 tweets to provide the most influential individuals and brands that drive the discussion. According to Onalytica the "analysis showed a very engaged community with a lot of interactive tweets. The M2M discussion seems to be more fragmented and driven by some of the major brands present in the...
So you think you are a DevOps warrior, huh? Put your money (not really, it’s free) where your metrics are and prove it by taking The Ultimate DevOps Geek Quiz Challenge, sponsored by DevOps Summit. Battle through the set of tough questions created by industry thought leaders to earn your bragging rights and win some cool prizes.
As data explodes in quantity, importance and from new sources, the need for managing and protecting data residing across physical, virtual, and cloud environments grow with it. Managing data includes protecting it, indexing and classifying it for true, long-term management, compliance and E-Discovery. Commvault can ensure this with a single pane of glass solution – whether in a private cloud, a Service Provider delivered public cloud or a hybrid cloud environment – across the heterogeneous enter...
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...
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...
More and more brands have jumped on the IoT bandwagon. We have an excess of wearables – activity trackers, smartwatches, smart glasses and sneakers, and more that track seemingly endless datapoints. However, most consumers have no idea what “IoT” means. Creating more wearables that track data shouldn't be the aim of brands; delivering meaningful, tangible relevance to their users should be. We're in a period in which the IoT pendulum is still swinging. Initially, it swung toward "smart for smar...
Governments around the world are adopting Safe Harbor privacy provisions to protect customer data from leaving sovereign territories. Increasingly, global companies are required to create new instances of their server clusters in multiple countries to keep abreast of these new Safe Harbor laws. Is it worth it? In his session at 19th Cloud Expo, Adam Rogers, Managing Director of Anexia, Inc., will discuss how to keep your data legal and still stay in business.
@ThingsExpo has been named the Top 5 Most Influential Internet of Things Brand by Onalytica in the ‘The Internet of Things Landscape 2015: Top 100 Individuals and Brands.' Onalytica analyzed Twitter conversations around the #IoT debate to uncover the most influential brands and individuals driving the conversation. Onalytica captured data from 56,224 users. The PageRank based methodology they use to extract influencers on a particular topic (tweets mentioning #InternetofThings or #IoT in this ...
Successful transition from traditional IT to cloud computing requires three key ingredients: an IT architecture that allows companies to extend their internal best practices to the cloud, a cost point that allows economies of scale, and automated processes that manage risk exposure and maintain regulatory compliance with industry regulations (FFIEC, PCI-DSS, HIPAA, FISMA). The unique combination of VMware, the IBM Cloud, and Cloud Raxak, a 2016 Gartner Cool Vendor in IT Automation, provides a co...
P2P RTC will impact the landscape of communications, shifting from traditional telephony style communications models to OTT (Over-The-Top) cloud assisted & PaaS (Platform as a Service) communication services. The P2P shift will impact many areas of our lives, from mobile communication, human interactive web services, RTC and telephony infrastructure, user federation, security and privacy implications, business costs, and scalability. In his session at @ThingsExpo, Robin Raymond, Chief Architect...
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 ...
SYS-CON Events announced today that Niagara Networks 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. Niagara Networks offers the highest port-density systems, and the most complete Next-Generation Network Visibility systems including Network Packet Brokers, Bypass Switches, and Network TAPs.
SYS-CON Events announced today that Embotics, the cloud automation company, 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. Embotics is the cloud automation company for IT organizations and service providers that need to improve provisioning or enable self-service capabilities. With a relentless focus on delivering a premier user experience and unmatched customer support, Embotics is the fas...
In an era of historic innovation fueled by unprecedented access to data and technology, the low cost and risk of entering new markets has leveled the playing field for business. Today, any ambitious innovator can easily introduce a new application or product that can reinvent business models and transform the client experience. In their Day 2 Keynote at 19th Cloud Expo, Mercer Rowe, IBM Vice President of Strategic Alliances, and Raejeanne Skillern, Intel Vice President of Data Center Group and ...
SYS-CON Events announced today that StarNet Communications 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. StarNet Communications’ FastX is the industry first cloud-based remote X Windows emulator. Using standard Web browsers (FireFox, Chrome, Safari, etc.) users from around the world gain highly secure access to applications and data hosted on Linux-based servers in a central data center. ...
SYS-CON Events announced today that Cemware 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. Use MATLAB functions by just visiting website mathfreeon.com. MATLAB compatible, freely usable, online platform services. As of October 2016, 80,000 users from 180 countries are enjoying our platform service.