PDF 438K
Werbung
1 Fachhochschule Dortmund Prof. Dr. Frank M. Thiesing Komponentenorientierte Softwareentwicklung und Hypermedia SS04 Janeva: .NET meets J2EE Ruthild Klempel Allgemeine Informatik Matr.Nr. 7043018 Windscheidstrasse, 24 45147 Essen Tel. 0201/7203207 E-mail: [email protected] 2 Inhalt 1. Einleitung............................................................................................................................... 3 2. Einführung in Janeva..............................................................................................................3 3. Systemvoraussetzungen..........................................................................................................6 3.1 ... für die Entwicklung Janeva-basierter Anwendungen................................................... 6 3.2 ... für den Einsatz von Janeva-basierter Anwendungen....................................................8 4. Installation.............................................................................................................................. 8 5. Ein erstes Beispiel................................................................................................................ 11 5.1 Die J2EE-Seite............................................................................................................... 11 5.2 Die .NET-Seite............................................................................................................... 12 5.2.1 Der Client............................................................................................................. 12 5.2.2 Janeva-Klassenbibliotheken einbinden................................................................ 14 5.2.3 Janeva-Stubs generieren....................................................................................... 15 5.2.4 Die Ausführung des Clients................................................................................. 16 6. Fazit...................................................................................................................................... 18 Literaturverzeichnis...................................................................................................................19 Anhang...................................................................................................................................... 20 3 1. Einleitung Es ist Fakt, dass die .NET-Welt und die Java-Welt wenig miteinander integriert sind. Beide Technologien haben technische und kommerzielle Stärken und bieten viele Vorteile. Ein guter Ansatz wäre es, wenn beide Technologien nicht als Konkurrenten gesehen würden, sondern als Ergänzung füreinander.1 So müsste man sich nicht für eine der beiden Technologien entscheiden, sondern könnte die Vorteile der beiden Welten gleichzeitig nutzen. Und so kommt Janeva ins Spiel: eine einfache Möglichkeit um beide Technologien zu verbinden. Ziel dieser Ausarbeitung ist es, Entwickler, die sich zum ersten Mal mir der Software Janeva befassen möchten, bei den ersten Schritten zu begleiten und einen groben Überblick über die Funktionalität, Vorgehensweise und Vorteile dieser Software zu verschaffen. Es soll eine Entscheidungshilfe über den möglichen Einsatz dieser Software für potentielle JanevaAnwender sein. Diese Ausarbeitung hat keinen Anspruch auf Vollständigkeit. Es wird auf so viel eingegangen, wie es nötig ist, um ein erstes Beispiel mit Janeva zustande zu bekommen und um ein allgemeines Verständnis zu verschaffen. Im Folgenden wird hauptsächlich auf die Verbindung zwischen J2EE und .NET eingegangen. Die Verbindung zwischen CORBA-Komponenten und .NET wird hier nur grob aufgeführt. 2. Einführung in Janeva Janeva ermöglicht die Entwicklung von client- und server-seitigen Anwendungen für das . NET Framework, die auf server-seitigen J2EE/CORBA-Komponenten über das IIOPProtokoll (Internet Inter-ORB Protocol) zugreifen.2 „Dabei handelt es sich im Kern um eine Java-basierte CORBA-Implementierung, die die Borland-Entwickler mit Hilfe von Microsofts Visual J# in die .NET-Welt transformiert haben.“3 1 Vgl. The Middleware Company: High Performance .NET and J2EE Interoperability with Borland’s Janeva. S. 3. http://www.borland.com/products/white_papers/pdf/high_performance_dotnet_and_j2ee.pdf (06.05.04). 2 Vgl. Developers Guide. S. 11. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 3 Stahl, Michael: Über-Brückung, Borlands Janeva: Zugriff von .NET- auf J2EE- und CORBA-Objekte. In: iX 2/2004. S. 63. 4 Die Janeva-Laufzeitumgebung ist eine Sammlung von Klassenbibliotheken in Form von DLLDateien, die Klassen zur Verfügung stellt, um die Kommunikation zwischen .NET und J2EE/CORBA zu gewährleisten. „Die Laufzeitumgebung stellt die typischen CORBA und J2EE-API's dar die verwendet werden, um entfernte Objekte anzusprechen. Diese API's halten sich an die CLR-Regeln (Common Language Specification) von Microsoft, sodass sie von jeder .NET-Programmiersprache verwendet werden können.“4 Janeva generiert Client-Stubs bzw. Server-Skeletons um Methoden von J2EE- und CORBAObjekten aufzurufen. So werden die Interfaces zur Verfügung gestellt, die benötigt werden, um auf J2EE- bzw. CORBA-Komponenten zuzugreifen. Diese Stubs/Skeletons bilden die Schnittstelle zwischen .NET und J2EE- bzw. CORBA-Servern. „Somit ist der Zugriff auf J2EE/CORBA-Dienste für den .NET-Entwickler bzw. .NET-Tools transparent: Die J2EE/CORBA-Dienste werden wie ein beliebiger .NET-Dienst behandelt. NET-Entwickler brauchen keine Vorkenntnisse in Java, J2EE oder CORBA.“5 „.NET-Programmierern bleiben diese Details weitgehend verborgen, und sie können sich vollständig in der Welt des Managed .NET-Code bewegen, ohne in größerem Umfang mit CORBA oder J2EE in Berührung zu kommen.“6 Client-Stubs werden gebraucht um die Schnittstelle zwischen .NET-Clients und J2EE/CORBA-Komponenten zu bilden. Dementsprechend werden Server-Skeletons als Schnittstelle zwischen .NET-serverseitigen Komponenten und J2EE/CORBA-Komponenten verwendet, wie in Abb. 1 deutlich wird. 4 Developers Guide. S. 12-13. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 5 The Middleware Company: High Performance .NET and J2EE Interoperability with Borland’s Janeva. S. 5. http://www.borland.com/products/white_papers/pdf/high_performance_dotnet_and_j2ee.pdf (06.05.04). 6 Stahl, Michael: Über-Brückung, Borlands Janeva: Zugriff von .NET- auf J2EE- und CORBA-Objekte. In: iX 2/2004. S. 63. 5 Abb. 17 Die J2EE/CORBA-Server müssen nicht verändert werden, um mit den .NET-Clients bzw. -Servern zu kommunizieren. Alle Einstellungen erfolgen nur auf der .NET-Seite. Deshalb sind in Abb.1 keine grau-markierten Stellen in den J2EE/CORBA-Umgebungen. „Janeva bietet eine Lösung für die Interoperabilität, die weder zusätzliche Hardware- noch Software-Infrastruktur erfordert, um in die vorhandene Deployment-Umgebung integriert werden zu können. Dies minimiert Kosten und senkt Risiken. Janeva benötigt keine zusätzliche Entwicklungsarbeit für die Konnektivität, keine Änderungen an vorhandenen Backend-Systemen und keine Änderungen an vorhandenen IT- oder Geschäftsprozessen.“8 Janeva stellt zwei Arten von Compilern zur Verfügung, um die Stubs bzw. Skeletons zu generieren. Der CORBA-basierte Compiler generiert Stubs/Skeletons aus IDL-Dateien (Interface Definition Language), und der J2EE-basierte Compiler generiert Stubs/Skeletons aus Interfaces, die in Java-RMI-Dateien (Remote Method Invocation) bzw. in J2EEArchivdateien spezifiziert sind.9 Das Ergebnis ist ein C#-Code, der sich aber „an die Regeln der CLS (Common Language Specification) hält, sodass die Nutzung jeder .NET-Sprache grundsätzlich möglich ist“10. 7 Developers Guide. S. 12. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 8 Erhöhen Sie die Plattform Interoperabilität. S. 2. http://www.borland.com/janeva/pdf/jnva_datasheet.pdf (30.03.04). 9 Vgl. Developers Guide. S. 11. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 10 Stahl, Michael: Über-Brückung, Borlands Janeva: Zugriff von .NET- auf J2EE- und CORBA-Objekte. In: iX 2/2004. S. 63. 6 Abb.211 Um z. B. einen Client zu programmieren, der auf J2EE-Komponenten zugreift, müssen die EJB-Interfaces, die in Form einer .ear oder .jar-Datei vorliegen, in „.NET-Code“ umgewandelt werden (Client-Stub). Dies geschieht durch den J2EE-basiertern Compiler. Der Client greift über diesen jetzt in C#-Code vorliegenden Stub auf die EJB's. Die JanevaKlassenbibliotheken müssen in das .NET-Projekt eingebunden werden. Sind diese Voraussetzungen erfüllt, kann das .NET-Projekt kompiliert werden, wie in Abb. 2 zu sehen ist. 3. Systemvoraussetzungen 3.1... für die Entwicklung Janeva-basierter Anwendungen Um Janeva-basierte Anwendungen erfolgreich entwickeln zu können, muss folgende Software auf dem Entwicklungs-Rechner vorhanden sein: • .NET Framework: Da Janeva ein .NET-Produkt ist, wird das .NET Framework für die Ausführung benötigt. • Microsoft Visual J# .NET: Die Janeva-Kommunikations-Umgebung wurde in J# implementiert. Auch wenn die Clients in einer anderen Programmiersprache programmiert werden, müssen Microsoft Visual J# sowie die .NET-Laufzeitumgebung installiert sein. 11 The Middleware Company: High Performance .NET and J2EE Interoperability with Borland’s Janeva. S. 6. http://www.borland.com/products/white_papers/pdf/high_performance_dotnet_and_j2ee.pdf (06.05.04). 7 Für die richtige Ausführung von den Janeva-Tools und der Janeva-Laufzeitumgebung sollten Visual J# und das .NET Framework in derselben Versionsnummer sein.12 • Java Runtime Environment 1.4: Wird benötigt, damit der Java-basierte Compiler (java2cs) ausgeführt werden kann. (Anmerkung: JRE wird nicht für die Ausführung von JanevaClients benötigt, nur für die Entwicklung dieser Clients. Wenn bei der Entwicklung der java2cs-Compiler nicht benötigt wird, muss das JRE auch nicht vorhanden sein.13) Eine Entwickler-Lizenz (Development License) ist auch erforderlich, um Janeva-basierte Anwendungen zu entwickeln. Sie ist kostenlos, man darf aber Janeva nur auf einem Rechner für Testzwecke verwenden.14 Im Kapitel 4 wird näher darauf eingegangen, wie man die Lizenz bekommt und an Janeva anbindet. Wenn man das Microsoft Visual Studio .Net installiert, ist das .NET Framework schon darin enthalten. Die Sprache J# kann bei der Installation von Visual Studioauch mit installiert werden. Empfohlene Hardware: • Intel® Pentium® II-Klasse Prozessor 450 MHz (600 MHz oder mehr empfohlen) • 128 MB RAM (256 MB empfohlen) • 10 MB Festplattenspeicher (volle Installation)15 Betriebssysteme, die unterstützt werden: • Microsoft® Windows® Server 2003 • Microsoft® Windows® 2000 Server • Microsoft® Windows® 2000 Professional • Microsoft® Windows® XP™ Professional16 Anmerkung: Für diese Ausarbeitung wurde Janeva unter Microsoft® Windows® XP™ Home Edition getestet, und es haben sich keinerlei Probleme ergeben. 12 Vgl. Installation Guide. S. 10. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaInstallGuide.pdf (30.03.04). 13 Vgl. Readme. <Janeva 6.0-Installationsverzeichnis>readme.html 14 Vgl. License Terms. <Janeva 6.0-Installationsverzeichnis>license.rtf 15 Installation Guide. S. 9. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaInstallGuide.pdf (30.03.04). 16 Vgl. Installation Guide. S. 9. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaInstallGuide.pdf (30.03.04). 8 3.2... für den Einsatz Janeva-basierter Anwendungen Um Janeva-basierte Anwendungen auf verschiedenen Rechnern einsetzen zu können, wird auf den Rechnern, in denen die Anwendung laufen soll, folgendes benötigt: • Microsoft .NET Framework Redistributable Package • Microsoft Visual J# Redistributable Package • Janeva runtime libraries (Klassenbibliotheken): • • Borland.Janeva.Runtime.dll • Borland.Janeva.Private.dll • Borland.Janeva.Services.dll Janeva deployment license key (Lizensschlüssel)17: Janeva-Laufzeitlizenzen müssen für den Einsatz auf verschiedenen Rechnern bei Borland käuflich erworben werden.18 Es wird unterschieden zwischen Client-Runtime-Lizenzen und Server/CPU-Lizenzen.19 4. Installation Nachdem die benötigte Software, die im Abschnitt 3.1. beschrieben ist, installiert ist, kann Janeva installiert werden. Die heruntergeladene Janeva_60.zip20-Datei muss entpackt und die Setup.exe-Datei ausgeführt werden. Beim Herunterladen wird man aufgefordert, sich zu registrieren. An die bei der Registrierung angegebene E-mail-Adresse wird ein Lizenzschlüssel gesendet. Wie der Schlüssel eingebunden wird, wird später aufgeführt. In dem Verzeichnis, wo die Janeva_60.zip-Datei entpackt wurde, ist eine Datei namens JanevaInstallGuide.pdf, die eine Hilfestellung für den Installationsvorgang ist. Im Folgenden werden einige wichtige Aspekte der Installation aufgeführt. Wie in Abb.3 zu sehen ist, wird im Installationsdialog gefragt, welche Janeva-Komponenten installiert werden sollen. 17 Vgl. Developers Guide. S. 48. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 18 Vgl. Stahl, Michael: Über-Brückung, Borlands Janeva: Zugriff von .NET- auf J2EE- und CORBA-Objekte. In: iX 2/2004. S. 65. 19 Vgl. License Terms. <Janeva 6.0-Installationsverzeichnis>license.rtf. 20 Diese Datei kann heruntergeladen werden bei http://www.borland.com/products/downloads/download_janeva.html. 9 Abb. 3 Es ist empfehlenswert, alle Optionen anzukreuzen. Beim ankreuzen von Borland Janeva Runtime werden die Janeva-Klassenbibliotheken geliefert. In Borland Janeva Tools sind der Java-basierte Compiler und der IDL-basierte Compiler enthalten. Documents and Examples liefert Beispiele und die Dokumentation, wo die API's beschrieben werden und wichtige Informationen für Entwickler, die Janeva-basierte Anwendungen entwickeln möchten, enthalten sind. Borland Janeva for Visual Studio Addin gibt dem Entwickler die Möglichkeit, im Visual Studio .NET einige Janeva-Einstellungen zu verändern. Im nächsten Schritt wird gefragt, ob der Pfad des Janeva-bin-Verzeichnisses in die Umgebungsvariablen PATH einfügen werden soll. Es ist empfehlenswert, yes anzukreuzen. Janeva benötigt auch den Pfad zum JRE (Java Runtime Environment), falls der Java-basierte Compiler verwendet werden soll. Deshalb wird gefragt (Abb. 4), ob man den Pfad selbst eingeben will, ob er automatisch gesucht werden soll oder ob man ihn nicht angeben soll. 10 Abb. 4 Falls man die erste Option wählt, erscheint ein Dialog am Ende des Installationsvorgangs, wo der JRE-Pfad anzugeben ist. Falls man die zweite Option wählt und der Pfad trotzdem nicht gefunden wird, wird man am Ende auch aufgefordert, den Pfad anzugeben. Die dritte Option ist für den Fall, dass die Janeva-Laufzeitumgebung (Klassenbibliotheken) auf einem Produktiv-System installiert werden soll.21 Nachdem der Installationsprozess beendet ist, muss der Lizenzschlüssel, den man nach der Registrierung per E-Mail bekommen hat, in das Janeva-Installationsverzeichnis kopiert und nach borland.txt umbenannt werden. Falls man bei der Installation angekreuzt hat, dass das Addin für den Visual Studio .NET installiert werden soll, erscheinen im Visual Studio einige zusätzliche Konfigurationsmöglichkeiten, womit man Janeva-Einstellungen verändern kann. Dies erreicht man im Visual Studio unter dem Menü Extras – Optionen. Wenn man Borland Janeva anklickt, erscheint folgendes Fenster: 21 Vgl. Installation Guide. S. 17. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaInstallGuide.pdf (30.03.04). 11 Abb. 5 Jetzt sind alle Voraussetzungen erfüllt, um Janeva-Anwendungen zu programmieren. 5. Ein erstes Beispiel Im nachfolgenden Beispiel werden Microsoft Visual Studio .NET 2003 und Sun Java System Application Server Platform Edition 8, welche kompatibel zur J2EE 1.4-Plattform ist, verwendet. Wie dieses Beispiel mit anderen Programmierumgebungen und J2EE Servern durchzuführen ist, wird in dieser Ausarbeitung nicht behandelt. Die hier verwendete JanevaVersion ist die 6.0. Das Beispiel ist ein einfacher .NET-Client in der Sprache C#, der Methoden von einen EJB aufruft. 5.1 Die J2EE-Seite Um diesen EJB zur Verfügung zu stellen, der später von dem Client verwendet wird, muss das „Converter“-Beispiel von dem J2EE-Tutorial22 von Sun durchgeführt werden. Es handelt sich um einen EJB namens ConverterBean, der Methoden enthält, die die Umrechnung von Dollar nach Yen und von Yen nach Euro durchführen. 22 http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html (31.03.04), Kap. 24 12 Es werden zwei Interfaces zur Verfügung gestellt, um den Zugriff von außen zu ermöglichen. Der ConverterHome ist ein Home Interface, der dem Client erlaubt, eine Instanz von dem EJB zu erzeugen. Der Converter ist ein Remote Interface, der die Methoden definiert, die von einem Client aufgerufen werden dürfen. Um das Beispiel durchführen zu können, muss der J2EE Application Server gestartet und der Status von ConverterApp muss running sein (Siehe Abb. 6). Dies kann man überprüfen, wenn man den Deploytool23 startet. Im Baum muss unter Servers - localhost:484824 der Status von ConverterApp erscheinen. Abb. 6 Im Anhang dieser Ausarbeitung werden die Quelltexte zu dem Tutorial-Beispiel aufgeführt. 5.2 Die .NET-Seite 5.2.1 Der Client Das Ziel dieses Beispiels ist es, einen Client in .NET zu programmieren, der genauso funktioniert wie der Client vom J2EE-Tutorial (ConverterClient).25 Dazu muss ein neues Projekt im Visual Studio .NET erstellt werden unter Datei – Neu – Projekt... . Dann wird unter Projekttyp Visual C#-Projekte ein leeres Projekt einfügt. In diesem Beispiel wird das Projekt unter dem Namen JanevaConverterClient verwendet. Zusätzlich wird unter Datei – Neues Element hinzufügen... eine Codedatei mit dem Namen JanevaConverterClient.cs eingefügt. Folgender C#-Quellcode wird in diese Datei kopiert bzw. editiert: 23 Im Windows erreichbar unter Start – Programme – Sun – J2EE 1.4 SDK - Deploytool Die Port-Nummer muss nicht zwingend diese sein. Bei der Installation von dem J2EE Application Server wird zwar diese Nummer für den Admin-Port vorgeschlagen, man kann aber auch eine andere wählen. 25 Um die Quelltexte zu vergleichen, siehe Anhang. 24 13 using using using using System; J2EE.Naming; J2EE.Rmi; J2EE.Math; namespace converter { public class JanevaTest { static void Main(string[] args) { Context root = new InitialContext(args); object myServerHomeObject = root.Lookup("ConverterBean"); ConverterHome home = (ConverterHome) PortableRemoteObject.Narrow(myServerHomeObject, typeof(ConverterHome)); Converter currencyConverter = home.Create(); BigDecimal param=new BigDecimal(100); BigDecimal amount=currencyConverter.DollarToYen(param); Console.WriteLine(amount); amount=currencyConverter.YenToEuro(param); Console.WriteLine(amount); } } } In dem Client werden Janeva-API's verwendet, wie in folgende Anweisungen zu sehen ist: using J2EE.Naming; using J2EE.Rmi; using J2EE.Math; Dies sind einige der Namensräume, die Janeva zur Verfügung stellt. In der Programmzeile Context root = new InitialContext(args); wird ein Root-Kontext für den J2EE-Naming-Service instanziiert. Dabei sind in der Variablen args Server-Informationen wie IP-Adresse und Port-Nummer, die per Argument an das Programm übergeben werden. In der nächsten Zeile wird das EJBHome-Objekt, das auf dem Server liegt, gesucht: object myServerHomeObject = root.Lookup("ConverterBean"); In der Zeile ConverterHome home = (ConverterHome) PortableRemoteObject.Narrow(myServerHomeObject, 14 typeof(ConverterHome)); wird das gefundene Objekt myServerHomeObject auf dem Typ ConverterHome gebracht. Mit der Zeile Converter currencyConverter = home.Create(); wird eine neue Instanz des EJB kreiert. Der Interface Converter definiert die Methoden, die vom Client aufgerufen werden dürfen. Diese Methoden können von dem Objekt aus, das von der Variablen currencyConverter referenziert wird, aufgerufen werden.26 5.2.2 Janeva-Klassenbibliotheken einbinden Wenn man versucht, in diesem Stadium das Projekt zu kompilieren, wird es fehlschlagen. Ein Grund dafür ist, dass Janeva-spezifische Klassen (Assemblys) verwendet werden, die noch nicht eingebunden sind. Dieses Problem kann man beheben, indem man in Visual Studio .NET im ProjektmappenExplorer mit der rechten Maustaste auf Verweise klickt und den Menüpunkt Verweis hinzufügen auswählt. Dort wird die Komponente Janeva Runtime ausgewählt.27 Abb. 7 26 Vgl. Developers Guide. S. 23. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 27 Vgl. Developers Guide. S. 46-47. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 15 Wenn man jetzt versucht, das Projekt zu kompilieren, ist dieses Problem bereits behoben. 5.2.3 Janeva-Stubs generieren Das Kompilieren ist zu diesem Zeitpunkt noch nicht möglich. Der Grund dafür besteht darin, dass die EJB-Interfaces, die in diesem Client verwendet werden, noch nicht in .NET zur Verfügung stehen. Abb. 8 Um dies zu beheben wird zunächst die Datei ConverterApp.ear im Verzeichnis <J2EETutorial-Verzeichnis>\examples\ejb\converter in das .NET-Projekt-Verzeichnis kopiert. In diese Datei sind die benötigten EJB-Interfaces in Java-Code definiert. Dieser Code muss in . NET-Code umgewandelt werden (Janeva-Stub), damit man diese Interfaces verwenden kann. Im Kommandozeilenfenster wird im .NET-Verzeichnis folgender Befehl ausgeführt: <.NET Projekt-Verzeichnis>>java2cs -o ConverterApp.cs ConverterApp.ear Der Java-basierte Compiler java2cs wandelt den Java-Code aus der Datei ConverterApp.ear in C#-Code um. Die dabei neu entstandene Datei heisst ConverterApp.cs. Diese Datei erscheint im .NET-Projekt-Verzeichnis.28 28 siehe Developers Guide. S. 46. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 16 Anmerkung: um die Janeva-Compiler wie beschrieben benutzen zu können, muss das Janevabin-Verzeichnis in der Umgebungsvariablen PATH enthalten sein. Wenn man im JanevaInstallationsvorgang diese Option nicht angekreuzt hat, muss folgender Befehl im Kommandozeilenfenster ausgeführt werden, bevor man den Compiler aufruft: <aktuelles Verzeichnis>> set PATH=<JanevaInstallationsverzeichnis>\bin;%PATH% Der nächste Schritt ist, die vom java2cs-Compiler generierte Datei ConverterApp.cs unter Projekt – Vorhandenes Element hinzufügen... in das Projekt einzubinden. Wichtig ist es, dass der Namespace, der in dieser generierten Datei verwendet wird, derselbe ist, der in dem Client verwendet wird. Wenn die beschriebenen Schritte ausgeführt wurden, kann das Projekt kompiliert werden. 5.2.4 Die Ausführung des Clients Es gibt drei Formen, wie man die J2EE-Server-Daten (z. B. IP-Adresse und Port-Nummer) an den Client übergeben kann: • Über Kommandozeilenargumente • Im Programmtext des Clients • In eine Konfigurationsdatei. In diesem Beispiel wird nur die erste Möglichkeit beschrieben.29 Im Verzeichnis <.NET-Projektverzeichnis>\bin\Debug wird im Kommandozeilenfenster die Datei JanevaConverterClient.exe mit einigen Argumenten aufgerufen. Der Befehl sieht folgendermaßen aus: <.NET-Projektverzeichnis>\bin\Debug>JanevaConverterClient -ORBInitRef NameService=corbaname:iiop:localhost:3700/NameService30 Die Client-Ausgabe sieht wie folgt aus: 29 Alle Möglichkeiten werden ausführlich im Janeva-Entwicklerhandbuch beschrieben. „Developers Guide”. S. 31-44. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 30 Vgl. Developers Guide. S. 32. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 17 Abb. 9 Die angegebenen Server-Angaben beziehen sich auf dem J2EE-Application-Server von Sun. Die übergebenen Argumente können von Server zu Server variieren. Jeder Server hat eine eigene URL-Syntax. Beispiel: • WebLogic 7 oder 8: corbaloc::localhost:7001/NameService • IBM WebSphere 5: corbaname:iiop:localhost:2809/NameServiceServerRoot • Oracle's 0C4J: corbaloc:iiop:1.2@localhost:5555/NameService • Sybase: corbaloc:iiop:1.2@localhost:9000/NameService31 Die Portnummer kann auch von der Standard-Portnummer des jeweiligen Servers abweichen. Im J2EE-Application-Server von Sun kann man dies leicht überprüfen, indem man unter Start – Programme – Sun – J2EE 1.4 SDK die Admin Console startet. Dort wird im Baum Application Server – ORB – IIOP-Listeners ausgewählt. Der hier benötigte Port ist unter dem Namen orb-listener-1 aufgeführt (Abb. 10). Abb. 10 31 Vgl. Developers Guide. S. 34. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). 18 6. Fazit Janeva ist ohne Zweifel eine sehr gute Lösung, um ohne viel Aufwand die Interoperabilität zwischen J2EE, CORBA und .NET zu ermöglichen. Allerdings erweisen sich Mängel in der Dokumentation. Wichtige Informationen sind durch die Dokumentation zerstreut, was auch dazu führt, dass die Dokumentation unübersichtlich ist. Man musst sich einen großen Teil der ersten fünfzig Seiten des Entwicklerhandbuches durchlesen, um alle nötigen Informationen zu haben, um ein kleines Client-Beispiel erfolgreich zu implementieren. Es gibt zwar Janeva-Beispiele, die mit der Software mitgeliefert werden, doch sie steigen auf einem zu hohen Niveau ein. Für Entwickler, die sich noch nie mit dem Thema beschäftigt haben, ist der Einstieg schwer. Was hier fehlt, ist ein ausführliches kleines Beispiel, in dem jeder Schritt erklärt wird, um ein allgemeines Verständnis und einen Überblick zu ermöglichen. Ein weiterer Aspekt ist, dass die mitgelieferten J2EE-Beispiele für den Borland Enterprise Server konzipiert sind. Zwar wird gezeigt, wie die Interoperabilität zwischen .NET und anderen EJB-Servern funktioniert, es wird aber nicht auf andere wichtige EJB-Server eingegangen, wie z.B. JBoss und der J2EE-Application Server von Sun. Noch ein Grund für den schweren Einstieg besteht darin, dass die Software ziemlich neu auf dem Markt ist und sich kaum verbreitet hat. Man findet keine Tutorials oder Foren über Janeva, wo Beispiele aufgeführt und durchdiskutiert werden. Doch die Vorteile überwiegen. Es ist zwar schwer, mit der vorhandenen Dokumentation ein erstes kleines Test-Client zum laufen zu bringen, doch wenn diese Hürde überwunden ist, ist nur noch die neu geöffnete Tür in Sicht. Es öffnet sich eine Tür mit vielenn Vorteilen und guten Lösungen. 19 Literaturverzeichnis Developers Guide. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaDevGuide.pdf (30.03.04). Erhöhen Sie die Plattform Interoperabilität. http://www.borland.com/janeva/pdf/jnva_datasheet.pdf (30.03.04). The Middleware Company: High Performance .NET and J2EE Interoperability with Borland’s Janeva. http://www.borland.com/products/white_papers/pdf/high_performance_dotnet_and_j2ee.pdf (06.05.04). Installation Guide. http://info.borland.com/techpubs/janeva/6_0/english/pdf/JanevaInstallGuide.pdf (30.03.04). J2EE-Tutorial. http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html (31.03.04). License Terms. <Janeva 6.0-Installationsverzeichnis>license.rtf. Readme <Janeva 6.0-Installationsverzeichnis>readme.html. Stahl, Michael: Über-Brückung, Borlands Janeva: Zugriff von .NET- auf J2EE- und CORBAObjekte. In: iX 2/2004. 20 Anhang Folgende Quelltexte sind aus dem J2EE-Tutorial.32 Es handelt sich um das „ConverterBeispiel“. Remote Interface (Converter.java) package converter; import javax.ejb.EJBObject; import java.rmi.RemoteException; import java.math.*; public interface Converter extends EJBObject { } public BigDecimal dollarToYen(BigDecimal dollars) throws RemoteException; public BigDecimal yenToEuro(BigDecimal yen) throws RemoteException; Home Interface (ConverterHome.java) package converter; import java.rmi.RemoteException; import javax.ejb.CreateException; import javax.ejb.EJBHome; public interface ConverterHome extends EJBHome { Converter create() throws RemoteException, CreateException; } Enterprise Bean Class (ConverterBean.java) package converter; import import import import java.rmi.RemoteException; javax.ejb.SessionBean; javax.ejb.SessionContext; java.math.*; public class ConverterBean implements SessionBean { BigDecimal yenRate = new BigDecimal("121.6000"); BigDecimal euroRate = new BigDecimal("0.0077"); public BigDecimal dollarToYen(BigDecimal dollars) { BigDecimal result = dollars.multiply(yenRate); 32 http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html (31.03.04), Kap. 24. 21 } return result.setScale(2, BigDecimal.ROUND_UP); public BigDecimal yenToEuro(BigDecimal yen) { BigDecimal result = yen.multiply(euroRate); } return result.setScale(2, BigDecimal.ROUND_UP); public ConverterBean() {} public void ejbCreate() {} public void ejbRemove() {} public void ejbActivate() {} public void ejbPassivate() {} } public void setSessionContext(SessionContext sc) {} Application Client (ConverterClient.java) import import import import import import converter.Converter; converter.ConverterHome; javax.naming.Context; javax.naming.InitialContext; javax.rmi.PortableRemoteObject; java.math.BigDecimal; public class ConverterClient { public static void main(String[] args) { try { Context initial = new InitialContext(); Context myEnv = (Context) initial.lookup("java:comp/env"); Object objref = myEnv.lookup("ejb/SimpleConverter"); ConverterHome home = (ConverterHome) PortableRemoteObject.narrow(objref, ConverterHome.class); Converter currencyConverter = home.create(); BigDecimal param = new BigDecimal("100.00"); BigDecimal amount = currencyConverter.dollarToYen(param); System.out.println(amount); amount = currencyConverter.yenToEuro(param); System.out.println(amount); System.exit(0); } } } catch (Exception ex) { System.err.println("Caught an unexpected exception!"); ex.printStackTrace(); }
