Enterprise Java Beans

1
Enterprise Java Beans

• Was sind Enterprise JavaBeans?
• Historie
• Motivation
• Architektur
• Konstruktion eines Enterprise JavaBeans
• Zusammenspiel mit anderen Architekturen

2
Was sind Enterprise JavaBeans?

• Industriell unterstützte serverseitige
  Komponentenarchitektur für die Java-Plattform
• über 40 Softwareentwickler haben Ihre
  Unterstützung für EJB Technolgie in Ihren
  Produkten zugesagt
• EJB ist kein Produkt, sondern eine Spezifikation,
  die die Architektur der EJB-Komponenten und
  Schnittstellen zwischen EJB-Server und
  EJB-Komponenten definiert
• die Spezifikation wird von SUN entwickelt - dies
  soll aber in Kooperation mit dem Feedback der
  industriellen Partner und der Öffentlichkeit
  geschehen

3
Historie

• Erste Spezifikation 1.0 herausgegeben von SUN am
  24. März 1998
• erste Produkte im frühen Sommer 1998
  herausgebracht
• erste größere Produkte (EJB-Server) jetzt
  verfügbar
• EJB-Deployathon Event auf der JavaOne99
  Konferenz (15-18 Juni)
• anhand einer Beispielanwendung (Car Shipping)
  wird bei fertigen EJB-Server-Implementation
  demonstriert, ob und wie gut sie die
  EJB-Spezifikation (nur 1.0 erforderlich) erfüllen
• http//java.sun.com/features/1999/06/ejbdeploy.htm
  l
• EJB Spezifikation 1.1 Public Draft 2 am 24. Juni
  herausgegeben

4
Motivation

• Client/Server Modelle two-tier entwickelten
  sich zu three-tier (oder multi-tier) Modellen
• Konzentration der fachlichen Anwendungslogik
  (business logic) in middle-tier mit
  unterliegenden Diensten für die Infrastruktur und
  client-seitigen Applikationen für die
  Benutzerschnittstelle
• aus Zusammenschluß von drei Entwicklungskonzepten
  bildete SUN den EJB Standard
• serverseitige Anwendungen in Java (wie mit
  Servlets eingeleitet)
• Konnektoren zu bestehenden Enterprise Systemen
  (wie z.B. mit JDBC für Datenbanken)
• modulare, einfach zu verwendene Komponenten (wie
  bei JavaBeans)
• Skalierbarkeit, einfache Entwicklung, Verwendung,
  Pflege und WORA (write once, run anywhere) für
  die Anwendungslogik

5
Architektur

• EJB- Architektur Standardarchitektur für
  Entwicklung von fachlicher Anwendungslogik in
  multi-tier Anwendungen als wiederverwendbare
  Komponenten
• Teile der Architektur und deren Aufgaben
• EJB Server
• kapselt die vorhandenen Systeme und Resourcen, um
  fundamentale Dienste in einer standardisierten
  Schnittstelle für die Beans anzubieten
• EJB home interface
• ermöglicht Zugriff auf Dienste zum Lebenszyklus
  eines Beans
• nur für entity-beans gibt Methoden zum Auffinden
  von Exemplaren an
• EJB remote interface
• deklariert Methoden für fachlichen Zugriff auf
  das Beans

6
Architektur

• EJB Komponenten (die eigentlichen Beans)
• Implementation von Methoden korrespondierend zum
  home interface
• Implementation von einfachen Callback-Interfaces
  zur Unterstützung der von Container zur Verfügung
  gestellten Dienste
• Implementation fachliche Anwendungslogik nach
  remote interface
• Session-Beans
• existieren nur für die Dauer einer Sitzung
  zwischen Client und Server
• eingesetzt für Berechnungen oder Zugriffe auf
  Datenbanken
• Entity-Beans
• bilden Objektrepräsentationen von persistenten
  Daten
• jedes Exemplar mit Primärschlüssel gekennzeichnet
• können Ihre Persistenz selbst verwalten oder
  Container überlassen
• Deployment Descriptor
• enthält Einstellungen für Lebenszyklus,
  Transaktionsverhalten, Sicherheit und Persistenz
  des Beans

7
Architektur

• EJB Container
• implementiert home und remote interfaces des
  Beans bei Installation des Beans im Server und
  veröffentlicht es unter Verwendung von JNDI
• hängt sich über Interfaces des Beans zwischen
  alle Methodenaufrufe des Clients an ein Bean -
  dies geschieht transparent für den Client
• verwaltet Lebenszyklus der Komponenten,
  Transaktionen und Sicherheit und bei Bedarf auch
  Persistenz nach Angaben im deployment descriptor
• verdeckt für den Client die mögliche Trennung von
  Bean und Client in verschiedene Umgebungen auf
  verschiedenen Systemen im Netzwerk
• der Container ist damit nicht unbedingt eine
  physikalische Einheit
• EJB-Client
• findet Beans per JNDI
• verwendet Beans über home und remote interfaces

8
Konstruktion

• Konstruktion einessession beans
• remote interface
• home interface
• bean class
• deployment descriptor
• client

