In questo articolo continuiamo la trattazione di OSGi, e in particolare vediamo alcuni esempi di implementazione di alcuni servizi dell’OSGi service compendium e qualche esempio di integrazione OSGi-EJB.

Introduzione

Le specifiche OSGi definiscono un ambiente di servizi modulari che permettono di implementare servizi in maniera standardizzata, seguendo l’approccio component-oriented.

Si tratta dunque di uno standard che permette di implementare dei servizi definiti mediante dei moduli che espongono solamente il codice inerente il contratto da implementare.

Accanto allo standard OSGi (OSGi Core Framework), nel precedente articolo abbiamo visto come sia stato definito un secondo standard che descrive dei servizi aggiuntivi che potrebbero essere offerti da un runtime environment. Essi formano l’OSGi Compendium Service.

Il Compendium definisce dei servizi estremamente utili che qualunque sviluppatore di bundle OSGi si potrebbe/vorrebbe implementare “in casa”: ecco quindi che il Compendium permette di avere questi servizi già pronti senza doverli reimplementare ogni volta.

In questo articolo forniamo degli esempi di utilizzo di alcuni servizi del Compendium e anche degli esempi di integrazione con CDI/EJB. Iniziamo ora a vedere il Blueprint Container, il Declarative Services e il JNDI Service. Infine vedremo un esempio di utilizzo di un servizio OSGi all’interno di un Session Bean.

Blueprint Container

Il Blueprint Container permette di definire dei servizi OSGi e di legarli assieme via IoC “alla Spring” senza avere a che fare con le interfacce OSGi.

Supponiamo di dover definire due servizi, A e B, ognuno dei quali ha al suo interno dei “backed bean” BeanA e BeanB. BeanB ha al suo interno un riferimento all’istanza di BeanA. Per definire i due servizi e i due bean, utilizziamo un file XML di configurazione molto simile a quelli utilizzati da Spring:

           xmlns_xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi_schemaLocation="http://www.osgi.org/xmlns/blueprint/v1.0.0 
           http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd">
 
            ="org.jboss.test.osgi.example.blueprint.bundle.BeanA" init-method="init">
 
    
 
  
 
              interface="org.jboss.test.osgi.example.blueprint.bundle.ServiceA">
 
  
 
 
  
 
    
 
      
 
    
 
  
 
  
 

I servizi A e B sono definiti come segue:

public interface ServiceB {
 
  BeanA getBeanA();
 
}

Il servizio A fornisce un riferimento al BeanA, mentre il servizio B ritorna solamente il riferimento al MbeanServer:

public interface ServiceA {
 
  MBeanServer getMbeanServer();
 
}

BeanA e BeanB sono dei semplici POJO che contengono solamente il metodo di inizializzazione,  le proprietà che devono essere valorizzate dal contenitore e i rispettivi getter/setter:

public class BeanA implements ServiceA {
 
  private MBeanServer mbeanServer;
 
  public BeanA() { }
 
  public void init() { }
 
  public MBeanServer getMbeanServer() {
 
    return mbeanServer;
 
  }
 
  public void setMbeanServer(MBeanServer mbeanServer) {
 
    this.mbeanServer = mbeanServer;
 
  }
 
}
 
 
 
public class BeanB implements ServiceB {
 
  private BeanA beanA;
 
  public BeanB() { }
 
  public void init() { }
 
  public BeanA getBeanA() {
 
    return beanA;
 
  }
 
  public void setBeanA(BeanA beanA) {
 
      this.beanA = beanA;
 
  }
 
}

Come si vede, non si fa mai riferimento al BundleActivator n��� tanto meno al ciclo di vita di un bean OSGi.

Test con Arquillan

Costruiamo ora il bundle con i due servizi e testiamolo con Arquillan. Prima di tutto creiamo il TestCase per il Blueprint:

@RunWith(Arquillian.class)
 
public class BlueprintTestCase {
 
…
 
  @ArquillianResource
 
  Deployer deployer;
 
  @ArquillianResource
 
  BundleContext context;
 
…
 
}

In questo modo abbiamo creato un test case JUnit che utilizza Arquillan (@RunWith), le risorse deployer e context vengono valorizzate da Arquillan e sono rispettivamente il servizio di deployment del bundle e il contesto OSGi. Adesso creiamo il bundle OSGi da deployare:

  @Deployment
 
  public static JavaArchive blueprintProvider() {
 
    final JavaArchive archive 
                = ShrinkWrap.create(JavaArchive.class, "blueprint-tests");
 
    archive.addClasses(ProvisionerSupport.class, BlueprintSupport.class);
 
    archive.addClasses(BeanA.class, ServiceA.class,
                                 BeanB.class, ServiceB.class);
 
    archive.addAsResource("repository/aries.blueprint.feature.xml");
 
    archive.addAsResource("repository/jbosgi.jmx.feature.xml");
 
    archive.setManifest(new Asset() {
 
      @Override
 
      public InputStream openStream() {
 
        OSGiManifestBuilder builder = OSGiManifestBuilder.newInstance();
 
        builder.addBundleSymbolicName(archive.getName());
 
        builder.addBundleManifestVersion(2);
 
        builder.addImportPackages(XRepository.class, Repository.class, 
                                            XResource.class, Resource.class, 
                                            XResourceProvisioner.class);
 
        builder.addDynamicImportPackages(BlueprintContainer.class,
                                                   MBeanServer.class);
 
        builder.addImportPackages(ServiceTracker.class);
 
        builder.addExportPackages(ServiceA.class);
 
        return builder.openStream();
 
      }
 
    });
 
    return archive;
 
  }

