jsp-develop.de presents:

JSP meets Middleware (CORBA)
von shark,  08.07.2001 11:55:15
Im ersten Teil des Artikels "JSP meets Middleware" wurden die Grundlagen für die Anbindung der Java Server Pages Technologie an Middleware Systeme besprochen. Das nachfolgende Beispiel zeigt, wie von einer JSP-Seite eine Service Methode, die in einem CORBA Server abläuft, aufgerufen werden kann.

Ausgehend von der folgenden IDL Datei "corba.idl" erzeugt man Java Klassendateien (Stubs), um von einem CORBA Client auf die Service Methoden eines CORBA Servers zuzugreifen.

IDL-Datei "corba.idl":
------------------------------
module CorbaApp
{
  interface JspToCorba
  {
    string CorbaService();
  };
};

Nach Aufruf des "idltojava" Compilers in einer DOS Box werden die entsprechenden Java Klassen erzeugt.

Aufruf des IDL Compilers:
-------------------------------------
idltojava corba.idl

Nach dem Compiler-Durchlauf werden die folgenden Java Dateien in dem Verzeichnis "CorbaApp" erzeugt:

JspToCorbaHolder.java
JspToCorbaHelper.java
JspToCorba.java
_JspToCorbaStub.java
_JspToCorbaImplBase.java

Die Java Dateien compiliert man mit dem Java Compiler zu Klassendateien.

Aufruf des Java Compilers:
--------------------------------------
javac *.java

Nachdem die Klassendateien erzeugt wurden, kopiert man das komplette Verzeichnis in den Java Classpath (falls vor der Kompilierung noch nicht geschehen).

Danach schreibt man die Klasse CorbaServant. Die Klasse CorbaServant enthält die Service Methoden des CORBA Servers (konform wie in der der "corba.idl" deklariert).

Source Code der Klasse Corba Servant:
---------------------------------------------------------
import CorbaApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;

// CorbaServant ist von der Klasse _JspToCorbaImplBase abgeleitet
class CorbaServant extends _JspToCorbaImplBase
{
  // Service Methode des CORBA Servers
  public String CorbaService()
  {
    return("Service Methode des CORBA Servers aufgerufen ...");
  }
}

Nachdem die Klasse CorbaServant realisiert wurde, programmiert man den CORBA Server und den CORBA Client.

Source Code des CORBA Servers:
--------------------------------------------------
import CorbaApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;

public class CorbaServer
{
  public static void main(String args[])
  {
    try
    {
      // Object Request Broker initialisieren   
      ORB orb = ORB.init(args, null);
     
      // Instanz der Klasse CorbaServant erzeugen
      CorbaServant oCorbaServant = new CorbaServant();
     
      // Naming Context ermitteln
      org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
      NamingContext nmRef        = NamingContextHelper.narrow(objRef);
     
      // Bind der Obbjektreferenz im Naming Service durchfuehren
      NameComponent nmComponent = new NameComponent("Corba","");
      NameComponent path[]      = {nmComponent};
      nmRef.rebind(path, oCorbaServant);
     
      // Instanz der Klasse Object erzeugen
      java.lang.Object oSync = new java.lang.Object();
     
      System.out.println("CORBA Server gestartet ...\n");
     
      // Auf Anfragen vom Client warten
      synchronized(oSync)
      {
         oSync.wait();
      }           
    }
    catch(Exception ex)
    {
      ex.printStackTrace();
    }
  }
}

Source Code des CORBA Clients:
-------------------------------------------------
package CorbaApp;

import CorbaApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;

public class CorbaClient
{
  public JspToCorba initCorba(String pstrValues[])
  {
    try
    {
      // Object Request Broker initialisieren   
      ORB orb = ORB.init(pstrValues, null);
           
      // Naming Context ermitteln
      org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
      NamingContext nmRef        = NamingContextHelper.narrow(objRef);
     
      // Auflösung der Obbjektreferenz im Naming Service
      NameComponent nmComponent = new NameComponent("Corba","");
      NameComponent path[]      = {nmComponent};
      JspToCorba corbaRef      = JspToCorbaHelper.narrow(nmRef.resolve(path));

      return(corbaRef);                     
    }
    catch(Exception ex)
    {
      ex.printStackTrace();
    }
   
    return(null);
  }

  public String callServiceMethod(String pstrWhich, JspToCorba poCorbaRef)
  {
    if(pstrWhich.equals("ServiceMethod"))
    {
      // Aufruf der Service Methode im CORBA Server
      String strCorbaMessage = poCorbaRef.CorbaService();
     
      return(strCorbaMessage);
    }

    return(null);
  }
}

Der CORBA Client enthält die Methode "initCorba" zur Initialisierung des CORBA Systems und die Methode "callServiceMethod" zum Aufruf eines Services im CORBA Server. Nach dem Übersetzen des Corba Servers und Clients kopiert man den Client (wenn noch nicht geschehen) in das entsprechende Verzeichnis des Java Klassenpfades (Classpath). In unserem Fall ist es das Verzeichnis "CorbaApp", in dem auch die Dateien, die von dem IDL Compiler erzeugt wurden liegen.

Abschliessend bindet man den CORBA Client in eine JSP-Seite ein und startet das CORBA System.

Source Code der JSP-Seite:
----------------------------------------
<%@ page language= "java" contentType="text/html"%>
<%@ page import = "CorbaApp.*"%>
<%
  // Instanz der Klasse CORBA Client erzeugen
  CorbaClient oCorbaClient = new CorbaClient();
 
  // CORBA Client initialisieren
  String strValues[] = {"-ORBInitialPort 900"}; 
  JspToCorba corbaRef = oCorbaClient.initCorba(strValues);
 
  // Pruefen ob die Objetreferenz gueltig ist
  if(null != corbaRef)
  {
    // Service Methode aufrufen und Message lesen
    String strMessage = oCorbaClient.callServiceMethod("ServiceMethod", corbaRef);

    // Pruefen ob die Message vorhanden ist
    if(null != strMessage)
    {
      // Message ausgeben
      out.println(strMessage);
    }
    else
    {
      out.println("Message konnte nicht gelesen werden!");
    }
  }
  else
  {
    out.println("CORBA Client Initialisierung fehlgeschlagen!");
  }
%>

Das CORBA System startet man folgendermaßen:
-------------------------------------------------------------------------

(1) CORBA Naming Service in einer DOS Box starten: "start tnameserv"

(2) CORBA Server in der DOS Box starten: "start java CorbaServer -ORBInitialPort 900"

(3) JSP-Seite im Browser aufrufen

Der CORBA Naming Service wird in unserem Beispiel ohne einen speziellen Port gestartet, sodass automatisch der Standardport "900" verwendet wird.

Abschliessend ist noch anzumerken, dass der IDL Compiler "idltojava" einen C Präprozessor benötigt. Es muss also eine C/C++ Umgebung z.B.: Visual Studio installiert worden sein.

Das besprochene Beispiel ist eine sehr gute Alternative zu Enterprise Java Beans und für den Fall das ein kommerzielles CORBA System verwendet wird, bestens geeignet für die Integration von Applikationen, die nicht mit der Programmiersprache Java implementiert worden sind.

Die Kombination eines CORBA Systems mit einem Application Server ist eine gute Basis. Für diesen Fall, kann das CORBA System die Brücke zwischen bereits im Unternehmen etablierten Anwendungen und einer neuen zu realisierenden E-Business Lösung sein.
URL dieses Beitrags:
http://www.jsp-develop.de/forumbeitrag/view/119/