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

Java IoT: Article

Component Models in Java | Part 2

OSGi Component Model

OSGi is the latest component model to join the bandwagon of component models, which provides a platform for component oriented development and assembly. OSGi framework is a standards based platform whose specifications are provided by the OSGi Alliance (www.osgi.org, formerly OSGi was referred as Open Services Gateway Initiative). OSGi Alliance is an industry backed nonprofit organization which was founded in March 1999. The OSGi specification has gone through many releases and the current major version in use is 4 and version 5 has been introduced recently.

The OSGi defines a dynamic module system for Java. This offers help for Java's modularity problems by providing better control to the code structure, manage the lifecycle of the code and a complete loosely coupled approach that is much needed for component-oriented development.

The OSGi specification consists of two parts:

  • OSGi Framework
  • OSGi Standard services

The OSGi framework is the OSGi runtime environment that provides all the functionality as per the specifications. Applications are deployed and executed in the OSGi framework. The OSGi framework provides an API for the development of components. There are a number of framework implementations and some of the popular ones are Eclipse Equinox, Apache Felix and Knoplerfish. OSGi standard services define reusable services that should be provided as part of the development platform implementation. There are three conceptual layers in OSGi framework:

  • Module layer - Responsible for packaging and sharing code
  • Lifecycle layer - Responsible for managing the lifecycle of deployed module during runtime
  • Service layer - Responsible for dynamic service publication, searching and binding

OSGi Bundle
An OSGi bundle is a deployment module in the form of a JAR file. A module in OSGi parlance is known as a bundle. Bundles contain class files and resource files, similar to the regular JAR file in Java, but in addition they contain manifest information that contains metadata about the bundle. Apart from the regular JAR file's manifest contents, a bundle's manifest file has OSGi specific information such as module name, version number, dependencies, etc., thus giving better modularity and easy maintainability. Bundles are more powerful than JAR files in enforcing module boundaries, because a bundle needs to explicitly define what portion of its internal code is externally visible. Similarly, a bundle must explicitly declare any external dependencies that it has with the code exposed by other bundles. A bundle must have a unique identity - Bundle Name and Version.

The OSGi framework matches the exports and imports of deployed bundles to dynamically wire the entire application. This process of bundle resolution ensures consistency among the different bundles in terms of versions and other constraints. An application in OSGi is nothing but a collection of bundles with explicitly defined dependencies. A bundle is deployed in OSGi framework once it is developed.

OSGi Service Registry
The OSGi Service registry promotes service oriented programming. The service registry provides service publication service discovery and service binding. The bundles deployed in the OSGi framework can leverage the service registry later for publishing and consuming services. A bundle providing a service publishes the service in the OSGi Service Registry. A service is defined by a Java Interface, which represents a conceptual contract between the provider and consumer. A potential consumer can use the registry to search for providers of a particular service. Once if finds a service provider, it can bind and use the service. Services layer in OSGi facilitates one more level of dynamism other than bundles. Just as bundles can be added and removed in a running application, the Services can appear and go dynamically in a runtime application.

OSGi Component
As discussed earlier, a bundle is the deployment unit in OSGi component model. A bundle is a JAR file that contains:

  • Class files
  • Resource files
  • Manifest file (with additional metadata)

The class files are typically the interface and the implementation which constitutes the component. The manifest will have additional metadata as shown below:

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: com.demo.helloWorld

Bundle-SymbolicName: com.demo.helloWorld

Bundle-Version: 1.0.0.qualifier

Bundle-Activator: com.demo.Activator

Bundle-Vendor: PIRAM

Bundle-RequiredExecutionEnvironment: JavaSE-1.7

Import-Package: org.osgi.framework;version="1.3.0"

Bundle-ActivationPolicy: lazy

