Although the ServiceLoader provides a general mechanism to return instances of classes based on their interface type, there are the three specific problems that prevent its general use with OSGi:

To solve these problems, the OSGi Enterprise Specification Release 5 provides the Service Loader Mediator, implemented by the Apache Aries SPI-Fly bundle. This provides the following two key features:

In both cases, the consumer and producer need to opt-in explicitly through the use of entries in the MANIFEST.MF to ensure that bundles are weaved (or not) on demand. The weaving bundle org.apache.aries.spifly.dynamic.bundle also needs to be installed and started prior to any consumers starting.

Create a plug-in project called com.packtpub.e4.advanced.loader.producer. This does not need an Activator and will be a standard OSGi bundle that targets Standard OSGi.

Create a class in the com.packtpub.e4.advanced.loader.producer package called HelloWorldRunnable that implements Runnable:

package com.packtpub.e4.advanced.loader.producer;
public class HelloWorldRunnable implements Runnable {
  public void run() {
    System.out.println("Hello World");
  }
}

Create a META-INF/services/java.lang.Runnable file with the following content in order to register it as a service for the ServiceLoader:

com.packtpub.e4.advanced.loader.producer.HelloWorldRunnable

This is enough for the ServiceLoader to find it with ServiceLoader.load, but in order for it to work in an OSGi runtime, the bundle needs to have additional OSGi metadata. Add the following to the META-INF/MANIFEST.MF file:

Require-Capability:
 osgi.extender;
  filter:="(osgi.extender=osgi.serviceloader.registrar)"

This expresses a dependency on the OSGi Service Loader Mediator (provided by SPI-Fly). If this dependency is missing, the bundle will fail to resolve.

By default, all services under the META-INF/services/ directory will be made available. If a single service type should be exported, it can be expressed with Provide-Capability on the osgi.serviceloader:

Provide-Capability:
 osgi.serviceloader;osgi.serviceloader=java.lang.Runnable

Multiple instances of the same interface need no extra configuration lines; all of the instances in the java.lang.Runnable file will be exported. If there are multiple service types (in other words, multiple files under the META-INF/services/ directory), they can be represented as follows:

Provide-Capability:
 osgi.serviceloader;osgi.serviceloader=java.lang.Runnable,
 osgi.serviceloader;osgi.serviceloader=java.util.Comparator

To run the producer, some prerequisite bundles must be acquired. These can be downloaded from Maven Central or from the book's GitHub repository at https://github.com/alblue/com.packtpub.e4.advanced/.

The necessary bundles are as follows:

Import these into the Eclipse workspace by navigating to File | Import | Plug-in Development | Plug-ins and Fragments, and then choose the directory that the prerequisite bundles have been downloaded into, as illustrated in the following screenshots:

Click on Next and select all of the available bundles by choosing Add All, followed by Finish:

To run the producer, create a new Launch Configuration by navigating to Run | Run Configurations … menu. Click on OSGi Framework and hit the New button to create a new configuration called ServiceLoader Producer Only:

Add the following bundles from the Workspace:

Add the following bundles from the Target Platform:

Run the framework by clicking on Run.

Using the console, look at the producer bundle. It should declare that it has registered the Runnable instance as an OSGi service:

osgi> ss | grep producer
4 ACTIVE com.packtpub.e4.advanced.loader.producer_1.0.0.qualifier
osgi> bundle 4
com.packtpub.e4.advanced.loader.producer_1.0.0.qualifier [4]
 Id=4, Status=ACTIVE
 "Registered Services"
 {java.lang.Runnable}={
  .org.apache.aries.spifly.provider.implclass=
  com.packtpub.e4.advanced.loader.producer.HelloWorldRunnable,
  serviceloader.mediator=7, service.id=46}

In this case, the serviceloader.mediator service property is 7, and bundle 7 is the SPI-Fly implementation:

osgi> bundle 7
org.apache.aries.spifly.dynamic.bundle_1.0.0 [7]

Create another plug-in project called com.packtpub.e4.advanced.consumer, this time with an Activator that looks like the following code:

package com.packtpub.e4.advanced.loader.consumer;
import java.util.ServiceLoader;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
public class Activator implements BundleActivator {
  public void start(BundleContext context) throws Exception {
    ServiceLoader<Runnable> sl=ServiceLoader.load(Runnable.class);
    Runnable runnable = sl.iterator().next();
    runnable.run();
  }
  public void stop(BundleContext context) throws Exception {
  }
}

When the bundle starts, the Activator will look for implementations of the Runnable interface, and then run them. The iterator.next method will fail if there are no implementations available, which will prevent the consumer bundle from starting if a Runnable instance cannot be found.

When run, the bundle fails because the client has not been processed to hook the ServiceLoader.load call to look for OSGi specific services.

To fix this, the consumer bundle needs to register the following as a generic capability in the META-INF/MANIFEST.MF file:

Require-Capability: 
 osgi.extender;
  filter:="(osgi.extender=osgi.serviceloader.processor)"

This ensures there is a processor present, and calls to ServiceLoader.load will be replaced with a call to an appropriate OSGi handler routine. Now, when the client bundle is started, Hello World should be printed out when the framework starts up.

As with the producer, it is possible to constrain the consumer such that it only allows lookup for implementations of a specific interface:

Require-Capability:
 osgi.extender;
  filter:="(osgi.extender=osgi.serviceloader.processor)",
 osgi.serviceloader;
  filter:="(osgi.serviceloader=java.lang.Runnable)";
  cardinality:=multiple

Also, as with the producer, if multiple services are required, then these can be added by adding additional osgi.serviceloader capability requirements.

The filter should not be used to represent a disjunction or a conjunction of filters, which would either say "An instance that satisfies either X or Y" or "An instance that satisfies both X and Y."

Instead, there needs to be two separate requirement constraints, the bundle needs X and the bundle needs Y. For example, to require both a Runnable and a List:

Require-Capability:
 osgi.extender;
  filter:="(osgi.extender=osgi.serviceloader.processor)",
 osgi.serviceloader;
  filter:="(osgi.serviceloader=java.lang.Runnable)";
  cardinality:=multiple
 osgi.serviceloader;
  filter:="(osgi.serviceloader=java.util.List)";
  cardinality:=multiple

To run the consumer, create a new Launch Configuration by navigating to Run | Run Configurations … menu. Click on OSGi Framework and hit the New button to create a new configuration called ServiceLoader Producer And Consumer:

Add the following bundles from the Workspace:

Add the following bundles from the Target Platform:

Run the framework by clicking on Run. It should display Hello World in the console as the client bundle is activated and acquires the registered producer service:

Hello World
osgi>