Enterprise Application Integration

1. Enterprise Application Integration EAI mit der Java 2 Enterprise Edition und Enterprise JavaBeans

2. Einordnung in funktionale Bestandteile einer EAI Infrastruktur Prozessmanagement Metadatenbank für Zusatzdienste Nachrichtenmanagement Middleware Java 2 Enterprise Edition Adapter Adapter Adapter Adapter Adapter Adapter Physisches Netzwerk

3. Java 2 Enterprise Edition • Keine Programmiersprache, sondern Spezifikationen und Verfahren zur Entwicklung, Einführung und Verwaltung komplexer und verteilter Anwendungssysteme • Standards für Komponenten, Container und Dienste sowie Definition einer Systemarchitektur • Abstraktion… • …von Präsentation und Implementierung • Gleiche Schnittstellen für verschiedene Clients (Browser, Fat Client, Mobiltelefone, …) • …von Geschäftslogik und Plattform • Flexible Implementierung von Geschäftsprozessen über wiederverwendbare Komponenten (Enterprise JavaBeans)

4. Java 2 Enterprise Edition

5. Java 2 Enterprise Edition • Spezifikationsvorgaben in J2EE-Anwendungsservern implementiert • Laufzeitumgebung für J2EE Komponenten, die die J2EE Spezifikation erfüllt • Logische Aufteilung in Container (Web-Container, EJB-Container) • Muss, um Spezifikation zu erfüllen, diverse Dienste anbieten • Dienste eines J2EE-Anwendungsservers: • Webserver • Sicherheitsdienste (Authentifizierung, Autorisation, Zugangsbeschränkungen, Verschlüsselung – über JAAS) • Transaktionsmanagement (über JTS, JTA) • Namensdienste (über JNDI) • Persistenzmanagement (über JDBC) • Ressourcenverwaltung (Pooling, Aktivierung und Passivierung von EJBs) • Interoperabilität: Anbindung von J2EE-fremden Systemen (über CORBA, J2EE Connector Architektur und Web Services)

6. J2EE-Komponenten • Servlets • Java-Klassen, die HTTP-Anfragen verarbeiten und HTTP-Antworten erstellen • i.d.R. Controller-Komponenten für Webanwendungen, manchmal auch View • Alternativ als Gateway für HTTP-basierenden Protokolle verwendet • Java Server Pages / Java Server Faces • Markup-Dateien, die neben HTML-/XML-Tags auch Java-Code und spezielle JSP-/JSF-Tags enthalten • werden als Servlet kompiliert • View-Komponenten für Webanwendungen

7. J2EE-Komponenten • Enterprise JavaBeans • Kapseln Geschäftslogik, Daten und Nachrichtenverarbeitung für unternehmensweite Anwendungen • Werden später im Detail vorgestellt • Ressourcen-Adapter („Konnektoren“) • Verbindung zwischen Anwendungsserver und EIS (SAP, Bank- und Versicherungs-EIS auf Mainframes, Message Oriented Middleware…) • Applikationen bzw. Applets • Bieten als Client Zugriff auf die Serverfunktionen an.

8. Architektur • Üblicherweise Aufteilung in vier Schichten • Clients (Browser, Thin Clients) • Präsentationslogik (JSP/JSF, Servlets) • Geschäftslogik (Enterprise JavaBeans) • Datenhaltung (relationale und XML-Datenbanken) • Auch Drei-Schichten-Architektur möglich: • Client mit Präsentationslogik (Fat-Client, Applet, …) • Geschäftslogik (Enterprise JavaBeans) • Datenhaltung

9. Architektur

10. Enterprise JavaBeans • Komponenten zur Implementierung von Geschäftsprozessen, Daten und Nachrichtenverarbeitung • Entity Beans • Daten für unternehmensrelevante Geschäftsobjekte • Werden in persistentem Speicher gesichert (i.d.R. Datenbank) • Bean-managed Persistence: Bean kümmert sich selber um ihre Persistenz • Container-managed Persistence: • Container kümmert sich um Persistenz • ermöglicht automatische Verwaltung von Relationen zwischen Entitäten (Container-Managed Relationships) • EJB-Query Language zum Auffinden von Entitäten in Datenbank; Bean wird über Schema angesprochen • Gemeinsam von mehreren Clients nutzbar • z. B. Bankkonto, Flugreservierung, Kundendaten