The OSGi Framework provides an inbuilt API called BundleActivator which helps the bundle to hook its own lifecycle management. The BundleActivator interface has two methods - start() and stop() which are invoked when the bundle is started and stopped respectively. Any bundle can implement this interface to check its own life cycle. The bundle could perform actions as specified in the start and stop methods of the Activator class. The use of bundle as a component for building application on the OSGi framework does not just depend on the bundle doing the work whenever it is started or stopped. The bundle needs to be able to expose certain functionality as provided interfaces and it needs to consume functionalities as per the require interfaces. Thus a collection of bundles made into an assembly should be able to work together to form a system. Generally the provided interface will be created as a separate bundle and the implementations can be wired dynamically by the OSGi runtime from the implementation bundles. There can be more than one implementation, the wiring happens depending on the runtime.

Example to understand OSGi Component Model
The OSGi component model can be understood with the same shopping Cart example discussed in the earlier models.

Figure 3: OSGi Component Model - Cart Component Example

The Cart application in this example is created with the following bundles for better modularity and maintainability.

  1. Interface Bundle (com.online.shopping)
  2. Implementation Bundle (CartImpl)
  3. Client Bundle (CartClient)

The Cart component is comprised of interface bundle and implementation bundle. The interface bundle (com.online.shopping) defines an interface ICart. This interface will be used by the implementation bundle to invoke the exposed services. The client bundle will use the interface for invoking the required services which gets bounded to the implementation bundle by the service registry.

Interface Bundle
The interface bundle contains the interface ICart for the Cart component and is defined as below:

package com.online.shopping;

import java.util.Collection;

