Enterprise Application Integration - Department of Information Systems

Enterprise Application Integration
EAI mit der Java 2 Enterprise Edition
und Enterprise JavaBeans
Enterprise Application Integration
Björn Eilers
Prozessmanagement
Nachrichtenmanagement
Physisches Netzwerk
Enterprise Application Integration
2
Björn Eilers
Adapter
Adapter
Adapter
Adapter
Adapter
Adapter
Middleware
Java 2 Enterprise Edition
Metadatenbank für Zusatzdienste
Einordnung in funktionale Bestandteile einer EAI Infrastruktur
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)
Enterprise Application Integration
3
Björn Eilers
Java 2 Enterprise Edition
Enterprise Application Integration
4
Björn Eilers
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)
Enterprise Application Integration
5
Björn Eilers
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
Enterprise Application Integration
6
Björn Eilers
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.
Enterprise Application Integration
7
Björn Eilers
Architektur
Üblicherweise Aufteilung in vier Schichten
1.
2.
3.
4.
Clients (Browser, Thin Clients)
Präsentationslogik (JSP/JSF, Servlets)
Geschäftslogik (Enterprise JavaBeans)
Datenhaltung (relationale und XML-Datenbanken)
Auch Drei-Schichten-Architektur möglich:
1. Client mit Präsentationslogik (Fat-Client, Applet, …)
2. Geschäftslogik (Enterprise JavaBeans)
3. Datenhaltung
Enterprise Application Integration
8
Björn Eilers
Architektur
HTTP
JSP
/
JSF
Browser
Session Bean
Servlets
HTTP
Mobiltelefon
SOAP
Firewall
RMI/IIOP
Fat Client
Web
Service
Endpunkt
Session Bean
EJB Container
Web Container
Basisdienste
Sicherheit
Web
Services
XMLDienste
JMS
JavaMail
JAF
JTA/JTS
JDBC
Entity Bean
Datenbank
Web Service
Client
Message
Queue
Message-driven
Bean
Entity Bean
Datenbank
Externes System
J2EE Applikationsserver
Enterprise Application Integration
9
Björn Eilers
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 Application Integration
10
Björn Eilers
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 Application Integration
11
Björn Eilers
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 Application Integration
12
Björn Eilers
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 serverund datenbankspezifische Eigenschaften zu definieren
JAR-Archive mit Deployment Descriptoren, kompilierten Klassen
und Interfaces sowie benötigten Bibliotheken
Enterprise Application Integration
13
Björn Eilers
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
Enterprise Application Integration
14
Björn Eilers
Zugriff auf Entity und Session Beans
Beans über JNDI auffind- und zugreifbar
Konvention: Alle Beans unter Wurzel ejb/ ablegen
Ablauf:
1.
2.
3.
4.
Erzeugen eines initialen Kontext
Suchen der Bean im JNDI-Namensraum
Wenn aufgefunden, Referenz auf Bean holen
Bean benutzen
Enterprise Application Integration
15
Björn Eilers
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
Enterprise Application Integration
16
Björn Eilers
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 { [...] }
Enterprise Application Integration
17
Björn Eilers
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 BeanUmfeldes: ejbActivate, ejbPassivate, ejbLoad, ejbStore,
(un)setEntityContext
Enterprise Application Integration
18
Björn Eilers
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"
Definition der Entity Bean
*
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"
Angaben zur Datenbank
* @jboss.persistence create-table = "true" alter-table = "true"
*
Klassennamen
* @ejb.home local-class = "lspi.eai.phonebook.EntryLocalHome"
* @ejb.interface local-class = "lspi.eai.phonebook.EntryLocal" */ der Local- und
public abstract class EntryBean implements EntityBean { [...] }
Enterprise Application Integration
19
Björn Eilers
LocalHomeInterfaces
Definition von Entity Beans
import java.rmi.*;
import javax.ejb.*;
public abstract class EntryBean implements EntityBean {
private EntityContext ctx;
public
public
public
public
void
void
void
void
Lebenszyklus der Bean
ejbActivate() throws EJBException, RemoteException {}
ejbPassivate() throws EJBException, RemoteException {}
ejbLoad() throws EJBException, RemoteException {}
ejbStore() throws EJBException, RemoteException {}
public void setEntityContext(EntityContext ctx) throws EJBException {
this.ctx = ctx;
}
public void unsetEntityContext() throws EJBException {
this.ctx = null;
}
[...]
}
Enterprise Application Integration
20
Björn Eilers
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
Enterprise Application Integration
21
Björn Eilers
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);
Füllen der Entität mit
setDateOfBirth(dateOfBirth);
initialen Werten
setPhoneNumber(phoneNumber);
return null;
}
Falls notwendig,
public void ejbPostCreate(String lastname,
Erzeugung von
String firstname,
Long dateOfBirth,
Relationen
String phoneNumber) throws CreateException {
// keine Relation zu füllen
}
Enterprise Application Integration
22
Björn Eilers
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
* @ejb.interface-method view-type="local" */
public abstract String getFirstname();
public abstract void setFirstname(String firstname);
Definition persistenter
public abstract String getLastname();
Felder
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);
Enterprise Application Integration
23
Björn Eilers
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
Enterprise Application Integration
24
Björn Eilers
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"
*/
Enterprise Application Integration
25
Björn Eilers
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)
Enterprise Application Integration
26
Björn Eilers
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
Enterprise Application Integration
27
Björn Eilers
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();
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();
/** @ejb.interface-method
*
view-type = "local" */
public abstract void
setExample2(Example2 example2);
[...]
}
/** @ejb.interface-method
*
view-type = "local" */
public abstract void
setExample1(Example1 example1);
[...]
}
Enterprise Application Integration
28
Björn Eilers
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();
/** @ejb.interface-method
*
view-type = "local" */
public abstract void setExample2(Example2
example2);
[...]
}
Enterprise Application Integration
29
Björn Eilers
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();
/** @ejb.interface-method
*
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();
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
setExamples2(java.util.Collection
examples2);
[...]
/**
* @ejb.interface-method
*
view-type = "local" */
public abstract void
setExamples1(java.util.Collection
examples1);
[...]
}
}
Enterprise Application Integration
30
Björn Eilers
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);
[...]
}
Enterprise Application Integration
31
Björn Eilers
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
Enterprise Application Integration
32
Björn Eilers
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"
Meta-Informationen:
*
type="Stateless"
Zustandslos, remote
*
view-type="remote"
*
* @ejb.home remote-class = "lspi.eai.phonebook.PhonebookHome"
* @ejb.interface remote-class = "lspi.eai.phonebook.Phonebook"
*/
Interfaces sind
public class PhonebookBean implements SessionBean {
remote
[...]
}
Enterprise Application Integration
33
Björn Eilers
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();
}
}
Enterprise Application Integration
34
Björn Eilers
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
Enterprise Application Integration
35
Björn Eilers
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;
}
}
Enterprise Application Integration
36
Björn Eilers
Bean Deployment
1. Bean-Klasse implementieren
2. XDoclet auf Bean-Klasse anwenden
Generiert Local/Remote- und LocalHome/Home-Interfaces sowie
Deployment Deskriptoren
3. Quellen kompilieren
4. Kompilierte Klassen und Deployment Deskriptoren in JAR-Datei
packen
Klassen mit Packagestruktur übernehmen
Deployment-Deskriptoren in Unterverzeichnis META-INF/ packen
5. 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
Enterprise Application Integration
37
Björn Eilers
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();
}
}
Enterprise Application Integration
38
Björn Eilers
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();
}
Enterprise Application Integration
39
Björn Eilers
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
Enterprise Application Integration
40
Björn Eilers
EAI mit J2EE: Session Bean als Web Service
1. 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;
}
Enterprise Application Integration
41
Björn Eilers
EAI mit J2EE: Session Bean als Web Service
2. Deployment Descriptor ejb-jar.xml aktualisieren
Hinzufügen eines <service-endpoint>-Tags unter /ejb-jar/enterprisebeans/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>
Enterprise Application Integration
42
Björn Eilers
EAI mit J2EE: Session Bean als Web Service
3. 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 JavaDatentypen auf Web Service-Elemente ab)
Enterprise Application Integration
43
Björn Eilers
EAI mit J2EE: Session Bean als Web Service
4. 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-mappingfile>
<port-component>
<port-component-name>PhonebookService</port-component-name>
<wsdl-port>PhonebookSEIPort</wsdl-port>
<service-endpoint-interface>lspi.eai.phonebook.PhonebookSEI</serviceendpoint-interface>
<service-impl-bean>
<ejb-link>Phonebook</ejb-link>
</service-impl-bean>
</port-component>
</webservice-description>
</webservices>
Enterprise Application Integration
44
Björn Eilers
EAI mit J2EE: Session Bean als Web Service
5. Beans und Deployment Deskriptoren in JAR-Archiv packen
WSDL-Datei in Verzeichnis META-INF/wsdl
webservices.xml und Mapping-Datei nach META-INF
6. 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)
7. Ansprechen des Web Services über Axis
Generierung der Client-Dateien wie in WS-Vorlesung mithilfe von
WSDL2Java
Enterprise Application Integration
45
Björn Eilers
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
<<EntityBean>>
Entry
-id : long
-lastname : String
-firstname : String
-dateOfBirth : long
-telephoneNumber : String
<<ValueObject>>
EntryDTO
<<SessionBean>>
Phonebook
+createNew Entry( entry : EntryDTO )
+findEntry( lastname : String, firstname : String )
+getEntries()
1
-id : long
-lastname : String
-firstname : String
-dateOfBirth : Calendar
-telephoneNumber : String
-phonebook
0..*
PhonebookGUI
+...()
Enterprise Application Integration
46
Björn Eilers
-entries
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)
Enterprise Application Integration
47
Björn Eilers