11. Enterprise JavaBeans • Session Beans • Implementierung von Geschäftsprozessen als Dienst • Zustandslos: • Für simple Geschäftsprozesse; kann von mehreren Clients gleichzeitig benutzt werden • Keine Daten zwischen Methodenaufrufen gespeichert, arbeiten nur auf übergebenen Daten • Können ab EJB 2.1 Dienste auch als Web Service anbieten • z. B. Geldentnahme von Bankkonto • Zustandsbehaftet: • Speichern Daten über mehrere Methodenaufrufe • Methodenaufrufe können Zustand der Bean verändern • nur von einem Client nutzbar; Daten nicht persistent • z. B. Veränderung eines Warenkorbs bei Online-Einkauf

12. Enterprise JavaBeans • Message-Driven Beans • Stellt einen Nachrichtenempfänger dar (nicht automatisch auch einen Sender!) • Serverseitige Geschäftslogik für Verarbeitung asynchroner Nachrichten • Bietet auf Wunsch Zustellungsgarantie (Ausfall des Systems sorgt nicht für Verlust der Nachricht) • Client kommuniziert nur über Nachrichtenaustausch, Bean „lauscht“ auf das Eintreffen neuer Nachrichten • z. B. Datenabgleich zwischen zwei Filialen, Ausführung eines Workflows • Werden in nächster Veranstaltung detailliert vorgestellt

13. Enterprise JavaBeans • Weiterhin für Deployment von Enterprise JavaBeans benötigt: • Deployment Deskriptoren • XML-Dokumente zur Beschreibung der Bean-Klassen und -Interfaces, der Bean-Eigenschaften sowie zur Konfiguration der Bean im Applikationsserver • Ein herstellerunabhängiger Deskriptor (ejb-jar.xml), ein oder mehrere herstellerabhängige Deskriptoren (jboss.xml, sun-ejb-jar.xml, …), um server- und datenbankspezifische Eigenschaften zu definieren • JAR-Archive mit Deployment Descriptoren, kompilierten Klassen und Interfaces sowie benötigten Bibliotheken

14. Zugriff auf Entity und Session Beans • Zugriff auf Entity und Session Beans über zwei Wege möglich • Entfernter Zugriff von außerhalb der virtuellen Maschine, in der der Applikationsserver läuft • Beans müssen „Remote Interfaces“ implementieren • Zugriff über RMI/IIOP (Remote Method Invocation/Internet InterORB Protocol) • Argumente und Ergebnisse werden als Werte übergeben • Durch Netzwerkübertragung, Marshalling und Demarshalling hoher Overhead; Aufrufe sehr langsam • Lokaler Zugriff innerhalb der virtuellen Maschine • Beans müssen „Local Interfaces“ implementieren • Sehr schnell, da Beans direkt aufgerufen werden können • Argumente und Ergebnisse werden als Referenzen übergeben • Entity Beans: ermöglicht durch den Container verwaltete Relationen

15. Zugriff auf Entity und Session Beans • Beans über JNDI auffind- und zugreifbar • Konvention: Alle Beans unter Wurzel ejb/ ablegen • Ablauf: • Erzeugen eines initialen Kontext • Suchen der Bean im JNDI-Namensraum • Wenn aufgefunden, Referenz auf Bean holen • Bean benutzen

16. Grundlegender Aufbau von Entity und Session Beans • Remote und/oder Local Interfaces: • Definieren die Geschäftsmethoden einer Bean • Erben von javax.ejb.EJBObject bzw. javax.ejb.EJBLocalObject • RemoteHome und/oder LocalHome Interfaces: • Definieren Methoden zum Verwalten von Beans • Erzeugen, Löschen, Auffinden, Aktivieren und Passieren • Erben von javax.ejb.EJBHome bzw. javax.ejb.EJBLocalHome • Bean-Klassen: • Implementieren die in den Interfaces definierten Geschäfts- und Verwaltungsmethoden • Müssen javax.ejb.EntityBean (Entity Beans) bzw. javax.ejb.SessionBean (Session Beans) implementieren

