Experimentieren mit OSGi auf der Server-Seite

Ich habe OSGi eher zufällig kennengelernt. Ich musste eine Präsentation halten und ein Kollege schlug mir vor, mich mit OSGi zu beschäftigen. Und als ich anfing, mich damit zu beschäftigen, war ich ziemlich überrascht, wie einfach sich damit einige der Probleme lösen lassen, mit denen wir bei der Entwicklung von Webanwendungen konfrontiert sind. Es gibt so viele gute Artikel und Blogs, die eine große Menge an Material über OSGi bereitstellen. Sie sind in der Referenz aufgeführt. Eines der Konzepte von OSGi, das mich wirklich fasziniert hat, war die Möglichkeit, dass Bundles Dienste exportieren können, die von anderen Bundles genutzt werden können, ohne dass sie etwas über das exportierende Bundle wissen. OSGi sorgt dafür, indem es eine Service Registry einführt, in der das exportierende Bundle die Schnittstellen registriert, die es zur Verfügung stellen möchte, und jedes andere Bundle, das diese Schnittstellen nutzen möchte, kann einfach in der Registry nachsehen, um die Implementierung zu verwenden. Das andere Konzept von OSGi, das ich ebenfalls interessant fand, war die Art und Weise, wie OSGi die Versionsverwaltung nutzt, um die Verwendung verschiedener Versionen derselben Java-Klasse innerhalb eines Projekts zu ermöglichen. Deshalb habe ich diesen Blog ins Leben gerufen, um diese Konzepte näher zu erforschen. An dieser Stelle ist es wichtig zu erwähnen, dass die Zielgruppe dieses Blogs Personen sind, die neu in OSGi sind. Auch die verwendeten Beispiele sind sehr einfach und sollen nur den Kontrollfluss von einem Paket zum anderen zeigen.

Um zu zeigen, wie OSGi die Service Registry verwendet, habe ich 2 Bundles (Service und Dao) erstellt, die ihre Schnittstellen registrieren. Es gibt 2 weitere Bundles (ServiceServlet und DaoServlet), die auf die Registry verweisen, um nach diesen Schnittstellen zu suchen. Ich habe Servlets erstellt, die die Methoden der Schnittstellen aufrufen, um zu zeigen, wie wir ein dynamisches webfähiges Projekt mit OSGi erstellen können. Schließlich möchte ich die Versionsverwaltung zeigen. Ich habe 2 verschiedene Bundles erstellt, die das gleiche Paket und die gleiche Java-Klasse, aber unterschiedliche Methoden haben. Diese Bundles werden unterschiedliche Versionen haben und wir werden sehen, wie diese 2 Methoden nebeneinander existieren können. Einrichtung der Umgebung: Voraussetzungen:

1. Sie müssen bereits Java 1.5 oder höher in Ihrem Systempfad installiert haben. Für meine Installation verwende ich Java 1.6.
2. Sie müssen bereits mit Eclipse vertraut sein.
3. Sie müssen bereits damit vertraut sein, wie man ein Bundle erstellt und wie man OSGi-Befehle verwendet. Wenn Sie damit nicht vertraut sind, sollten Sie zunächst verstehen, wie Sie ein einfaches OSGi-Bundle erstellen.

Für dieses Setup verwende ich Eclipse Europa, das mit dem Equinox-Framework geliefert wird, das für die Ausführung von OSGi erforderlich ist. Sie können auch die neueste Version von Eclipse herunterladen. Der OSGi-Container Equinox ist bereits in Eclipse 3.2 oder höher enthalten. Falls Sie Eclipse 3.1 oder eine frühere Version verwenden, müssen Sie das Eclipse Equinox Plugin herunterladen. Für dieses Setup verwenden wir Jetty als Server. Equinox kann jedoch auch für die Verwendung mit Tomcat konfiguriert werden. Einrichten der Ausführungsumgebung

Stellen Sie sicher, dass Sie die JVMs, die Sie verwenden möchten, installiert haben und dass Sie jede OSGi-Ausführungsumgebung einer der JVMs zugeordnet haben. Gehen Sie zu Fenster --> Voreinstellungen --> Installierte JREs --> Ausführungsumgebungen.

Sie können den Quellcode herunterladen. Importieren Sie die Pakete in Eclipse und gehen Sie direkt zum ersten Szenario über.

