Enterprise Application Integration

Präsentation zum Thema: "Enterprise Application Integration"—  Präsentation transkript:

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
Erste Einblendung: Hersteller von AS Server Zweite Einblendung: Unternehmen, die an der Spezifikation mitwirken

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 Server Pages / Java Server Faces
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, …) 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 Beispiel: Java-Klasse als Enterprise JavaBean deklarieren name = "Example" * local-jndi-name="ejb/examples/Example" * type="CMP" * cmp-version="2.x" * schema = "Example" */ public abstract class ExampleBean { [...] }

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
package lspi.eai.phonebook; import java.rmi.*; import javax.ejb.*; 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" * table-name = "phonebook_entries" create-table = "true" alter-table = "true" local-class = "lspi.eai.phonebook.EntryLocalHome" local-class = "lspi.eai.phonebook.EntryLocal" */ public abstract class EntryBean implements EntityBean { [...] } Definition der Entity Bean Angaben zur Datenbank Klassennamen der Local- und LocalHome- Interfaces

20 Definition von Entity Beans
import java.rmi.*; import javax.ejb.*; public abstract class EntryBean implements EntityBean { private EntityContext ctx; public void ejbActivate() throws EJBException, RemoteException {} public void ejbPassivate() throws EJBException, RemoteException {} public void ejbLoad() throws EJBException, RemoteException {} public void ejbStore() throws EJBException, RemoteException {} public void setEntityContext(EntityContext ctx) throws EJBException { this.ctx = ctx; } public void unsetEntityContext() throws EJBException { 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
view-type = "local" */ public Long ejbCreate(String lastname, String firstname, Long dateOfBirth, String phoneNumber) throws CreateException { setId(Long.valueOf(System.nanoTime())); setLastname(lastname); setFirstname(firstname); setDateOfBirth(dateOfBirth); setPhoneNumber(phoneNumber); return null; } public void ejbPostCreate(String lastname, // keine Relation zu füllen Füllen der Entität mit initialen Werten Falls notwendig, Erzeugung von Relationen

23 Definition von Entity Beans
view-type="local" */ public abstract Long getId(); view-type="local" */ public abstract void setId(Long id); public abstract String getFirstname(); public abstract void setFirstname(String firstname); public abstract String getLastname(); public abstract void setLastname(String lastname); public abstract String getPhonenumber(); public abstract void setPhonenumber(String phonenumber); public abstract Long getDateOfBirth(); public abstract void setDateOfBirth(Long dateOfBirth); 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-Interface z. 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) /** * signature = "java.util.Collection findAll()" * query = "SELECT OBJECT(e) FROM Entry AS e" * 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 Bei unidirektionalen Relationen Definition einer "virtuellen" Rückbeziehung

28 Beziehungen zwischen Entity Beans
Beispiel für eine bidirektionale 1:1-Beziehung public class Example1Bean { [...] * view-type = "local" * name = "Example1-Example2" * role-name = "Ex1-knows-Ex2" * related-pk-field = "example2Id" * fk-column = "fk_example2Id" * fk-constraint = "true" */ public abstract Example2Local getExample2(); * view-type = "local" */ public abstract void setExample2(Example2 example2); } public class Example2Bean { [...] * view-type = "local" * name = "Example1-Example2" * role-name = "Ex2-knows-Ex1" * related-pk-field = "example1Id" * fk-column = "fk_example1Id" * fk-constraint = "true" */ public abstract Example1Local getExample1(); * view-type = "local" */ public abstract void setExample1(Example1 example1); }

29 Beziehungen zwischen Entity Beans
Beispiel für eine bidirektionale 1:n-Beziehung public class Example1Bean { [...] * view-type = "local" * name = "Example1-Example2" * role-name = "Ex1-knows-Ex2" * related-pk-field = "example2Id" * fk-column = "fk_example2Id" * fk-constraint = "true" */ public abstract Example2Local getExample2(); * view-type = "local" */ public abstract void setExample2(Example2 example2); } public class Example2Bean { [...] * view-type = "local" * name = "Example1-Example2" * role-name = "Ex2-knows-Ex1" */ public abstract java.util.Collection getExamples(); * view-type = "local" */ public abstract void setExamples(java.util.Collection examples); }

30 Beziehungen zwischen Entity Beans
Beispiel für eine bidirektionale n:m-Beziehung public class Example1Bean { [...] * view-type = "local" * name = "Example1-Example2" * role-name = "Ex1-has-Ex2" */ public abstract java.util.Collection getExamples2(); /** * view-type = "local" */ public abstract void setExamples2(java.util.Collection examples2); } public class Example2Bean { [...] * view-type = "local" * name = "Example1-Example2" * role-name = "Ex2-has-Ex1" */ public abstract java.util.Collection getExamples1(); /** * view-type = "local" */ public abstract void setExamples1(java.util.Collection examples1); }

31 Beziehungen zwischen Entity Beans
Beispiel für eine unidirektionale 1:(1)-Beziehung public class Example1Bean { [...] view-type = "local" name = "Example1-Example2" * role-name = "Example1-has-Examples2" * target-ejb = "Example2Bean" * target-role-name = "Example2-referenced-by-Example1" * target-multiple = "no" related-pk-field = "example2Id" * fk-column = "fk_example2Id" * fk-constraint = "true" */ public abstract Example2Local getExample2(); view-type = "local" */ public abstract void setExample2(Example2Local example2); }

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
package lspi.eai.phonebook; import java.rmi.*; import javax.ejb.*; /** name="Phonebook" * display-name="PhonebookSB" * description="Business logic of a phonebook" * jndi-name="ejb/example/Phonebook" * type="Stateless" * view-type="remote" * remote-class = "lspi.eai.phonebook.PhonebookHome" remote-class = "lspi.eai.phonebook.Phonebook" */ public class PhonebookBean implements SessionBean { [...] } 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 private EntryLocalHome lookupEntryLocalHome() throws NamingException { InitialContext ctx = new InitialContext(); try { EntryLocalHome entryHome = (EntryLocalHome)ctx.lookup("ejb/example/Entry"); return entryHome; } 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 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
view-type = "remote" */ public EntryDTO findEntry(String lastname, String firstname) throws RemoteException { try { EntryLocalHome entryHome = lookupEntryLocalHome(); EntryLocal entry = entryHome.findByName(lastname, firstname); Calendar dateOfBirth = new GregorianCalendar(); dateOfBirth.setTimeInMillis( entry.getDateOfBirth().longValue()); EntryDTO entryDTO = new EntryDTO(dateOfBirth, entry .getLastname(), entry.getFirstname(), entry .getPhoneNumber()); return entryDTO; } catch (NamingException e) { throw new RemoteException(e.getMessage()); } catch (FinderException e) { return null; }

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:

38 Client-Programmierung
Zugriff auf Session Beans über JNDI Wichtig: jbossall-client.jar, Remote-/RemoteHome-Interfaces und DTO-Klassen im Pfad des Clients! public PhonebookHome getPhonebookHome() { String JBOSS_HOST = "wi-vm215.uni-muenster.de"; Properties p = new Properties(); 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 { InitialContext ctx = new InitialContext(p); phonebookHome = (PhonebookHome)ctx.lookup("ejb/example/Phonebook"); return phonebookHome; } catch (NamingException e) { e.printStackTrace(); }

39 Client-Programmierung
Benutzung der Bean im Client: try { PhonebookHome phonebookHome = getPhonebookHome(); Phonebook phonebook = phonebookHome.create(); EntryDTO entry = phonebook.findEntry("Meyer", "Ute"); } catch (CreateException ce) { ce.printStackTrace(); } catch (RemoteException re) { 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 package lspi.eai.phonebook; import java.rmi.*; public interface PhonebookSEI extends Remote { public EntryDTO findEntry(String lastname, String firstname) throws RemoteException; public EntryDTO[] findEntries() throws RemoteException; public void addEntry(EntryDTO entry) throws RemoteException; }

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 ü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

47 Literatur Roman, E., et. al.: Mastering Enterprise JavaBeans, Third Edition Engel, A., Koschel., A., Tritsch, R.: J2EE kompakt, Spektrum Akademischer Verlag 2002 Guter Einstieg in die Materie, obwohl z. T. überholt J2EE Specification 1.4 / EJB Specification 2.1 Technische Kurzdokumentationen zu J2EE (einführende Beispiel in J2EE)