17. Exkurs: XDoclet • Engine zur Unterstützung von Attribute-Oriented Programming: • Source Code-Erzeugung mit Hilfe von Meta-Informationen in JavaDoc-ähnlichen Kommentaren • Aus XDoclet-Tags und Sourcecode Informationen extrahieren, daraus Supportklassen und -dateien generieren • Kommentare auf Klassen-, Methoden und Attributebene möglich • Dokumentation unter http://xdoclet.sf.net/ • Beispiel: Java-Klasse als Enterprise JavaBean deklarieren /** @ejb.bean name = "Example" * local-jndi-name="ejb/examples/Example" * type="CMP" * cmp-version="2.x" * schema = "Example" */ publicabstractclassExampleBean{[...] }

18. Definition von Entity Beans • Bean wird mithilfe von XDoclet Meta-Angaben beschrieben • Art der Bean (Entity Bean, CMP) • Name der Bean und JNDI-Context, unter dem Bean bereitsteht • Schema, als das Bean in EJB-QL angesprochen werden kann • Art des Zugriffs: für Entity Beans lokal, sonst kein CMR möglich • Name des Primärschlüssels • Klasse als abstract deklarieren, muss Interface javax.ejb.EntityBean implementieren • Beinhaltet Methoden zur Verwaltung des Lebenszyklus und des Bean-Umfeldes: ejbActivate, ejbPassivate, ejbLoad, ejbStore, (un)setEntityContext

19. Definition von Entity Beans packagelspi.eai.phonebook; importjava.rmi.*; importjavax.ejb.*; /** @ejb.bean name="Entry" * display-name="EntryEB" * description="A phonebook entry" * jndi-name="ejb/Entry" * local-jndi-name="ejb/Entry" * type="CMP" * cmp-version="2.x" * view-type="local" * schema = "Entry" * primkey-field = "id" * * @ejb.persistence table-name = "phonebook_entries" * @jboss.persistence create-table = "true" alter-table = "true" * * @ejb.home local-class = "lspi.eai.phonebook.EntryLocalHome" * @ejb.interface local-class = "lspi.eai.phonebook.EntryLocal" */ publicabstractclassEntryBeanimplementsEntityBean{ [...] } Definition der Entity Bean Angaben zur Datenbank Klassennamen der Local- und LocalHome- Interfaces

20. Definition von Entity Beans importjava.rmi.*; importjavax.ejb.*; publicabstractclassEntryBeanimplementsEntityBean{ privateEntityContextctx; publicvoidejbActivate()throwsEJBException,RemoteException{} publicvoidejbPassivate()throwsEJBException,RemoteException{} publicvoidejbLoad()throwsEJBException,RemoteException{} publicvoidejbStore()throwsEJBException,RemoteException{} publicvoidsetEntityContext(EntityContextctx)throwsEJBException{ this.ctx=ctx; } publicvoidunsetEntityContext()throwsEJBException{ this.ctx=null; } [...] } Lebenszyklus der Bean Umgebung der Bean

21. Definition von Entity Beans • Methoden zum Erzeugen neuer Entitäten implementieren • Eine oder mehrere ejbCreate und ejbPostCreate-Methoden (jeweils paarweise); mit XDoclet-Tags als create-Methoden deklarieren • ejbCreate-Methode füllt Bean mit zugehörigen Daten; Rückgabe vom Typ des Primärschlüssels, jedoch immer null • ejbPostCreate-Methode populiert Relationen zu anderen Entity Beans (bei Container-Managed Relationships; erst nach Erzeugung der Bean möglich); Rückgabe ist void • Persistente Felder abstract mit get- und set-Operationen definieren • Mit XDoclet als persistente Felder deklarieren und Primärschlüssel identifizieren • Zusätzliche Geschäftsmethoden implementieren