• Erstellen Sie ein Bundle SampleDao mit 2 Paketen.
  1. 1. Das Paket com.sample.sampledao enthält eine Schnittstelle MyDao, die eine Methode List retrieveAllObjects() hat.

  public interface MyDao {
  public List retrieveAllObjects();
  }

  1. 1. Das Paket com.sample.sampledao.impl enthält den Aktivator für das Bundle sowie die Implementierung für die MyDao-Schnittstelle. Im Aktivator registrieren wir die Schnittstelle in der Serviceregistrierung, damit jedes Paket außerhalb des Bundles darauf zugreifen kann.

  public class Activator implements BundleActivator {
  private ServiceRegistrierung daoregistration;
  public void start(BundleContext context) throws Exception
  {
  System.out.println("innerhalb des sampleDao-Bündels");
  MyDao mydao = new MyDaoImpl();
  daoregistration = context.registerService(MyDao.class.getName(),
  mydao, null);
  }
  public void stop(BundleContext context) throws Exception
  {
  System.out.println("Außerhalb des sampleDao-Bündels");
  daoregistration.unregister();
  }
  }

  1. 1. Stellen Sie sicher, dass Sie den Aktivator auf der Registerkarte Übersicht der Manifest.MF hinzufügen.
  
  1. 1. Der Code für die Implementierung würde lauten. Lassen Sie den auskommentierten Code vorerst so, wie er ist.

  public class MyDaoImpl implements MyDao {
  public List retrieveAllObjects()
  {
  //Test test= new Test();
  System.out.println("Innerhalb von retrieveAllObjects von MyDao");
  //test.testMethod2();
  null zurückgeben;
  }
  }

  1. 1. Klicken Sie auf der Registerkarte Laufzeit der Manifest.MF auf die Schaltfläche Hinzufügen im Bereich Exportierte Pakete und wählen Sie com.sample.sampledao, um es zu exportieren. Klicken Sie nun auf Eigenschaften und wählen Sie die Version 1.0.0.
  
• Erstellen Sie ein Bundle SampleService mit 2 Paketen.
  1. 1. Das Paket com.sample.sampleservice hat eine Schnittstelle MyService.java mit der Methode List findAllObjects().

  public interface MyService
  {
  public List findAllObjects();
  }

  1. 1. Das Paket com.sample.sampleservice.impl enthält den Aktivator für das Bundle sowie die Implementierung für die Schnittstelle MyService. Im Aktivator registrieren wir die Schnittstelle in der Service-Registry, damit jedes Paket außerhalb des Bundles darauf zugreifen kann. Außerdem verweisen wir auf die Serviceregistrierung, um nach dem von der Dao-Schnittstelle bereitgestellten Dienst zu suchen.

  public class Activator implements BundleActivator {
  private ServiceRegistrierung Registrierung;
  public static MyDao myDao;
  ServiceReferenz daoServiceReferenz;
  public void start(BundleContext context) throws Exception
  {
  System.out.println("Innerhalb des Sampleservice-Bündels");
  MyService service = new MyServiceImpl();
  registration = context.registerService (MyService.class.getName(),
  service, null);
  daoServiceReference= context.getServiceReference(MyDao.class.getName());
  myDao =(MyDao)context.getService(daoServiceReference);
  }
  public void stop(BundleContext kontext) throws Exception
  {
  System.out.println("Außerhalb des Sampleservice-Bündels");
  registration.unregister();
  context.ungetService(daoServiceReference);
  }
  }

  Stellen Sie auch hier sicher, dass Sie den Aktivator auf der Registerkarte Übersicht der Manifest.MF hinzufügen. Gehen Sie auch zur Registerkarte Abhängigkeiten der Manifest.MF und importieren Sie das Paket com.sample.sampledao.
  1. 1. Die Implementierung der Service-Schnittstelle hat den folgenden Code. Wie zuvor lassen Sie den auskommentierten Code so stehen.

  public class MyServiceImpl implements MyService {
  MyDao myDao;
  public Liste findAllObjects()
  {
  // Test test = new Test();
  myDao = Activator.myDao;
  System.out.println("Innerhalb von findAllObjects von MyService");
  // test.testMethod1();
  return (myDao == null) ? null : myDao.retrieveAllObjects(); 
  }
  }

  1. Exportieren Sie das Paket com.sample.sampleservice auf der Registerkarte Runtime der Manifest.MF, wie in Schritt 1d geschehen.