public interface ICart {
public void addItem(Product product, int quantity);
public Collection<Product> listItems();    
public double getTotalPrice();
public void clearCart();

This bundle has ONLY the interface and its helper class and it exports the com.online.shopping package as shown in the manifest file below:

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: CartIntf
Bundle-SymbolicName: CartIntf
Bundle-Version: 1.0.0.qualifier
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: org.osgi.framework;version="1.3.0"
Export-Package: com.online.shopping

The structure of the bundle jar file is as below:

Figure 4: Structure of Interface Bundle

Implementation Bundle
ICart interface is implemented by the class CartImpl, whose code as demonstrated below:

package com.online.shopping.impl;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import com.online.shopping.ICart;
import com.online.shopping.Product;

public class CartImpl implements ICart {
Map<Product, Integer> items = new HashMap<Product, Integer>();      

public void addItem(Product product, int quantity) {
if(items.containsKey(product)) {
quantity +=items.get(product);
items.put(product, quantity);


public Collection<Product> listItems() {

return items.keySet();


public double getTotalPrice() {
double totalPrice = 0;
for(Product product: items.keySet()) {
totalPrice+=product.getPrice()* items.get(product);           
return totalPrice;

public void clearCart() {


The CartImpl is the class in the implementation bundle that implements the ICart interface and provides the ICart service implementation. In the implementation bundle, the interface com.online.shopping.ICart is not added to the CLASSPATH, but imported by the OSGi framework. This bundle imports the interface bundle as explained in the MANIFEST.MF below:

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: CartImpl
Bundle-SymbolicName: CartImpl
Bundle-Version: 1.0.0.qualifier
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: com.online.shopping,
Service-Component: META-INF/component.xml

The implementation bundle is exposed as a declarative service component. From the manifest file, it is evident that the bundle is not exported as a package, but it is exposed as a service with the entry - Service-Component that this is exposed as a component and the component description is available in component.xml. With the help of such XML files, components declare their provided services. The OSGi framework helps to publish the CartImpl as a service in the OSGi service registry. The component.xml is as below:

<?xml version="1.0" encoding="UTF-8"?>
<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="CartImpl">
<implementation class="com.online.shopping.impl.CartImpl"/>
<provide interface="com.online.shopping.ICart"/>

The ICart is exposed as a service and the service is implemented by the CartImpl implementation class. Looking at the component.xml, it is clear that the component provides the ICart service. The component declares the implementation class and the provided interface. The declarative services in the OSGi framework publish the service at the execution time after the bundle is activated. The structure of the JAR file of the bundle is as follows:

Figure 5: Structure of Implementation Bundle

Client Bundle
The client bundle is supposed to consume the services exposed by the ICart service implementation and consume it. The client bundle is another component that imports the com.online.shopping package and consumes the service through OSGi service registry. The client bundle's manifest looks as below:

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: CartClient
Bundle-SymbolicName: CartClient
Bundle-Version: 1.0.0.qualifier
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: com.online.shopping,
Service-Component: META-INF/component.xml

The client is also a component which consumes the services provided by the ICart component.

Figure 6: Structure of Client Bundle

The component.xml in client bundle has reference to the ICart service interface.

<?xml version="1.0" encoding="UTF-8"?>
<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="CartClient">
<implementation class="com.client.CartClient"/>
<reference bind="gotService" cardinality="1..1" interface="com.online.shopping.ICart" name="ICart" policy="dynamic" unbind="lostService"/>

Apart from the interface reference, the component.xml also refers to some methods called ‘gotService' and ‘lostService' during binding and unbinding of service references. These are the methods defined in the client class which will be invoked with the associated service references into the service object. This allows the component to find out the services without retrieving them. The declarative specifications in OSGi framework defines the methods where the service reference will be injected. The component service policy may be static or dynamic. In static policy, the service reference is injected once and not changed until the component is deactivated. Where as in the dynamic policy, the component is notified whenever the service comes or goes utilizing the true dynamism. In the example, it is dynamic. The client invokes the ICart service as follows:

package com.client;

import java.util.Collection;

import org.osgi.framework.ServiceReference;
import org.osgi.service.component.ComponentContext;

import com.online.shopping.ICart;
import com.online.shopping.Product;

public class CartClient {

ComponentContext context;
ServiceReference reference;
ICart cart;

public void activate(ComponentContext context) {
System.out.println("Activate Component");

if(reference!= null) {
cart = (ICart)context.locateService("ICart", reference);

Product product = new Product();
cart.addItem(product, 20);

Product newProduct = new Product();
newProduct.setName("Enterprise OSGi");
cart.addItem(newProduct, 10);

Collection<Product> productItems = cart.listItems();
for(Product items: productItems) {
System.out.println(items.getName()+"******"+ items.getPrice());             

System.out.println("Total Price of Cart Items: "+cart.getTotalPrice());



public void gotService(ServiceReference reference) {
System.out.println("Bind Service");
this.reference = reference;

public void lostService(ServiceReference reference) {
System.out.println("unbind Service");
this.reference = null;           


The client has defined three methods:

  • activate - part of declarative services API. This method is invoked when this component is activated. The ComponentContext is used to locate the ICart with the injected service reference.
  • gotService - user defined method as available in the component.xml, this method is invoked with the service reference (using dependency injection) when the service object is binded.
  • lostService - user defined method as mentioned in the client component.xml, this method is invoked with the injected service reference when the service object is unbinded.

Figure 7: Cart Component Bundles Deployment in OSGi Container

The client is not even aware of the implementation bundle. If there are multiple implementations available for the same service, the service is bounded dynamically by the environment. If there is any change in the implementation, only the implementation bundle will undergo change. A revised bundle can provide additional services which can be consumed by clients. So replacing components is easier and will not affect any other component. This way, OSGi gives good modularity by de-coupling components and a pluggable dynamic service model which are much needed features of a component model.

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

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.

Latest Stories
Intelligent machines are here. Robots, self-driving cars, drones, bots and many IoT devices are becoming smarter with Machine Learning. In her session at @ThingsExpo, Sudha Jamthe, CEO of IoTDisruptions.com, will discuss the next wave of business disruption at the junction of IoT and AI, impacting many industries and set to change our lives, work and world as we know it.
@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 ...
SYS-CON Events announced today that eCube Systems, the leading provider of modern development tools and best practices for Continuous Integration on OpenVMS, will exhibit 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. eCube Systems offers a family of middleware products and development tools that maximize return on technology investment by leveraging existing technical equity to meet evolving business needs. ...
Join Impiger for their featured webinar: ‘Cloud Computing: A Roadmap to Modern Software Delivery’ on November 10, 2016, at 12:00 pm CST. Very few companies have not experienced some impact to their IT delivery due to the evolution of cloud computing. This webinar is not about deciding whether you should entertain moving some or all of your IT to the cloud, but rather, a detailed look under the hood to help IT professionals understand how cloud adoption has evolved and what trends will impact th...
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...
operations aren’t merging to become one discipline. Nor is operations simply going away. Rather, DevOps is leading software development and operations – together with other practices such as security – to collaborate and coexist with less overhead and conflict than in the past. In his session at @DevOpsSummit at 19th Cloud Expo, Gordon Haff, Red Hat Technology Evangelist, will discuss what modern operational practices look like in a world in which applications are more loosely coupled, are deve...
Web Real-Time Communication APIs have quickly revolutionized what browsers are capable of. In addition to video and audio streams, we can now bi-directionally send arbitrary data over WebRTC's PeerConnection Data Channels. With the advent of Progressive Web Apps and new hardware APIs such as WebBluetooh and WebUSB, we can finally enable users to stitch together the Internet of Things directly from their browsers while communicating privately and securely in a decentralized way.
All clouds are not equal. To succeed in a DevOps context, organizations should plan to develop/deploy apps across a choice of on-premise and public clouds simultaneously depending on the business needs. This is where the concept of the Lean Cloud comes in - resting on the idea that you often need to relocate your app modules over their life cycles for both innovation and operational efficiency in the cloud. In his session at @DevOpsSummit at19th Cloud Expo, Valentin (Val) Bercovici, CTO of So...
Enterprises have been using both Big Data and virtualization for years. Until recently, however, most enterprises have not combined the two. Big Data's demands for higher levels of performance, the ability to control quality-of-service (QoS), and the ability to adhere to SLAs have kept it on bare metal, apart from the modern data center cloud. With recent technology innovations, we've seen the advantages of bare metal erode to such a degree that the enhanced flexibility and reduced costs that cl...
With an estimated 50 billion devices connected to the Internet by 2020, several industries will begin to expand their capabilities for retaining end point data at the edge to better utilize the range of data types and sheer volume of M2M data generated by the Internet of Things. In his session at @ThingsExpo, Don DeLoach, CEO and President of Infobright, discussed the infrastructures businesses will need to implement to handle this explosion of data by providing specific use cases for filterin...
Security, data privacy, reliability, and regulatory compliance are critical factors when evaluating whether to move business applications from in-house, client-hosted environments to a cloud platform. Quality assurance plays a vital role in ensuring that the appropriate level of risk assessment, verification, and validation takes place to ensure business continuity during the migration to a new cloud platform.
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...
In his session at Cloud Expo, Robert Cohen, an economist and senior fellow at the Economic Strategy Institute, will provide economic scenarios that describe how the rapid adoption of software-defined everything including cloud services, SDDC and open networking will change GDP, industry growth, productivity and jobs. This session will also include a drill down for several industries such as finance, social media, cloud service providers and pharmaceuticals.
DevOps is speeding towards the IT world like a freight train and the hype around it is deafening. There is no reason to be afraid of this change as it is the natural reaction to the agile movement that revolutionized development just a few years ago. By definition, DevOps is the natural alignment of IT performance to business profitability. The relevance of this has yet to be quantified but it has been suggested that the route to the CEO’s chair will come from the IT leaders that successfully ma...
Ask someone to architect an Internet of Things (IoT) solution and you are guaranteed to see a reference to the cloud. This would lead you to believe that IoT requires the cloud to exist. However, there are many IoT use cases where the cloud is not feasible or desirable. In his session at @ThingsExpo, Dave McCarthy, Director of Products at Bsquare Corporation, will discuss the strategies that exist to extend intelligence directly to IoT devices and sensors, freeing them from the constraints of ...