22. Definition von Entity Beans /** @ejb.create-method view-type = "local" */ publicLongejbCreate(Stringlastname, Stringfirstname, LongdateOfBirth, StringphoneNumber)throwsCreateException{ setId(Long.valueOf(System.nanoTime())); setLastname(lastname); setFirstname(firstname); setDateOfBirth(dateOfBirth); setPhoneNumber(phoneNumber); returnnull; } publicvoidejbPostCreate(Stringlastname, Stringfirstname, LongdateOfBirth, StringphoneNumber)throwsCreateException{ // keine Relation zu füllen } Füllen der Entität mit initialen Werten Falls notwendig, Erzeugung von Relationen

23. Definition von Entity Beans /** @ejb.pk-field * @ejb.persistent-field * @ejb.interface-method view-type="local" */ publicabstractLonggetId(); /** @ejb.interface-method view-type="local" */ publicabstractvoidsetId(Longid); /** @ejb.persistent-field * @ejb.interface-method view-type="local" */ publicabstractStringgetFirstname(); publicabstractvoidsetFirstname(Stringfirstname); publicabstractStringgetLastname(); publicabstractvoidsetLastname(Stringlastname); publicabstractStringgetPhonenumber(); publicabstractvoidsetPhonenumber(Stringphonenumber); publicabstractLonggetDateOfBirth(); publicabstractvoidsetDateOfBirth(LongdateOfBirth); Definition persistenter Felder

24. Auffinden von Entity Beans • Geschieht über EJB-QL: • Vereinfachtes SQL-Derivat (reine Anfragesprache!) • Grundsyntax:SELECT OBJECT(identifier) FROM Schemaname AS identifier [WHERE identifier.feldname = ?1 AND identifier.relation.feldname = ?2] • ?n: n-ter Parameter der Methodensignatur • Definition von find-Methoden in LocalHome-Interface (Konvention: findByXXX(), findAll()) • Methode findByPrimaryKey(PKKlasse primaryKey) immer definiert • Rückgabekardinalität 0..1: Rückgabetyp ist Local-Interfacez. B. EntryLocal findByName(String lastname, String firstname) • Rückgabekardinalität 0..n: Rückgabetyp ist java.util.Collection bzw. java.util.Enumeration

25. Auffinden von Entity Beans • Mit XDoclet: Definition in Klassenkommentar der Bean-Klasse • Parameternamen voll qualifiziert angeben (z.B. java.lang.String anstelle von String) /** * @ejb.finder * signature = "java.util.Collection findAll()" * query = "SELECT OBJECT(e) FROM Entry AS e" * @ejb.finder * signature = "lspi.eai.phonebook.EntryLocal * findByName(java.lang.String lastname, java.lang.String * firstname)" * query = "SELECT OBJECT(e) FROM Entry AS e WHERE e.lastname = ?1 AND * e.firstname = ?2" */

26. Beziehungen zwischen Entity Beans • CMR zwischen zwei Entity Beans möglich, wenn diese • lokale Interfaces benutzen und • Persistenz vom Container gemanaged wird • Mögliche Kardinalitäten • One-to-One (1:1) • One-to-Many (1:n) • Many-to-One (n:1) • Many-to-Many (n:m) • Können gerichtet oder ungerichtet sein • Unidirektional (ausgehende Bean kennt Zielbean, aber nicht umgekehrt) • Bidirektional (Beans kennen sich gegenseitig)

27. Beziehungen zwischen Entity Beans • Relationen sowohl in Quelltext (über get- und set-Methoden) als auch in Deployment Deskriptor definieren (wird von XDoclet übernommen) • Anlegen von Relationen • bei X:1: abstrakte get- und set-Methoden vom Typ des Local-Interfaces der Zielbean • bei X:n: abstrakte get- und set-Methoden vom Typ java.util.Collection bzw. java.util.Set • Definition der Relation per XDoclet-Tags (@ejb.relation sowie @jboss.relation) • Bei unidirektionalen Relationen Definition einer "virtuellen" Rückbeziehung

28. publicclassExample1Bean{ [...] /** @ejb.interface-method * view-type = "local" * @ejb.relation * name = "Example1-Example2" * role-name = "Ex1-knows-Ex2" * @jboss.relation * related-pk-field = "example2Id" * fk-column = "fk_example2Id" * fk-constraint = "true" */ publicabstractExample2LocalgetExample2(); /** @ejb.interface-method * view-type = "local" */ publicabstractvoidsetExample2(Example2example2); [...] } publicclassExample2Bean{ [...] /** @ejb.interface-method * view-type = "local" * @ejb.relation * name = "Example1-Example2" * role-name = "Ex2-knows-Ex1" * @jboss.relation * related-pk-field = "example1Id" * fk-column = "fk_example1Id" * fk-constraint = "true" */ publicabstractExample1LocalgetExample1(); /** @ejb.interface-method * view-type = "local" */ publicabstractvoidsetExample1(Example1example1); [...] } Beziehungen zwischen Entity Beans Beispiel für eine bidirektionale 1:1-Beziehung

29. publicclassExample1Bean{ [...] /** @ejb.interface-method * view-type = "local" * @ejb.relation * name = "Example1-Example2" * role-name = "Ex1-knows-Ex2" * @jboss.relation * related-pk-field = "example2Id" * fk-column = "fk_example2Id" * fk-constraint = "true" */ publicabstractExample2LocalgetExample2(); /** @ejb.interface-method * view-type = "local" */ publicabstractvoidsetExample2(Example2example2); [...] } publicclassExample2Bean{ [...] /** @ejb.interface-method * view-type = "local" * @ejb.relation * name = "Example1-Example2" * role-name = "Ex2-knows-Ex1" */ publicabstractjava.util.CollectiongetExamples(); /** @ejb.interface-method * view-type = "local" */ publicabstractvoidsetExamples(java.util.Collectionexamples); [...] } Beziehungen zwischen Entity Beans Beispiel für eine bidirektionale 1:n-Beziehung

30. publicclassExample1Bean{ [...] /** @ejb.interface-method * view-type = "local" * @ejb.relation * name = "Example1-Example2" * role-name = "Ex1-has-Ex2" */ publicabstractjava.util.CollectiongetExamples2(); /** * @ejb.interface-method * view-type = "local" */ publicabstractvoidsetExamples2(java.util.Collectionexamples2); [...] } publicclassExample2Bean{ [...] /** @ejb.interface-method * view-type = "local" * @ejb.relation * name = "Example1-Example2" * role-name = "Ex2-has-Ex1" */ publicabstractjava.util.CollectiongetExamples1(); /** * @ejb.interface-method * view-type = "local" */ publicabstractvoidsetExamples1(java.util.Collectionexamples1); [...] } Beziehungen zwischen Entity Beans Beispiel für eine bidirektionale n:m-Beziehung

31. publicclassExample1Bean{ [...] /** @ejb.interface-method view-type = "local" * @ejb.relation name = "Example1-Example2" * role-name = "Example1-has-Examples2" * target-ejb = "Example2Bean" * target-role-name = "Example2-referenced-by-Example1" * target-multiple = "no" * @jboss.relation related-pk-field = "example2Id" * fk-column = "fk_example2Id" * fk-constraint = "true" */ publicabstractExample2LocalgetExample2(); /** @ejb.interface-method view-type = "local" */ publicabstractvoidsetExample2(Example2Localexample2); [...] } Beziehungen zwischen Entity Beans Beispiel für eine unidirektionale 1:(1)-Beziehung

32. Definition von Session Beans • Definition der Meta-Informationen wieder über XDoclet • Typ angeben: "Stateless" für zustandslose, "Stateful" für zustandsbehaftete Session Beans • In der Regel keine lokalen, sondern remote Interfaces für Kommunikation mit Bean • Klasse muss javax.ejb.SessionBean implementieren • Methoden ejbRemove(), ejbActivate(), ejbPassivate(), setSessionContext(…) für Lebenszyklus- und Umgebungsverwaltung • Bei zustandslosen Beans parameterlose ejbCreate()-Methode, bei zustandsbehafteten Beans ejbCreate(…)-Methoden frei definierbar

33. Definition von Session Beans packagelspi.eai.phonebook; importjava.rmi.*; importjavax.ejb.*; /** * @ejb.bean name="Phonebook" * display-name="PhonebookSB" * description="Business logic of a phonebook" * jndi-name="ejb/example/Phonebook" * type="Stateless" * view-type="remote" * * @ejb.home remote-class = "lspi.eai.phonebook.PhonebookHome" * @ejb.interface remote-class = "lspi.eai.phonebook.Phonebook" */ publicclassPhonebookBeanimplementsSessionBean{ [...] } Meta-Informationen: Zustandslos, remote Interfaces sind remote

34. Definition von Session Beans • Für Zugriff auf Entity Beans und andere Session Beans: lookupXXX()-Methoden erzeugen • Auffinden benötigter Beans im JNDI-Namensdienst privateEntryLocalHomelookupEntryLocalHome()throwsNamingException{ InitialContextctx=newInitialContext(); try{ EntryLocalHomeentryHome= (EntryLocalHome)ctx.lookup("ejb/example/Entry"); returnentryHome; }finally{ if(ctx!=null)ctx.close(); } }

35. Definition von Session Beans • Geschäftsmethoden definieren • Da Zugriff remote erfolgt, muss java.rmi.RemoteException geworfen werden • Geschäftsmethode über XDoclet-Tag @ejb.interface-method deklarieren • Daten von/für Entity Beans in Data Transfer Objects / Value Objects verpacken • Entity Beans nicht serialisierbar • DTO: Einfache JavaBean, die java.io.Serializable implementiert und get- und set-Methoden anbietet

36. Definition von Session Beans /** @ejb.interface-method view-type = "remote" */ publicEntryDTOfindEntry(Stringlastname, Stringfirstname)throwsRemoteException{ try{ EntryLocalHomeentryHome=lookupEntryLocalHome(); EntryLocalentry=entryHome.findByName(lastname,firstname); CalendardateOfBirth=newGregorianCalendar(); dateOfBirth.setTimeInMillis( entry.getDateOfBirth().longValue()); EntryDTOentryDTO=newEntryDTO(dateOfBirth,entry .getLastname(),entry.getFirstname(),entry .getPhoneNumber()); returnentryDTO; }catch(NamingExceptione){ thrownewRemoteException(e.getMessage()); }catch(FinderExceptione){ returnnull; } }

37. Bean Deployment • Bean-Klasse implementieren • XDoclet auf Bean-Klasse anwenden • Generiert Local/Remote- und LocalHome/Home-Interfaces sowie Deployment Deskriptoren • Quellen kompilieren • Kompilierte Klassen und Deployment Deskriptoren in JAR-Datei packen • Klassen mit Packagestruktur übernehmen • Deployment-Deskriptoren in Unterverzeichnis META-INF/ packen • JAR-Archiv auf dem Server deployen • Bei lokaler JBoss-Installation in Unterverzeichnis server\default\deploy kopieren • Für die Übungen: http://wi-vm215.uni-muenster.de:8080/deployment

38. Client-Programmierung • Zugriff auf Session Beans über JNDI • Wichtig: jbossall-client.jar, Remote-/RemoteHome-Interfaces und DTO-Klassen im Pfad des Clients! publicPhonebookHomegetPhonebookHome(){ StringJBOSS_HOST="wi-vm215.uni-muenster.de"; Propertiesp=newProperties(); p.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory"); p.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces"); p.setProperty("java.naming.provider.url",JBOSS_HOST); try{ InitialContextctx=newInitialContext(p); phonebookHome=(PhonebookHome)ctx.lookup("ejb/example/Phonebook"); returnphonebookHome; }catch(NamingExceptione){ e.printStackTrace(); } }