• Erstellen Sie ein Bundle ServiceServlet mit einem Paket com.sample.service.
  1. 1. Um ein Servlet in einem Bundle zu erstellen, müssen Sie ein paar Schritte befolgen.
        1. 1. Rufen Sie die Datei Manifest.MF auf und wählen Sie die Registerkarte Abhängigkeiten.
           2. Klicken Sie auf die Schaltfläche Hinzufügen unter Automatisierte Verwaltung von Abhängigkeiten und wählen Sie javax.servlet aus der Liste der Bundles.
           3. Klicken Sie auf die Schaltfläche Hinzufügen neben Importierte Pakete und fügen Sie die JARs javax.servlet und javax.servlet.http hinzu.
        
     2. Der Aktivator für das Bundle sucht in der Diensteregistrierung nach der Implementierung der Schnittstelle MyService, und der Code für den Aktivator lautet wie folgt:

  public class ServletActivator implements BundleActivator {
  public static MyService myService;
  ServiceReferenz serviceReferenz;
  public void start(BundleContext context) throws Exception
  {
  System.out.println("Innerhalb von ServiceServlet");
  serviceReference= context.getServiceReference (MyService.class.getName());
  myService =(MyService)context.getService(serviceReference);
  }
  public void stop(BundleContext context) throws Exception
  {
  System.out.println("Outside Service Servlet");
  context.ungetService(serviceReference);
  }
  }

  1. 1. Erstellen Sie ein Servlet MyServlet im Paket com.sample.service. Der Servlet-Code sieht wie folgt aus:

    public class MyServlet extends HttpServlet
  {
  MyService myService;
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
  throws ServletException, IOException
  {
  resp.setContentType("text/html");
  PrintWriter pw = new PrintWriter (resp.getOutputStream());
  pw.println("Dieses Servlet wird in einem Service Servlet mit OSGi ausgeführt.");
  pw.println("Willkommen bei meinem Service Servlet");
  pw.println("");
  myService.findAllObjects();
  pw.close();
  }
  //@Override
  public void init() throws ServletException
  {
  System.out.println("innerhalb der init-Methode");
  myService = ServletActivator.myService;
  }
  }

  Dieses Servlet ruft die Methode findAllObjects der MyService-Schnittstelle auf.
  1. Um die Anwendung webfähig zu machen, müssen wir Erweiterungspunkte verwenden, um das Servlet zu registrieren.
     1. 1. Gehen Sie im Manifest-Assistenten auf die Registerkarte Übersicht und klicken Sie auf Erweiterungen.
     
     1. 1. Klicken Sie auf OK, um die Seite Erweiterungen anzuzeigen. Dadurch wird dem Assistenten für Manifeste eine Registerkarte Erweiterungen hinzugefügt, die sich von nun an automatisch öffnet.
        2. Klicken Sie auf die Schaltfläche Hinzufügen und setzen Sie den Filter auf "org.eclipse.equinox.http.registry.servlets". Vergessen Sie nicht, das Kontrollkästchen zu deaktivieren.
     
     1. 1. Geben Sie den Namen Ihrer Servlet-Klasse ein, geben Sie ihr einen Alias und speichern Sie Ihre Änderungen.
     Dadurch wird eine plugin.xml in Ihrer Manifest.MF erstellt.
