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

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

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)

Java 2 Enterprise Edition Erste Einblendung: Hersteller von AS Server Zweite Einblendung: Unternehmen, die an der Spezifikation mitwirken

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)

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

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.

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

Architektur

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

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

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

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

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

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

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

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" */ public abstract class ExampleBean { [...] }

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

Definition von Entity Beans package lspi.eai.phonebook; import java.rmi.*; import javax.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" */ public abstract class EntryBean implements EntityBean { [...] } Definition der Entity Bean Angaben zur Datenbank Klassennamen der Local- und LocalHome- Interfaces

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

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

Definition von Entity Beans /** @ejb.create-method 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

Definition von Entity Beans /** @ejb.pk-field * @ejb.persistent-field * @ejb.interface-method view-type="local" */ public abstract Long getId(); /** @ejb.interface-method view-type="local" */ public abstract void setId(Long id); /** @ejb.persistent-field 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

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

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" * 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" */

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)

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

Beziehungen zwischen Entity Beans Beispiel für eine bidirektionale 1:1-Beziehung public class Example1Bean { [...] /** @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" */ public abstract Example2Local getExample2(); * view-type = "local" */ public abstract void setExample2(Example2 example2); } public class Example2Bean { [...] /** @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" */ public abstract Example1Local getExample1(); * view-type = "local" */ public abstract void setExample1(Example1 example1); }

Beziehungen zwischen Entity Beans Beispiel für eine bidirektionale 1:n-Beziehung public class Example1Bean { [...] /** @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" */ public abstract Example2Local getExample2(); * view-type = "local" */ public abstract void setExample2(Example2 example2); } public class Example2Bean { [...] /** @ejb.interface-method * view-type = "local" * @ejb.relation * 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); }

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

Beziehungen zwischen Entity Beans Beispiel für eine unidirektionale 1:(1)-Beziehung public class Example1Bean { [...] /** @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" */ public abstract Example2Local getExample2(); /** @ejb.interface-method view-type = "local" */ public abstract void setExample2(Example2Local example2); }

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

Definition von Session Beans package lspi.eai.phonebook; import java.rmi.*; import javax.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" */ public class PhonebookBean implements SessionBean { [...] } Meta-Informationen: Zustandslos, remote Interfaces sind remote

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(); }

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

Definition von Session Beans /** @ejb.interface-method 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; }

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

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(); }

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(); }

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

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; }

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>

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)

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>

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

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

Literatur Roman, E., et. al.: Mastering Enterprise JavaBeans, Third Edition http://www.theserverside.com/books/wiley/masteringEJB/index.tss 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 http://java.sun.com/j2ee/1.4/docs/#specs Technische Kurzdokumentationen zu J2EE http://www.torsten-horn.de/techdocs/#JEE (einführende Beispiel in J2EE)