39. Client-Programmierung • Benutzung der Bean im Client: try{ PhonebookHomephonebookHome=getPhonebookHome(); Phonebookphonebook=phonebookHome.create(); EntryDTOentry=phonebook.findEntry("Meyer","Ute"); }catch(CreateExceptionce){ ce.printStackTrace(); }catch(RemoteExceptionre){ re.printStackTrace(); }

40. EAI mit J2EE • Anbindung J2EE-fremder Systeme auf zwei Arten • Über CORBA • Java-Interfaces der Beans (insb. Session Beans) in CORBA-IDL abbilden • Verbindung über IIOP-Protokoll möglich • Unterstützung für Authentifizierung/Autorisation, Verschlüsselung • Transaktionssicherheit • Hoher Implementierungsaufwand • Über Web Services • Seit J2EE v1.4/EJB 2.1: Stateless Session Beans als Web Service Endpunkte • Verbindung mit WS über SOAP • Authentifizierung/Autorisation, Verschlüsselung, Sitzungsverfolgung möglich, aber aufwändig • Relativ einfach zu implementieren

41. EAI mit J2EE: Session Bean als Web Service • Service Endpoint Interface (SEI) definieren • enthält durch WS bereitgestellte Geschäftsmethoden • kann weniger Methoden anbieten, als Bean bereitstellt • Interface erweitert java.rmi.Remote • Methoden müssen java.rmi.RemoteException werfen packagelspi.eai.phonebook; importjava.rmi.*; publicinterfacePhonebookSEIextendsRemote{ publicEntryDTOfindEntry(Stringlastname,Stringfirstname) throwsRemoteException; publicEntryDTO[]findEntries()throwsRemoteException; publicvoidaddEntry(EntryDTOentry)throwsRemoteException; }

