Shulou(Shulou.com)06/02 Report--

This article is to share with you about how to analyze OSGi services. The editor thinks it is very practical, so I share it with you. I hope you can get something after reading this article.

OSGi service

As we mentioned earlier, the OSGi architecture is very suitable for us to implement service-oriented applications (SOA). It allows Bundles to export services, while other Bundles can consume these exported services without knowing anything about the source Bundles. Because OSGi has the ability to hide real service implementation classes, it provides a good combination of classes and interfaces for service-oriented applications.

In the OSGi framework, the source Bundle registers the POJO object in the OSGi container, which does not have to implement any interface or inherit any superclass, but it can register under one or more interfaces and provide services to the outside world. The target Bundle can request a service registered under an interface from the OSGi container, and once it finds the service, the target Bundle binds the service to the interface and can invoke methods in the interface. Let's give an example so that we can better understand these concepts related to OSGi.

5.1. Export service

In this section, we will update HelloService Bundle so that it can export objects of the HelloServiceImpl class as services, as follows:

1) modify the MANIFEST.MF file in com.javaworld.sample.HelloService Bundle to import the org.osgi.framework package.

2) create a new Java class com.javaworld.sample.impl.HelloServiceActivator.java, whose source code is shown in listing 7

Source code listing 7. HelloServiceActivator.java

Public class HelloServiceActivator implements BundleActivator {ServiceRegistrationhelloServiceRegistration; public void start (BundleContext context) throws Exception {HelloService helloService = newHelloServiceImpl (); helloServiceRegistration=context.registerService (HelloService.class.getName (), helloService, null);} public void stop (BundleContext context) throws Exception {helloServiceRegistration.unregister ();}}

Note that in the source Bundle, we should export the service using the BundleContext.registerService () method, which takes three parameters:

A) the * parameters of this method are the interface name of the service you want to register. If you want to register your service under multiple interfaces, you need to create a new String array to hold the interface names, and then pass this array as * * parameters to the registerService () method. In the sample code, we want to export our service to the HelloServer interface name

B) the second parameter is the actual Java object of the service you want to register. In the sample code, we export the object of the HelloServiceImpl class as a service

C) the third parameter is the property of the service, which is a Dictionary object. If multiple Bundle export services have the same interface name, the target Bundle can use these attributes to filter the source Bundle to find the service it is interested in.

3) *, modify the MANIFEST.MF file in HelloServiceBundle and change the value of the Bundle-Activator attribute header to com.javaworld.sample.service.impl.HelloServiceActivator.

Now HelloService Bundle can export the HelloServiceImpl object. When the OSGi container starts HelloServiceBundle, it gives control to the HelloServiceActivator.java class, and HelloServiceActivator registers the HelloServiceImpl object as a service. Next, let's start creating consumers of the service.

5.2. Import servic

In this section, we will modify the HelloWorld Bundle developed above to make it a consumer of HelloService services. You mainly need to modify the Activator.java code in HelloWorldBundle, as shown in listing 8 of the source code:

Source code listing 8. Activator.java in HelloWorld Bundle

Packagecom.javaworld.sample.helloworld; importorg.osgi.framework.BundleActivator; importorg.osgi.framework.BundleContext; importorg.osgi.framework.ServiceReference; importcom.javaworld.sample.service.HelloService; publicclass Activator implements BundleActivator {ServiceReference helloServiceReference; public void start (BundleContext context) throws Exception {System.out.println ("HelloWorldword!"); helloServiceReference=context.getServiceReference (HelloService.class.getName ()); HelloService helloService= (HelloService) context.getService (helloServiceReference); System.out.println (helloService.sayHello ()) } public void stop (BundleContext context) throws Exception {System.out.println ("Goodbye wordings!"); context.ungetService (helloServiceReference);}}

In the above code, the BundleContext.getServiceReference () method returns a ServiceReference object for the service registered under the HelloService interface. If there is more than one HelloService service, this method returns the service that ranks * (the ranking of the service is specified by the Constants.SERVICE_RANKING attribute). Once you have the ServiceReference object, you can call its BundleContext.getService () method to get the real service object.

You can run the example application above by referring to the method of running Bundle, please click "running run..." Menu and make sure that the two Bundle HelloWorld and HelloService are selected. When you start HelloServiceBundle, you will see "InsideHelloServiceImple.sayHello ()" on the console, which is printed by the HelloServiceImpl.sayHello () method.

5.3. Create a service factory

In the previous section, we learned how to create a new Java object using the OSGi framework, register it as a service, and then let other Bundle consume the service. If you look at the HelloServiceActivator.start () method, you will notice that we created a new HelloServiceImp class object in the start () method, and then registered it under the name of the HelloService interface. After this registration, the OSGi container will return the same object when any other Bundle requests the HelloService service.

In most cases, there is nothing wrong with this implementation. But, for example, we want to return a different HelloServiceImpl object for each Bundle consumer, and for example, your service object is to open a database connection, but not immediately, but only when you really need it.

In both cases, our solution is to create a new class that implements the ServiceFactory interface and register the object of this class as a service, but not the actual service object. Once you have completed this step, when another Bundle requests the service, your ServiceFactory implementation class will take over the request, and ServiceFactory will create a new service object for each Bundle and delay the creation of the real service until someone really needs the service.

Next we will use ServiceFactory to update the com.javaworld.sample.HelloServiceBundle we developed above. The specific steps are as follows:

1) create a new factory class, HelloServiceFactory.java, with the source code shown in listing 9.

Listing 9 of the source code. HelloServiceFactory.java

Public class HelloServiceFactory implements ServiceFactory {private int usageCounter = 0; public Object getService (Bundle bundle,ServiceRegistration registration) {System.out.println ("Create objectof HelloService for" + bundle.getSymbolicName ()); usageCounter++; System.out.println ("Number ofbundles using service" + usageCounter); HelloService helloService = newHelloServiceImpl (); return helloService;} public void ungetService (Bundle bundle,ServiceRegistration registration, Object service) {System.out.println ("Release objectof HelloService for" + bundle.getSymbolicName ()); usageCounter-- System.out.println ("Number ofbundles using service" + usageCounter);}}

From the above code, we can see that the ServiceFactory interface defines two methods:

A) the getService () method: when a Bundle*** requests a service object using the BundleContext.getService (ServiceReference) method, the OSGi framework calls this method. In listing 9 of the source code, we use this method to create a new HelloServiceImpl object for each Bundle and return a different HelloServiceImpl object, which is cached if it is not the null,OSGi framework. If the same Bundle calls the BundleContext.getService (ServiceReference) method again, OSGi will return the same service object.

B) ungetService () method: when Bundle releases the service, the OSGi container can call this method to destroy the service object. In listing 9 of the source code, we use the usageCounter variable to track the number of service usage and print out the number of clients for the service.

2) modify the start () method of HelloServiceActivator.java in HelloService Bundle to register it under the ServiceFactory interface name instead of the HelloService interface. The detailed code is shown in listing 10:

Listing 10 of the source code. HelloServiceActivator.java in modified HelloServiceBundle

Package com.javaworld.sample.service.impl; importorg.osgi.framework.BundleActivator; importorg.osgi.framework.BundleContext; importorg.osgi.framework.ServiceRegistration; importcom.javaworld.sample.helloservice.HelloServiceFactory; importcom.javaworld.sample.service.HelloService; publicclass HelloServiceActivator implements BundleActivator {ServiceRegistrationhelloServiceRegistration; public void start (BundleContext context) throws Exception {HelloServiceFactory helloServiceFactory= new HelloServiceFactory (); helloServiceRegistration=context.registerService (HelloService.class.getName (), helloServiceFactory,null);} public void stop (BundleContext context) throws Exception {helloServiceRegistration.unregister ();}}

Now you can try out the sample code. You will notice that when HelloWorldBundle starts, the service counter changes to 1; when HelloWorldBundle stops, the number of service counters becomes 0.

5.4. Tracking service

In the "OSGi Services" section, you learned how to search for a service using its interface name. But what happens if multiple Bundle registers the service with the same interface name? At this point, the OSGi container will return the service that ranks *, that is, the service with the SERVICE_RANKING attribute value * at the time of registration. If multiple services have equal ranking values, the OSGi container returns the service with the lowest pid value.

However, if your service consumer needs to know when the service object under an interface is registered and unregistered, you should use the ServiceTracker class. Next, let's look at how to use the service tracker to modify our sample code, as follows.

1) modify the MANIFEST.MF file of HelloWorldBundle to import the org.osgi.util.tracker package

2) create a new class HelloServiceTracker.java

Source code listing 11.HelloServiceTracker.java

Public class HelloServiceTracker extends ServiceTracker {public HelloServiceTracker (BundleContext context) {super (context, HelloService.class.getName (), null);} public Object addingService (ServiceReference reference) {System.out.println ("Inside HelloServiceTracker.addingService" + reference.getBundle ()); return super.addingService (reference) } public void removedService (ServiceReference reference, Object service) {System.out.println ("Inside HelloServiceTracker.removedService" + reference.getBundle ()); super.removedService (reference, service);}}

In the constructor of the HelloSerivceTracker class above, you can see that we passed the HelloService interface name into its parent class, which means that HelloServiceTracker should track all services registered with the HelloService interface name, and HelloServiceTracker inherits from the ServiceTracker class and implements the following two methods:

A) addingService () method: this method will be called when Bundle registers the service with the interface name

B) removedService () method: this method will be called when Bundle unregisters a service under an interface name.

3) update our Activator.java class with the HelloServiceTracker class so that it manages the services instead of looking for them directly, as shown in listing 12.

Listing 12. Source code. Activator.java using HelloServiceTracker

Public class Activator implements BundleActivator {HelloServiceTracker helloServiceTracker; public void start (BundleContext context) throws Exception {System.out.println ("Hello wordings!"); helloServiceTracker= new HelloServiceTracker (context); helloServiceTracker.open (); HelloService helloService = (HelloService) helloServiceTracker.getService (); System.out.println (helloService.sayHello ()) } public void stop (BundleContext context) throws Exception {System.out.println ("Goodbye wordings!"); helloServiceTracker.close ();}}

We see that in the initial start () method, we first create a new HelloServiceTracker object, and then ask this object to track the service under the HelloService interface. At this point, we can call the getService () method to get the HelloService object.

If you try the sample code above, you will notice that when you start or stop HelloSerivceBundle, the OSGi container calls either the addingService () method or the removedService () method of the HelloServiceTracker object.

The above is how to analyze OSGi services. The editor believes that there are some knowledge points that we may see or use in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.