• Erstellen Sie das Bundle Dao Servlet mit dem Paket com.sample.daoservlet.
  1. 1. Wiederholen Sie Schritt 3a, um javax.servlet und javax.http.servlet jar als Abhängigkeiten für das DaoServlet hinzuzufügen. Der Aktivator für das Bundle verwendet die Service-Registry, um nach der Implementierung der MyDao-Schnittstelle zu suchen

  public class DaoActivator implementiert BundleActivator
  {
  public static MyDao myDao;
  ServiceReferenz daoServiceReferenz;
  public void start(BundleContext context) throws Exception
  {
  System.out.println("Innerhalb von DaoServlet");
  daoServiceReference= context.getServiceReference(MyDao.class.getName());
  myDao =(MyDao)context.getService(daoServiceReference);
  }
  public void stop(BundleContext context) throws Exception
  {
  System.out.println("Outside Dao Servlet");
  context.ungetService(daoServiceReference);
  }
  }

  1. 1. Erstellen Sie ein Servlet DaoServlet im Paket com.sample.DaoServlet. Der Servlet-Code sieht wie folgt aus:

  public class MyServlet extends HttpServlet
  {
  MyService myService;
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
  throws ServletException, IOException
  {
  resp.setContentType("text/html");
  PrintWriter pw = new PrintWriter (resp.getOutputStream());
  pw.println("Dieses Servlet wird in einem Dao-Servlet mit OSGi ausgeführt.");
  pw.println("Willkommen bei meinem Dao-Servlet");
  pw.println("");
  myService.retreiveAllObjects();
  pw.close();
  }

  Dao Servlet ruft die Methode retrieveAllObjects von MyDao auf.
  1. Wiederholen Sie Schritt 3d, um das Servlet mit Erweiterungspunkten zu registrieren.
  Erstes Szenario: Wir haben eine Methode findAllObjects() in der Schnittstelle MyService. Diese Methode ruft retrieveAllObjects() der MyDao-Schnittstelle auf. Beide Schnittstellen sind in der Service-Registry registriert. Es ist an der Zeit, die bisher geleistete Arbeit zu testen. Aber bevor wir das tun, müssen wir noch einige Schritte durchführen.
  • Wählen Sie ein Projekt und klicken Sie auf Ausführen als --> Ausführungsdialog öffnen...
  • Wählen Sie die Registerkarte Argumente und fügen Sie -Dorg.osgi.service.http.port hinzu, um die Portnummer zuzuweisen. Ich habe Port 8081 für OSGi gewählt. Kehren Sie zur Registerkarte Bundles zurück, damit wir die Paketabhängigkeiten auswählen können.
  • Klicken Sie auf Alle löschen, um alle Bundles zu deselektieren. Wählen Sie nun alle Arbeitsbereich-Bundles aus.
  • Wählen Sie zusätzlich zu Ihren Projekten die folgenden Bundles aus:
    • javax.servlet
    • org.apache.commons.logging
    • org.apache.xerces
    • org.apache.xml.resolver
    • org.eclipse.core.jobs
    • org.eclipse.core.runtime.compatibility.registry
    • org.eclipse.equinox.common
    • org.eclipse.equinox.http.jetty
    • org.eclipse.equinox.http.registry
    • org.eclipse.equinox.http.servlet
    • org.eclipse.equinox.registry
    • org.eclipse.osgi
    • org.eclipse.osgi.services
    • org.mortbay.jetty
  • Sie können nun auf die Schaltfläche Ausführen klicken, um Ihr OSGi-Bundle mit einem eingebetteten Jetty-Server zu starten.
  • Klicken Sie nun auf Ausführen als---> OSGi Framework und Sie sollten sehen osgi> Jun 23, 2008 10:32:41 AM org.mortbay.http.HttpServer doStart INFO: Version Jetty/5.1.x Jun 23, 2008 10:32:41 AM org.mortbay.util.Container start INFO: Started org.mortbay.jetty.servlet.ServletHandler@1081d2e Jun 23, 2008 10:32:41 AM org.mortbay.util.Container start INFO: Started HttpContext[/,/] Jun 23, 2008 10:32:41 AM org.mortbay.http.SocketListener start INFO: Started SocketListener on 0.0.0.0:8081 osgi>
  • Um den Status der Bundles zu sehen, geben Sie ss an der Eingabeaufforderung osgi> ein. Dies zeigt die Bundle-ID sowie den Status des Bundles an. Sie können ein Bundle starten, indem Sie start eingeben.
  • Wenn Sie nun https://xebia.com/blog:8081/myservlet aufrufen, sollten Sie in der OSGi-Konsole so etwas wie This servlet is running in an Service Servlet using OSGi. Welcome to my Service Servletsehen, und Sie sollten die Ausgabe sehen: osgi> Inside findAllObjects of MyService Inside retrieveAllObjects of MyDao
  • Wenn Sie auf https://xebia.com/blog:8081/daoservlet gehen, sollten Sie so etwas sehen This servlet is running in an Dao Servlet using OSGi. Welcome to my Dao Servlet und in der OSGi-Konsole sollten Sie etwas wie das hier sehen: osgi> Inside retrieveAllObjects of MyDao
  Versionsverwaltung Um zu sehen, wie OSGi die 2 verschiedenen Versionen der gleichen Klasse verwaltet, erstellen wir 2 Bundles mit dem gleichen Paket und der gleichen Klasse.
• Erstellen Sie ein Bundle CheckVersion mit Standard-Activator. Erstellen Sie ein Paket com.sample.test innerhalb des Bundles.
  1. 1. Dieses Paket enthält eine Klasse Test.java mit der Methode testMethod1().

  public class Test {
  public void testMethode1() {
  System.out.println("Innerhalb der Methode 1 von Test");
  }
  }

  1. 1. Klicken Sie auf die Registerkarte Runtime in der Manifest.MF. Exportieren Sie das Paket com.sample.test. Klicken Sie auf Eigenschaften und wählen Sie die Version 1.0.0 des Pakets.
  
  1. Dekommentieren Sie den Aufruf von Test.test.Method1() in der Datei MyServiceImpl.java aus dem Paket com.sample.sampleservice.impl.
  2. Klicken Sie in der Manifest.MF des Bundles SampleService auf die Registerkarte Abhängigkeiten und importieren Sie das Paket com.sample.test. Wählen Sie das neu importierte Paket aus und klicken Sie auf die Eigenschaften. Daraufhin wird ein Dialogfeld angezeigt, in dem Sie die Version des Pakets auswählen können. Geben Sie 1.0.0 als Version des ausgewählten Pakets ein.

Erstellen Sie ein Bundle CheckVersion2 mit Standard-Activator. Erstellen Sie ein Paket com.sample.test in diesem Bundle.

1. 1. Erstellen Sie eine Klasse Test.java in diesem Paket. Diese Klasse wird die Methode testMethod2() haben.

public class Test
{
public void testMethod2() {
System.out.println("Innerhalb von Methode 2 von Test");
}
}

1. 1. Klicken Sie auf die Registerkarte Runtime in der Manifest.MF. Exportieren Sie das Paket com.sample.test. Klicken Sie auf Eigenschaften und wählen Sie die Version 2.0.0 des Pakets.

1. 1. Dekommentieren Sie den Aufruf von Test.test.Method2() in der Datei MyDaoImpl.java.
   2. Klicken Sie in der Manifest.MF des Bundles SampleDao auf die Registerkarte Abhängigkeiten und importieren Sie das Paket com.sample.test. Wählen Sie das neu importierte Paket aus und klicken Sie auf die Eigenschaften. Daraufhin wird ein Dialogfeld angezeigt, in dem Sie die Version des Pakets auswählen können. Geben Sie 2.0.0 als Version des ausgewählten Pakets ein.

Abschließendes Szenario Wir können prüfen, wie dieselbe Klasse mit 2 verschiedenen Methoden und unterschiedlichen Versionen aus einem Paket heraus aufgerufen werden kann.

• Markieren Sie ein Projekt und wählen Sie Ausführen als --> Ausführungsdialog öffnen. Stellen Sie sicher, dass Sie alle Pakete im Arbeitsbereich auswählen.
• Klicken Sie auf Anwenden und Ausführen.
• Dies würde eine osgi-Eingabeaufforderung öffnen. Geben Sie ss in die osgi> ein und es wird eine Liste der Pakete angezeigt.
• Wenn Sie nun https://xebia.com/blog:8081/myservlet aufrufen, sollten Sie in der OSGi-Konsole so etwas wie This servlet is running in an Service Servlet using OSGi. Welcome to my Service Servletsehen, und Sie sollten die Ausgabe sehen: osgi> inside init method Inside findAllObjects of MyService test Objectcom.sample.test.Test@194d372 Inside Method 1 of Test Inside retrieveAllObjects of MyDao Inside Method 2 of Test
• Wenn Sie auf https://xebia.com/blog:8081/daoservlet gehen, sollten Sie etwas wie dieses This servlet is running in an Dao Servlet using OSGi. Welcome to my Dao Servlet sehen und in der OSGi-Konsole sollten Sie etwas wie dieses sehen: inside init method Inside retrieveAllObjects of MyDao Inside Method 2 of Test

In diesem Beitrag haben Sie erfahren, wie Sie die OSGi-Ausführungsumgebung einrichten und wie OSGi die Service Registry zur Verwaltung von Abhängigkeiten und zur Versionsverwaltung nutzt. In meinem nächsten Beitrag werde ich versuchen, von hier aus weiterzumachen und über einige andere coole Funktionen von OSGi zu schreiben. REFERENZEN:

• https://java.dzone.com/news/there-place-osgitm-enterprise- https://java.dzone.com/news/there-place-osgi-enterprise-ap-0 Oracle WebLogic Server https://byteworksinc.blogspot.com/2008/02/summary-this-post-covers-setting-up-an.html