• Bean ist in jedem EJB-Container/-Server
  lauffähig, wobei nur der deployment descriptor
  und vielleicht der Client-Code angepasst werden
  müssen

9
Konstruktion remote interface

• gibt die anwendungsfachliche Schnittstelle des
  Beans zum Client an
• Implementation des Interface geschieht durch den
  Container bei der Installation des Beans im
  Server, damit sich der Container bei allen
  Client-Methodenaufrufen einklinken kann
• der Entwickler muß entsprechende Methoden auch am
  Bean implementieren
• package ejb.demo
• import java.rmi.RemoteException
• import java.rmi.Remote
• import javax.ejb.
• public interface Demo extends EJBObject, Remote
• public String demoSelect() throws
  RemoteException

10
Konstruktion home interface

• anhand des home interface kann der Container ein
  neues Bean auf Geheiß des Clients erzeugen
• Implementation des Interface geschieht ebenfalls
  durch den Container bei der Installation des
  Beans im Server, so daß sich der Container bei
  allen Client-Methodenaufrufen einklinken kann
• package ejb.demo
• import javax.ejb.
• import java.rmi.Remote
• import java.rmi.RemoteException
• import java.util.
• public interface DemoHome extends EJBHome
• public Demo create() throws CreateException,
  RemoteException

11
Konstruktion bean class

• package ejb.demo
• import javax.ejb.
• import java.io.Serializable
• import java.util.
• import java.rmi.
• public class DemoBean implements SessionBean
• Implementation der durch die EJB-Spezifikation
  vorgegebenen Schnittstellen für ein Bean
• // Implement the methods in the SessionBean
  interface
• public void ejbActivate() ...
• public void ejbRemove() ...
• public void ejbPassivate() ...
• // Sets the session context. _at_param
  SessionContext
• public void setSessionContext(SessionContext
  ctx) ...

12
Konstruktion bean class

• wenn die Methode create() im home interface
  aufgerufen wird, erzeugt der Cointainer ein Bean
  und ruft daran die folgende Methode auf
• public void ejbCreate () ...
• die eigentliche Implementation der
  Anwendungslogik (business logic) wie auch schon
  im remote interface angegeben
• public String demoSelect() throws
  RemoteException
• return("hello world")

13
Konstruktion deployment descriptor

• Zur Erinnerung der Begriffsbildung
• deployment Installation eines Enterprise
  JavaBeans in einen Enterprise JavaBeans
  Container, dabei werden u.a. die Klassen zur
  Implemention des home und remote interfaces
  erzeugt
• deployment descriptor enthält Einstellungen für
  Lebenszyklus, Transaktionsverhalten, Sicherheit
  und Persistenz des Beans, nach denen der
  Container das Bean verwaltet
• Es gibt keinen vorgeschriebenen Weg, den
  deployment descriptor zu erzeugen, dies geschieht
  nach der jeweiligen Implemention des EJB
  Servers/Containers
• Anpassungen notwendig bei Wechsel des EJB-Servers

14
Konstruktion client

• package ejb.demo
• import javax.ejb.
• import javax.naming.
• import java.rmi.
• import java.util.Properties
• public class DemoClient
• public static void main()
• try
• Erzeugung eines Kontext für JNDI
• Properties p new Properties()
• p.put(Context.INITIAL_CONTEXT_FACTORY,
  "weblogic.jndi.T3InitialContextFactory")
• p.put(Context.PROVIDER_URL, "t3//localhost700
  1")
• Context ctx new InitialContext(p)
• hier ist der Client-Code abhängig vom verwendeten
  EJB-Server und muß bei einem Wechsel angepaßt
  werden

15
Konstruktion client

• Lookup des home interface per JNDI
• DemoHome dhome (DemoHome) ctx.lookup("demo.De
  moHome")
• Erzeugung eines Exemplars des JavaBeans durch den
  Container anhand der create()-Methode des home
  interface
• Demo demo dhome.create()
• Aufruf der Anwendungslogik im JavaBeans durch den
  Container anhand der Schnittstelle im remote
  interface
• System.out.println("The result is "
  demo.demoSelect())
• catch (Exception e) System.out.println(" gt
  Error lt") e.printStackTrace()

16
Zusammenspiel mit anderen Architekturen

• EJB und Corba
• EJB soll Corba jetzt und in Zukunft unterstützen
• Beans remote und home interfaces basieren auf RMI
  und können daher mit CORBA Objekten über RMI/IIOP
  (RMI Adaption von SUN/IBM, die das IIOP Protokoll
  erfüllt) zusammenarbeiten
• Für die EJB API hat SUN eine standardisierte
  Abbildung auf CORBA IDL geschaffen
• JTA (für Transaktionsverwaltung) kann leicht als
  Schicht über OMG OTS gelegt werden
• Transaktionen können vom Container, aber auch vom
  Client oder Beans selbst verwaltet werden, die
  dann JTA verwenden können
• Persistenz kann vom Container oder Beans selbst
  verwaltet werden, welches dann JDBC/JSQL
  verwenden kann