42. EAI mit J2EE: Session Bean als Web Service • Deployment Descriptor ejb-jar.xml aktualisieren • Hinzufügen eines <service-endpoint>-Tags unter /ejb-jar/enterprise-beans/session <ejb-jar[...]> <enterprise-beans> <session> <description><![CDATA[Business logic of a phonebook]]></description> <display-name>PhonebookSB</display-name> <ejb-name>Phonebook</ejb-name> <home>lspi.eai.phonebook.PhonebookHome</home> <remote>lspi.eai.phonebook.Phonebook</remote> <service-endpoint>lspi.eai.phonebook.PhonebookSEI</service-endpoint> <ejb-class>lspi.eai.phonebook.PhonebookBean</ejb-class> <session-type>Stateless</session-type> <transaction-type>Container</transaction-type> </session> </enterprise-beans> </ejb-jar>

43. EAI mit J2EE: Session Bean als Web Service • WSDL-Datei und Meta-Informationen für Web Service aus Service Endpoint Interface generieren • benötigt wscompile aus dem Java Web Services Developer Pack 2 • erzeugt Hilfsklassen, WSDL- und Mapping-Dokumente (bildet Java-Datentypen auf Web Service-Elemente ab)

44. EAI mit J2EE: Session Bean als Web Service • Speziellen Web Service-Descriptor webservices.xml definieren <webservices> <webservice-description> <webservice-description-name>PhonebookService</webservice-description-name> <wsdl-file>META-INF/wsdl/PhonebookService.wsdl</wsdl-file> <jaxrpc-mapping-file>META-INF/PhonebookService_mapping.xml</jaxrpc-mapping-file> <port-component> <port-component-name>PhonebookService</port-component-name> <wsdl-port>PhonebookSEIPort</wsdl-port> <service-endpoint-interface>lspi.eai.phonebook.PhonebookSEI</service-endpoint-interface> <service-impl-bean> <ejb-link>Phonebook</ejb-link> </service-impl-bean> </port-component> </webservice-description> </webservices>

