Welcome!

XML Authors: Gilad Parann-Nissany, Carmen Gonzalez, Yeshim Deniz, Pat Romanski, Mike Kavis

Related Topics: Java, XML, Wireless, SOA & WOA, Websphere, Weblogic, AJAX & REA

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

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

@Override

public Collection<Product> listItems() {

return items.keySet();

}

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

@Override
public void clearCart() {
items.clear();
}

}

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,
org.osgi.framework;version="1.6.0"
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"/>
<service>
<provide interface="com.online.shopping.ICart"/>
</service>
</scr:component>

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,
org.osgi.framework;version="1.6.0",
org.osgi.service.component;version="1.1.0"
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"/>
</scr:component>

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();
product.setName("OSGi");
product.setPrice(550.00);
cart.addItem(product, 20);

Product newProduct = new Product();
newProduct.setName("Enterprise OSGi");
newProduct.setPrice(400.00);
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());

cart.clearCart();
}

}

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.


@ThingsExpo Stories
Explosive growth in connected devices. Enormous amounts of data for collection and analysis. Critical use of data for split-second decision making and actionable information. All three are factors in making the Internet of Things a reality. Yet, any one factor would have an IT organization pondering its infrastructure strategy. How should your organization enhance its IT framework to enable an Internet of Things implementation? In his session at Internet of @ThingsExpo, James Kirkland, Chief Architect for the Internet of Things and Intelligent Systems at Red Hat, described how to revolutioniz...
The 3rd International Internet of @ThingsExpo, co-located with the 16th International Cloud Expo - to be held June 9-11, 2015, at the Javits Center in New York City, NY - announces that its Call for Papers is now open. The Internet of Things (IoT) is the biggest idea since the creation of the Worldwide Web more than 20 years ago.
The security devil is always in the details of the attack: the ones you've endured, the ones you prepare yourself to fend off, and the ones that, you fear, will catch you completely unaware and defenseless. The Internet of Things (IoT) is nothing if not an endless proliferation of details. It's the vision of a world in which continuous Internet connectivity and addressability is embedded into a growing range of human artifacts, into the natural world, and even into our smartphones, appliances, and physical persons. In the IoT vision, every new "thing" - sensor, actuator, data source, data con...
SYS-CON Events announced today that Gridstore™, the leader in hyper-converged infrastructure purpose-built to optimize Microsoft workloads, will exhibit at SYS-CON's 16th International Cloud Expo®, which will take place on June 9-11, 2015, at the Javits Center in New York City, NY. Gridstore™ is the leader in hyper-converged infrastructure purpose-built for Microsoft workloads and designed to accelerate applications in virtualized environments. Gridstore’s hyper-converged infrastructure is the industry’s first all flash version of HyperConverged Appliances that include both compute and storag...
"Matrix is an ambitious open standard and implementation that's set up to break down the fragmentation problems that exist in IP messaging and VoIP communication," explained John Woolf, Technical Evangelist at Matrix, in this SYS-CON.tv interview at @ThingsExpo, held Nov 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA.
The Internet of Things will put IT to its ultimate test by creating infinite new opportunities to digitize products and services, generate and analyze new data to improve customer satisfaction, and discover new ways to gain a competitive advantage across nearly every industry. In order to help corporate business units to capitalize on the rapidly evolving IoT opportunities, IT must stand up to a new set of challenges. In his session at @ThingsExpo, Jeff Kaplan, Managing Director of THINKstrategies, will examine why IT must finally fulfill its role in support of its SBUs or face a new round of...
The Internet of Things promises to transform businesses (and lives), but navigating the business and technical path to success can be difficult to understand. In his session at @ThingsExpo, Sean Lorenz, Technical Product Manager for Xively at LogMeIn, demonstrated how to approach creating broadly successful connected customer solutions using real world business transformation studies including New England BioLabs and more.
How do APIs and IoT relate? The answer is not as simple as merely adding an API on top of a dumb device, but rather about understanding the architectural patterns for implementing an IoT fabric. There are typically two or three trends: Exposing the device to a management framework Exposing that management framework to a business centric logic Exposing that business layer and data to end users. This last trend is the IoT stack, which involves a new shift in the separation of what stuff happens, where data lives and where the interface lies. For instance, it's a mix of architectural styles ...
An entirely new security model is needed for the Internet of Things, or is it? Can we save some old and tested controls for this new and different environment? In his session at @ThingsExpo, New York's at the Javits Center, Davi Ottenheimer, EMC Senior Director of Trust, reviewed hands-on lessons with IoT devices and reveal a new risk balance you might not expect. Davi Ottenheimer, EMC Senior Director of Trust, has more than nineteen years' experience managing global security operations and assessments, including a decade of leading incident response and digital forensics. He is co-author of t...
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 at Hookflash, will walk through the shifting landscape of traditional telephone and voice services ...
The definition of IoT is not new, in fact it’s been around for over a decade. What has changed is the public's awareness that the technology we use on a daily basis has caught up on the vision of an always on, always connected world. If you look into the details of what comprises the IoT, you’ll see that it includes everything from cloud computing, Big Data analytics, “Things,” Web communication, applications, network, storage, etc. It is essentially including everything connected online from hardware to software, or as we like to say, it’s an Internet of many different things. The difference ...
The 3rd International @ThingsExpo, co-located with the 16th International Cloud Expo - to be held June 9-11, 2015, at the Javits Center in New York City, NY - announces that it is now accepting Keynote Proposals. The Internet of Things (IoT) is the most profound change in personal and enterprise IT since the creation of the Worldwide Web more than 20 years ago. All major researchers estimate there will be tens of billions devices - computers, smartphones, tablets, and sensors - connected to the Internet by 2020. This number will continue to grow at a rapid pace for the next several decades.
The 3rd International Internet of @ThingsExpo, co-located with the 16th International Cloud Expo - to be held June 9-11, 2015, at the Javits Center in New York City, NY - announces that its Call for Papers is now open. The Internet of Things (IoT) is the biggest idea since the creation of the Worldwide Web more than 20 years ago.
We are reaching the end of the beginning with WebRTC, and real systems using this technology have begun to appear. One challenge that faces every WebRTC deployment (in some form or another) is identity management. For example, if you have an existing service – possibly built on a variety of different PaaS/SaaS offerings – and you want to add real-time communications you are faced with a challenge relating to user management, authentication, authorization, and validation. Service providers will want to use their existing identities, but these will have credentials already that are (hopefully) i...
The Internet of Things will greatly expand the opportunities for data collection and new business models driven off of that data. In her session at @ThingsExpo, Esmeralda Swartz, CMO of MetraTech, discussed how for this to be effective you not only need to have infrastructure and operational models capable of utilizing this new phenomenon, but increasingly service providers will need to convince a skeptical public to participate. Get ready to show them the money!
The Internet of Things is tied together with a thin strand that is known as time. Coincidentally, at the core of nearly all data analytics is a timestamp. When working with time series data there are a few core principles that everyone should consider, especially across datasets where time is the common boundary. In his session at Internet of @ThingsExpo, Jim Scott, Director of Enterprise Strategy & Architecture at MapR Technologies, discussed single-value, geo-spatial, and log time series data. By focusing on enterprise applications and the data center, he will use OpenTSDB as an example t...
"There is a natural synchronization between the business models, the IoT is there to support ,” explained Brendan O'Brien, Co-founder and Chief Architect of Aria Systems, in this SYS-CON.tv interview at the 15th International Cloud Expo®, held Nov 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA.
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.
DevOps Summit 2015 New York, co-located with the 16th International Cloud Expo - to be held June 9-11, 2015, at the Javits Center in New York City, NY - announces that it is now accepting Keynote Proposals. The widespread success of cloud computing is driving the DevOps revolution in enterprise IT. Now as never before, development teams must communicate and collaborate in a dynamic, 24/7/365 environment. There is no time to wait for long development cycles that produce software that is obsolete at launch. DevOps may be disruptive, but it is essential.
Scott Jenson leads a project called The Physical Web within the Chrome team at Google. Project members are working to take the scalability and openness of the web and use it to talk to the exponentially exploding range of smart devices. Nearly every company today working on the IoT comes up with the same basic solution: use my server and you'll be fine. But if we really believe there will be trillions of these devices, that just can't scale. We need a system that is open a scalable and by using the URL as a basic building block, we open this up and get the same resilience that the web enjoys.