Come si vede si crea un archivio con le nostre classi (ServiceA, ServiceB, BeanA e BeanB), si rendono disponibili le feature Blueprint (aries.blueprint.feature.xml) e JMX (jbosgi.jmx.feature.xml) mediante due file XML che elencano molte capabilities (sono repository di capabilities), tra cui quelle per il servizio Blueprint e JMX.

Un ulteriore bundle

Adesso definiamo un altro bundle da installare: questo bundle contiene i servizi Blueprint e JMX che ci servono per poter attivare il bundle che abbiamo appena definito:

  @Deployment(name = BLUEPRINT_BUNDLE, managed = false, testable = false)
 
  public static JavaArchive testBundle() {
 
    final JavaArchive archive 
                = ShrinkWrap.create(JavaArchive.class, BLUEPRINT_BUNDLE);
 
    archive.addAsResource("blueprint/blueprint-example.xml", 
                                    "OSGI-INF/blueprint/blueprint-example.xml");
 
    archive.setManifest(new Asset() {
 
      @Override
 
      public InputStream openStream() {
 
        OSGiManifestBuilder builder = OSGiManifestBuilder.newInstance();
 
        builder.addBundleSymbolicName(archive.getName());
 
        builder.addBundleManifestVersion(2);
 
        builder.addImportPackages("org.osgi.service.blueprint;
                                            version=‘[1.0.0,2.0.0)'");
 
        builder.addImportPackages(BlueprintContainer.class,
                                            MBeanServer.class);
 
        builder.addImportPackages(ServiceA.class);
 
        return builder.openStream();
 
      }
 
    });
 
    return archive;
 
  }

Il file blueprint-example.xml è il file XML che abbiamo definito di sopra: contiene le definizioni dei servizi A e B e dei backing bean BeanA e BeanB.

In questo bundle viene definito un import del package ServiceA.class, questo ci serve per definire una dipendenza tra questo bundle e il primo che abbiamo definito. In questa maniera installare e far partire il bundle BLUEPRINT_BUNDLE permette di farli partire entrambi.

Dopo di ciò si installano le capabilities che ci interessano:

  @Test
 
  @InSequence(0)
 
  public void addBlueprintSupport() throws Exception {
 
    ProvisionerSupport provisioner = new ProvisionerSupport(context);
 
    provisioner.installCapabilities(IdentityNamespace.IDENTITY_NAMESPACE,
                                   "aries.blueprint.feature", "jbosgi.jmx.feature");
 
  }

Il test

E ora siamo pronti per eseguire il test vero e proprio:

  @Test
 
  @InSequence(1)
 
  public void testBlueprintContainer() throws Exception {
 
    InputStream input = deployer.getDeployment(BLUEPRINT_BUNDLE);
 
    Bundle bundle = context.installBundle(BLUEPRINT_BUNDLE, input);
 
    try {
 
      bundle.start();
 
      BlueprintContainer container 
                  = BlueprintSupport.getBlueprintContainer(bundle);
 
      assertNotNull("BlueprintContainer available", container);
 
      ServiceReference srefA 
                  = context.getServiceReference(ServiceA.class);
 
      assertNotNull("ServiceA not null", srefA);
 
      ServiceA serviceA = context.getService(srefA);
 
      MBeanServer mbeanServer = serviceA.getMbeanServer();
 
      assertNotNull("MBeanServer not null", mbeanServer);
 
      ServiceReference srefB 
                  = context.getServiceReference(ServiceB.class);
 
      assertNotNull("ServiceB not null", srefB);
 
      ServiceB serviceB = context.getService(srefB);
 
      BeanA beanA = serviceB.getBeanA();
 
      assertNotNull("BeanA not null", beanA);
 
    } finally {
 
      bundle.uninstall();
 
    }
 
  }

Come si vede si installa il bundle del Blueprint, si fa partire il contesto e, infine, si prendono i riferimenti ai servizi e si testano i BeanA e BeanB per verificare che non siano nulli.

Declarative Services

Vediamo ora un semplice esempio di uso del Declarative Service. Supponiamo di voler creare e installare un servizio OSGi di comparazione di oggetti:

public class SampleComparator implements Comparator