45. EAI mit J2EE: Session Bean als Web Service • Beans und Deployment Deskriptoren in JAR-Archiv packen • WSDL-Datei in Verzeichnis META-INF/wsdl • webservices.xml und Mapping-Datei nach META-INF • JAR-Datei deployen • Bei lokaler Installation wieder nach server/default/deploy • Ansonsten über das Web-Interface hochladen • Installation kann über http://localhost:8080/ws4ee überprüft werden (bzw. über Web-Interface) • Ansprechen des Web Services über Axis • Generierung der Client-Dateien wie in WS-Vorlesung mithilfe von WSDL2Java

46. Telefonbuch-Beispiel • Telefonbuch-Beispiel mit Schritt-für-Schritt-Anleitung im Netz unter http://www.wi.uni-muenster.de/pi/lehre/ss06/EAI/j2ee_jboss.php

47. Literatur • Roman, E., et. al.: Mastering Enterprise JavaBeans, Third Editionhttp://www.theserverside.com/books/wiley/masteringEJB/index.tss • Engel, A., Koschel., A., Tritsch, R.: J2EE kompakt, Spektrum Akademischer Verlag 2002Guter Einstieg in die Materie, obwohl z. T. überholt • J2EE Specification 1.4 / EJB Specification 2.1http://java.sun.com/j2ee/1.4/docs/#specs • Technische Kurzdokumentationen zu J2EEhttp://www.torsten-horn.de/techdocs/#JEE (einführende Beispiel in J2EE)