J2EE Architektur by bzs12927

VIEWS: 98 PAGES: 61

									                                      Java
                                      Prof. Dr. Michael Hendrix

                  J2EE Architektur


J2EE: Sun Referenz-Implementierung



                      J2EE Server

                     EJB Container

                   Enterprise
                   Bean

                         Enterprise
                         Bean

                      Enterprise
                      Bean                              Datenbank
 Client
                                                        Server


                     Web Container

                      JSP File


                          Servlet
                                                        Java
                                                        Prof. Dr. Michael

                                         J2EE Dienste


HTTP
         Zugriff auf Servlets und JSP


EJB
         Zugriff auf EJB-Methoden


Naming und Directory
    lokalisiert Dienste und Komponenten mittels JNDI


Authentication
     User Log-In
                                                                           Java
                                                                           Prof. Dr. Michael

                                     EJB Container


Transaction Management
     Beschreibung verteilter Transaktionen im 'Deployment Descriptor'
     kein komplexer Code in den EJBs


Security
     Definition von Rollen im 'Deployment Descriptor'


Remote Client Connectivity
    Low Level Client/Server Kommunikation über VM Grenzen hinweg


Life Cycle Management
      Container ist zuständig für das Erzeugen, Entfernen etc. von EJBs


Database Connection Pooling
     Management eines Pools von Datenbank-Verbindungen
                                                               Java
                                                               Prof. Dr. Michael

                      Inhalt einer J2EE Anwendung



                            J2EE Application

                            J2EE App. DD

                                  .ear Datei




J2EE App. Client            Enterprise Bean         Web Component

J2EE App. Client DD        EJB DD                   Web Comp. DD
Java App.                  EJB Class                JSP Datei
                           Remote Interface         Servlet Class
                           Home Interface           GIF Datei
                                                    HTML Datei

      .jar Datei                 .jar Datei              .war Datei
                                      Java
                                      Prof. Dr. M. Hendrix

  Dateien in J2EE Anwendungen


            Element          Dateityp
J2EE Application             .ear
J2EE Application DD          .xml
Enterprise Bean              .jar
Enterprise Bean DD           .xml
EJB Class                    .class
Remote Interface             .class
Home Interface               .class
Web Component                .war
Web Component DD             .xml
JSP File                     .jsp
Servlet Class                .class
GIF File                     .gif
HTML File                    .html
J2EE Application Client      .jar
J2EE Application Client DD   .xml
Java Application             .class
                                                                         Java
                                                                         Prof. Dr. M. Hendrix

                               Deployment Descriptor


beschreibt Details des Deployment Prozesses
     Content
     Sicherheitseinstellungen
     Transaktionen
     Zustand
    etc.


Applikation: sun-j2ee-ri.xml   lib/dtds/sun-j2ee-ri.dtd
             application.xml   http://java.sun.com/j2ee/dtds/application_1_2.dtd

EJB:         ejb-jar.xml       http://java.sun.com/j2ee/dtds/ejb-jar_1_1.dtd

Web Comp.: web.xml             http://java.sun.com/j2ee/dtds/web-app_2.2.dtd
                                          Java
                                          Prof. Dr. M. Hendrix

              Beispiel: sun-j2ee-ri.xml


<?xml version="1.0" encoding="Cp1252"?>

<j2ee-ri-specific-information>
   <server-name></server-name>
   <rolemapping/>
   <web>
     <display-name>BonusWar</display-name>
     <context-root>BonusRoot</context-root>
   </web>
   <enterprise-beans>
     <ejb>
        <ejb-name>CalcBean</ejb-name>
        <jndi-name>calcs</jndi-name>
     </ejb>
   </enterprise-beans>
</j2ee-ri-specific-information>
                                              Java
                                              Prof. Dr. M. Hendrix

               Beispiel: application.xml


<?xml version="1.0" encoding="Cp1252"?>

<!DOCTYPE application PUBLIC
'-//Sun Microsystems, Inc.//DTD J2EE Application 1.2//EN'
'http://java.sun.com/j2ee/dtds/application_1_2.dtd'

<application>
  <display-name>BonusApp</display-name>
  <description>bla bla bla</description>
  <module>
    <ejb>ejb-jar-ic.jar</ejb>
  </module>
  <module>
    <web>
       <web-uri>war-ic.war></web-uri>
       <context-root>BonusRoot</context-root>
    </web>
  </module>
</application>
                                             Java
                                             Prof. Dr. M. Hendrix

                  Beispiel: ejb-jar.xml


<?xml version="1.0" encoding="Cp1252"?>

<!DOCTYPE ejb-jar PUBLIC
'-//Sun Microsystems, Inc.//DTD Enterprise Java Beans
1.1//EN'
'http://java.sun.com/j2ee/dtds/ejb-jar_1_1.dtd'

<ejb-jar>
  <description>bla bla bla</description>
  <display-name>CalcJar</display-name>
  <enterprise-beans>
     <session>
        <description>bla bla bla<description>
        <display-name>CalcBean</display-name>
        <ejb-name>CalcBean</ejb-name>
        <home>Beans.CalcHome</home>
        <remote>Beans.Calc</remote>
        <ejb-class>Beans.CalcBean</ejb-class>
        <session-type>Stateless</session-type>
        <transaction-type>Bean</transaction-type>
     </session>
  </enterprise-beans>
</ejb-jar>
                                              Java
                                              Prof. Dr. M. Hendrix

                   Beispiel: web.xml


<?xml version="1.0" encoding="Cp1252"?>

<!DOCTYPE web-app PUBLIC
'-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN'
'http://java.sun.com/j2ee/dtds/web-app_2.2.dtd'

<web-app>
  <display-name>BonusWar</display-name>
  <description>no description</description>
  <servlet>
    <servlet-name>BonusServlet</servlet-name>
    <display-name>BonusServlet</display-name>
    <description>no description</description>
    <servlet-class>BonusServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>BonusServlet</servlet-name>
    <url-pattern>BonusAlias</url-pattern>
  </servlet-mapping>
  <session-config>
    <session-timeout>30</session-timeout>
  </session-config>
</web-app>
                                                                Java
                                                                Prof. Dr. M. Hendrix

                         Erzeugen einer J2EE Applikation


Starten des J2EE-Servers: j2ee -verbose

         (Herunterfahren des Servers: j2ee -stop)


Starten des "Application Deployment Tool":    deploytool


Erzeugen einer neuen J2EE Anwendung mittels Deployment Tool

    1.   Neue Applikation erstellen  z.B. ConverterApp.ear
    2.   Neue Enterprise-Beans bzw. Web-Komponenten erstellen
    3.   Deploy-Application starten


Ändern einer vorhandenen J2EE-Applikation

    'Update and Redeploy Application'
                                                                                 Java
                                                                                 Prof. Dr. M. Hendrix

                                      Enterprise Java Beans


                          Session Bean                             Entity Bean
               führt Client-Aufgabe aus
Zweck          repräsentiert den Client             Business Objekt
               Client-Erweiterung
Zugriff       nur für einen Client                   kann mehrere Clients bedienen
                                                     persistent, auch nach dem Runterfahren
Persistenz    i.a. nicht persistent
                                                     des Servers


Beispiel für Session Bean

    Ein Online-Shopping Client könnte seinen Session Bean beauftragen, eine Bestellung zu
    erzeugen (Aufruf einer Bean-Methode getOrder)


Beispiel für Entity Bean

    Ein Entity Bean könnte einen Kunden repräsentieren, der in der Relationalen Datenbank
    als Zeile der Kundentabelle gespeichert ist
                                    Java
                                    Prof. Dr. Michael Hendrix




                    J2EE Server

                  EJB Container

Datenbank             Produkt
Server                Entity Bean


            Bestellung                Kunde
            Entity Bean               Entity Bean



                     Shopping
                     Session Bean




Web                       Servlet
Browser

                    Web Container
                                        Java
                                        Prof. Dr. Michael Hendrix

                         Rollen


Bean-Provider
     codieren die Beans, schreiben die Programmlogik

Anwendungsintegrator
    schreibt Anwendungen, die Beans verwenden
    z.B. GUI-Clients,Servlets, JSP

Server-Provider
     stellt Anwendungsrahmen und low-level-Dienste
       bereit
     z.B. Transaktionsdienst, Naming-Service

Container-Provider
     stellt Weitergabe-Tools (Deployment) bereit
     häufig Container-Provider = Server-Provider

Weitergebender (Deployer)
     adaptiert die EJB-Anwendung an die Zielumgebung
     legt Transaktions- und Sicherheitsrichtlinien fest
      (mittels Eintrag in den Deployment-Descriptor)

Systemadministrator
     konfiguriert und verwaltet die Enterprise-
      Datenverarbeitungs- und Netzwerkinfrastruktur
     überwacht die Ausführung
                                                                     Java
                                                                     Prof. Dr. Michael Hendrix

                                     EJB Konzept


1. Client fordert Objektreferenz vom Nameservice (JNDI) an

2. Nameservice liefert Home-Object

3. Client ruft create-Methode des Home-Objektes (Remote Call to EJB Container)
    EJB-Instanz wird erzeugt
    EJB-Object (Remote Interface) wird an den Client zurückgegeben


        EJB Client                            EJB Server
                                            EJB Container
  EJB Object                                                                         Persistence
  (Remote Interface)

                                                 EJB Instanz




4. Client ruft Business-Methoden des EJB-Objektes (Remote Call)
                                                                 Java
                                                                 Prof. Dr. Michael Hendrix

                            Erzeugen einer EJB-Anwendung


1. Codieren des Home-Interfaces

2. Codieren des Remote-Interfaces

3. Codieren der EJB-Class

4. Erzeugen des Deployment Descriptors

5. Erzeugen eines ejb-jar Files mit folgendem Inhalt:
        Home Interface
        Remote Interface
        EJB Class
        Deployment Descriptor
        Manifest File

6. Deployment: ejb-jar File an den Runtime-Container übergeben


7. Codieren des Clients
                                                               Java
                                                               Prof. Dr. Michael Hendrix

            Beispiel: Enterprise Bean zur Konvertierung von Währungen


Folgender Code ist erforderlich:

     Remote Interface

     Home Interface

     Enterprise Bean Class
                                                                             Java
                                                                             Prof. Dr. Michael Hendrix

                                     Remote Interface


definiert die Methoden für Geschäftsprozesse, die ein Client aufrufen kann


import javax.ejb.EJBObject;
import java.rmi.RemoteException;

public interface Converter extends EJBObject
    {
    public double dollarToEuro(double dollars) throws RemoteException;
    public double euroToDollar(double euros) throws RemoteException;
    }
                                                                       Java
                                                                       Prof. Dr. Michael Hendrix

                                    Home Interface


definiert die Methoden zum Erzeugen, Suchen oder Entfernen einer Enterprise Bean


import java.io.Serializable;
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;

public interface ConverterHome extends EJBHome
    {
    Converter create() throws RemoteException, CreateException;
    }
                                                           Java
                                                           Prof. Dr. Michael Hendrix

                                Enterprise Bean Class

import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
public class ConverterEJB implements SessionBean
    {
    public double dollarToEuro(double dollars)
          {
          return(dollars*102.4);
          }

    public double euroToDollar(double euros)
        {
        return(euros*0.977);
        }

    public ConverterEJB() { }
    public void ejbCreate() { }
    public void ejbRemove() { }
    public void ejbActivate() { }
    public void ejbPassivate() { }
    public void setSessionContext(SessionContext sc) { }
    }
                                                               Java
                                                               Prof. Dr. Michael Hendrix

                       Compilieren des Bean-Quellcodes


set J2EE_HOME=j2ee-homeverzeichnis

set CPATH=.;%J2EE_HOME%\lib\j2ee.jar

javac -classpath %CPATH% ConverterEJB.java ConverterHome.java Converter.java
                                                                   Java
                                                                   Prof. Dr. Michael Hendrix

                                 Deployment-Prozess


1. Transfer einer Kopie der .jar-Datei zum j2ee-Prozess

2. Die .jar-Datei im Repository gespeichert:
            $J2EE_HOME/repository/<hostname>/applications

3. Der Deployment-Descriptor wird gelesen und der Source-Code für das Home-Interface
   und das EJB-Object generiert und gespeichert:
          $J2EE_HOME/repository/<hostname>/gnrtrTMP

4. Beide Dateien werden compiliert und rmic gestartet  Stub und Skeleton
          Erzeugen von server.jar
          im Repository gespeichert

5. Eine Datei client.jar wird erzeugt
          Inhalt: Home-Interface, Remote-Interface, Stubs für Home- u. Remote-Objekt
          wird im CLASSPATH gespeichert

6. Web-Komponenten werden im Web-Server installiert

7. Erzeugen eines Containers und Einfügen der Beans in den Runtime-Prozess
                                                                    Java
                                                                    Prof. Dr. Michael Hendrix

                 Einfügen der Enterprise Bean in die Applikation


Folgende Schritte sind auszuführen (mittels "New Enterprise Bean Wizard" des
"Application Deployment Tool")

    1. Erzeugen des Bean "deployment descriptor"

    2. Packen des "deployment descriptor" und der Bean Klassen in eine jar-Datei

    3. Einfügen der jar-Datei in die Applikation ConverterApp.ear


Bemerkung: Das Manifest-File wird vom Tool automatisch erzeugt
                                                                   Java
                                                                   Prof. Dr. Michael Hendrix

                          Installieren der J2EE Applikation


Folgende Schritte sind mittels "Application Deployment Tool" auszuführen:

    1. Definieren des JNDI Namen für die Enterprise Bean: MyConverter

    2. Installieren der Applikation


JNDI

    Java Naming and Directory Interface

    Standard-Erweiterung zum Java-Core-API

     Lokalisieren und Benutzen von Resourcen mittel JNDI-Name

     Erhalten von Informationen über die Resource
                                                           Java
                                                           Prof. Dr. Michael Hendrix

                                     Codieren des Client


 Lokalisieren des Home Interfaces

 Erzeugen einer Enterprise Bean Instanz

 Aufruf einer Business-Methode
                                                              Java
                                                              Prof. Dr. Michael Hendrix

                                  Codegerüst des Client
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.rmi.PortableRemoteObject;
import Converter;
import ConverterHome;

public class ConverterClient
    {
    public static void main(String[] args)
          {
          try
              {
              // Lokalisieren des Home Interfaces
              // Erzeugen einer Enterprise Bean Instanz
              // Aufruf der Business-Methode
              }
          catch (Exception ex)
              {
              System.err.println("Unerwartete Exception!");
              ex.printStackTrace();
              }
          }
    }
                                                                    Java
                                                                    Prof. Dr. Michael Hendrix

                             Lokalisieren des Home Interfaces


Erzeugen eines JNDI Namenkontextes:

    Context initial = new InitialContext();


Holen des Objektes, das an den JNDI-Namen gebunden ist

    java.lang.Object objref = initial.lookup("MyConverter");


Die Referenz auf ein ConverterHome-Objekt beschränken (casten)

    ConverterHome home
        = (ConverterHome) PortableRemoteObject.narrow(objref, ConverterHome.class)
                                                                Java
                                                                Prof. Dr. Michael Hendrix

                       Erzeugen einer Enterprise Bean Instanz


Converter currencyConverter = home.create();




                              Aufruf einer Business-Methode


double betrag = currencyConverter.dollarToEuro(100.00);




                               Entfernen der Bean Instanz


currencyConverter.remove();
                                                    Java
                                                    Prof. Dr. Michael Hendrix

                                    Session Beans


Zweck von Session Beans

    Ausführen von Business-Taks für den Client


Beispiel: Online-Shop, Session Bean als Warenkorb

    Methoden:    addBook
                 removeBook
                 retrieveCart


Notwendige Komponenten

     Session Bean Class
     Home Interface
     Remote Interface
                                                                      Java
                                                                      Prof. Dr. Michael Hendrix

Anforderungen an eine Session Bean Class

       das SessionBean Interface muss implementiert sein
       die Klasse muss 'public' sein
       die Klasse darf nicht 'abstract' oder 'final' sein
       eine oder mehrere ejbCreate-Methoden müssen definiert sein
       Business-Methoden sollen implementiert sein
       ein parameterloser 'public'-Konstruktor muss vorhanden sein
       eine finalize-Methode darf nicht implementiert sein


SessionBean Interface

    SessionBean Interface


    EnterpriseBean Interface


    Serializable Interface
                                                                         Java
                                                                         Prof. Dr. Michael Hendrix

ejbCreate

    Enterprise Bean befindet sich im EJB-Container
         keine direkte Instantiierung einer Bean durch den Client möglich


    Typischer Ablauf

        1. der Client ruft die create-Methode des Home-Objektes

        2. der EJB-Container instantiiert die Enterprise Bean

        3. der EJB-Container ruft die entsprechende ejbCreate-Methode


    Eigenschaften

        es sind mehrere ejbCreate-Methoden möglich (mit unterschiedlichen Parametern)

        der Rückgabewert muss void sein

        die Argumente müssen legale Java RMI Typen sein

        die Methoden dürfen weder 'static' noch 'final' definiert sein
                                                                        Java
                                                                        Prof. Dr. Michael Hendrix

Business Methoden

    müssen 'public' definiert sein

    dürfen weder 'static' noch 'final' definiert sein

    Argumente und Rückgabewert müssen legale Java RMI Typen sein


Home Interface

    extends EJBHome

    deklariert die create-Methode für den Client

          throws java.rmi.RemoteException, javax.ejb.CreateException

          die Argumente müssen denen in der ejbCreate-Methode entsprechen

          Rückgabewert: Typ des Remote Interfaces der Enterprise Bean
           (nicht void wie bei ejbCreate)
                                                                     Java
                                                                     Prof. Dr. Michael Hendrix

Remote Interface

    extends javax.ejb.EJBObject

    throws java.rmi.RemoteException

    jeder Methodendeklaration muss eine Methoden-Implementierung in der Enterprise Bean
    Class entsprechen
                                                                          Java
                                                                          Prof. Dr. Michael Hendrix

                                  Stateless Session Beans


Ob 'stateless' oder 'stateful' wird im Deployment-Descriptor festgelegt


 Die Bean speichert keinen internen Zustand (keine Klassenvariablen)

 Die Bean kann mehrere Clients bedienen  bessere Skalierbarkeit

 Das Home-Interface hat nur eine parameterlose create-Methode


Beispiel:

            Bean, die Methoden zum Sortieren zur Verfügung stellt
                                                                       Java
                                                                       Prof. Dr. Michael Hendrix

                                  Stateful Session Beans


 Die Bean hat einen internen Zustand (in Form von Klassenvariablen)

 Die Bean bedient nur einen Client (repräsentiert einen Client)

 Das Home-Interface hat üblicherweise auch parameterbehaftete create-Methoden

 Der Container kann die Bean auf einen Sekundärspeicher auslagern
     i.a. schlechtere Performance als bei 'stateless beans'


Beispiel:

            Warenkorb eines Online-Shops
                                                   Java
                                                   Prof. Dr. Michael Hendrix

       Lebenszyklus einer Stateless Session Bean




                       Does Not
                       Exist



1. setSessionContext              ejbRemove
2. ejbCreate



                       Ready
                                                                      Java
                                                                      Prof. Dr. Michael Hendrix

                         Lebenszyklus einer Stateful Session Bean



                            Does Not
                            Exist



1. create                               1. remove
2. set Session Context                  2. ejbRremove
3. ejbCreate


                                            ejbPassivate
                            Ready                                   Passive


                                            ejbActivate
                                                                        Java
                                                                        Prof. Dr. Michael Hendrix

                                       Entity Beans


Zweck von Entity Beans

    Repräsentation einer Entity in einem persistenten Speicher (z.B. Datenbank)


Eigenschaften

    persistent (Container- oder Beans-verwaltete Persistenz)

    shared access

    primary key (eindeutige Objekt-Identifizierung)


Notwendige Komponenten

     Entity Bean Class
     Home Interface
     Remote Interface
                                                                       Java
                                                                       Prof. Dr. Michael Hendrix

                                       Persistenz


Bean-Managed- oder Container-Managed-Persistence
     wird im Deployment-Tool festgelegt (Eintrag in den Deployment-Descriptor)


Bean-Managed-Persistence

    ein Datenbank-Zugriff muss explizit programmiert werden
          z.B. SQL-insert-Statement in der ejbCreate-Methode


Container-Maneged-Persistence

    ein Datenbank-Zugriff wird automatisch generiert  keine SQL-Statements im Code

    Vorteile:
         schlankerer Code
         unabhängig von der eingesetzten Technologie (relationale Datenbank, XML etc.)
                                                                      Java
                                                                      Prof. Dr. Michael Hendrix

                 Beispiel mit Bean Managed Persistence: Bankkonto


Der Zustand der Entity Bean ist in einer Konto-Tabelle gespeichert.

Die Konto-Tabelle wurde durch folgende SQL-Anweisungen erzeugt:

    CREATE TABLE konto
       (id         VARCHAR(3) CONSTRAINT pk_konto PRIMARY KEY,
        vorname    VARCHAR(24),
        nachname VARCHAR(24),
        kontostand DECIMAL(10,2));


Entity Bean Klasse: Konto
                                                                        Java
                                                                        Prof. Dr. Michael Hendrix

Entity Bean Klasse


 muss das EntityBean Interface implementieren

 muss 'public' definiert sein

 darf nicht 'abstract' oder 'final' definiert sein

 kann 0 oder mehrere ejbCreate- und ejbPostCreate-Methoden implementieren

 kann Finder-Methoden implementieren (falls Persistenz von der Bean verwaltet wird)

 implementiert Business-Methoden

 muss einen leeren Konstruktor implementieren

 darf die Methode finalize nicht implementieren
                           Java
                           Prof. Dr. Michael Hendrix

  EntityBean Interface


 Serializable Interface




EnterpriseBean Interface




  EntityBean Interface
                                                                        Java
                                                                        Prof. Dr. Michael Hendrix

                                          ejbCreate


wird vom Container als Folge eines Client-Aufrufs der create-Methode aufgerufen


    fügt den Zustand der Entity in die Datenbank ein

    initialisiert die Instanz-Variablen

    Rückgabewert: Primärschlüssel
                                                                         Java
                                                                         Prof. Dr. Michael Hendrix

public String ejbCreate(String id, String vorname, String nachname, double kontostand)
    throws CreateException
    {
    if (kontostand < 0.0)
          throw new CreateException("Ein negativer Kontostand ist nicht erlaubt.");

    try
        {
        insertRow(id, vorname, nachname, kontostand);
        }
    catch (Exception ex)
        {
        throw new EJBException("ejbCreate: " + ex.getMessage());
        }

    this.id = id;
    this.vorname = vorname;
    this.nachname = nachname;
    this.kontostand = kontostand;

    return(id);
    }
                                                                        Java
                                                                        Prof. Dr. Michael Hendrix

                                         ejbPostCreate

für jede ejbCreate-Methode muss eine ejbPostCreate-Methode implementiert werden

ejbPostCreate wird vom EJB-Container direkt nach ejbCreate aufgerufen

ejbPostCreate wird oft leer implementiert

kann im Gegensatz zu ejbCreate die im EntityContext Interface deklarierten Methoden
         getPrimaryKey
         getEJBObject
aufrufen


Eigenschaften:

    Anzahl und Typ der Argumente muss der entsprechenden ejbCreate-Methode
    entsprechen

    muss 'public' definiert sein

    darf weder 'final' noch 'static' definiert sein

    Rückgabewert: void
                                                                            Java
                                                                            Prof. Dr. Michael Hendrix

                                         ejbRemove


entfernt die Entity Bean und löscht den Entity-Zustand von der Datenbank


public void ejbRemove()
    {
    try
         {
         deleteRow(id);
         }
    catch (Exception ex)
         {
         throw new EJBException("ejbRemove: " + ex.getMessage());
         }
    }


Bem.:

    falls direkt in der Datenbank die Zeile, die den Entity-Zustand speichert, gelöscht wird,
    wird die zugehörige Entity Bean automatisch entfernt
                                                                     Java
                                                                     Prof. Dr. Michael Hendrix

                                 ejbLoad und ejbStore

müssen implementiert werden

werden vom EJB-Container zu Zwecken der Synchronisation aufgerufen

    z.B. bei Transaktionen (im Zusammenhang mit COMMIT bzw. ROLLBACK)

    ejbLoad wird vor der Transaktion aufgerufen

    ejbStore wird nach der Transaktion aufgerufen

dürfen nicht vom Client aufgerufen werden
                                                                  Java
                                                                  Prof. Dr. Michael Hendrix

public void ejbLoad()
    {
    try
         {
         loadRow();
         }
    catch (Exception ex)
         {
         throw new EJBException("ejbLoad: " + ex.getMessage());
         }
    }


public void ejbStore()
    {
    try
         {
         storeRow();
         }
    catch (Exception ex)
         {
         throw new EJBException("ejbLoad: " + ex.getMessage());
         }
    }
                                                                        Java
                                                                        Prof. Dr. Michael Hendrix

                                     Finder-Methoden

Zweck:

    erlauben dem Client, Entity Beans zu lokalisieren

    zu jeder clientseitigen finder-Methode muss die Entity Bean Klasse eine entsprechende
    Methode implementieren (Prefix: ejbFind)

    Client ruft finder-Methode  Container ruft ejbFind-Methode


Eigenschaften:

    die ejbFindByPrimaryKey muss implementiert werden (weitere können implementiert
    werden, z.B. ejbFindByLastName)

    der Name einer Finder-Methode muss mit ejbFind beginnen

    die Methode muss 'public' definiert werden

    die Methode darf weder 'final' noch 'static' definiert werden

    Rückgabewert: "primary key" oder "collection of primary keys"
                                                                        Java
                                                                        Prof. Dr. Michael Hendrix

public String ejbFindByPrimaryKey(String primaryKey) throws FinderException
    {
    boolean result;

    try
        {
        result = selectByPrimaryKey(primaryKey);
        }
    catch (Exception ex)
        {
        throw new EJBException("ejbFindByPrimaryKey: " + ex.getMessage());
        }

    if (result)
          return(primaryKey);
    else
          throw new ObjectNotFoundException("Zeile der ID " + primaryKey " not found.");
    }
                                                                        Java
                                                                        Prof. Dr. Michael Hendrix

public String ejbFindByLastName(String lastName) throws FinderException
    {
    Collection result;

    try
        {
        result = selectByLastName(lastName);
        }
    catch (Exception ex)
        {
        throw new EJBException("ejbFindByLastName: " + ex.getMessage());
        }

    if (result.isEmpty())
          throw new ObjectNotFoundException("Keine Zeile gefunden.");
    else
          return(primaryKey);
    }
                                                                     Java
                                                                     Prof. Dr. Michael Hendrix

                                    Business-Methoden

beschreiben die Geschäftsprozesse

greifen normalerweise nicht direkt auf die Datenbank zu


public void debit(double betrag) throws UngenügenderKontostandException
    {
    if (kontostand - betrag < 0)
          throw new UngenügenderKontostandException();

    kontostand -= betrag;
    }


public void kredit(double betrag)
    {
    kontostand += betrag;
    }


u.s.w.
                                                               Java
                                                               Prof. Dr. Michael Hendrix

Aufruf der Business-Methoden durch einen Client

    Konto otto = home.create("123", "Mess", "Otto", 456.20);
    otto.kredit(88.50);
    otto.debit(20.25);
                                                        Java
                                                        Prof. Dr. Michael Hendrix

       Datenbank Zugriff (für das Konto-Beispiel)


        Methode          Resultierendes SQL Statement
ejbCreate             insert
ejbFindByPrimaryKey   select
ejbFindByLastName     select
ejbLoad               select
ejbRemove             delete
ejbStore              update
                                                                          Java
                                                                          Prof. Dr. Michael Hendrix

                                      Home Interface

definiert die Methoden, über die ein Client eine Entity Bean erzeugen oder finden kann


import java.util.Collection;
import java.rmi.RemoteException;
import javax.ejb.*;

public interface KontoHome extends EJBHome
    {
    public Konto create(String id, String vorname, String nachname, double kontostand)
          throws RemoteException, CreateException;

    public Konto findByPrimaryKey(String id)
        throws FinderException, CreateException;

    public Collection findByLastName(String lastName)
        throws FinderException, CreateException;
    }
                                                                       Java
                                                                       Prof. Dr. Michael Hendrix

Eigenschaften der create-Methode:

    Anzahl und Typ der Argumente müssen denen der ejbCreate-Methode in der Enterprise
    Bean Klasse entsprechen

    Rückgabewert: Remote Interface Typ der Enterprise Bean

    die throws-Klausel muss die Exceptions der throws-Klausel der entsprechenden
    Methoden ejbCreate und ejbPostCreate beinhalten


Eigenschaften der finder-Methoden:

    Anzahl und Typ der Argumente müssen denen der entsprechenden Methode in der Entity
    Bean Klasse entsprechen

    Rückgabewert: Remote Interface Typ der Entity Bean oder eine Collection dieser
                  Typen

    die Exceptions in der throws-Klausel beinhalten jene der entsprechenden Methode in der
    Entity Bean Klasse

    die Throws-Klausel muss die javax.ejb.FinderException und die
    javax.ejb.RemoteException beinhalten
                                                                     Java
                                                                     Prof. Dr. Michael Hendrix

                                     Remote Interface

definiert die Business-Methoden, die ein Client aufrufen kann


import javax.ejb.EJBObject;
import java.rmi.RemoteException;

public interface Konto extends EJBObject
    {
    public void debit(double betrag)
          throws UngenügenderKontostandException, RemoteException;

    public void kredit(double betrag) throws RemoteException;
    }
                                           Java
                                           Prof. Dr. Michael Hendrix

                                 Clients


Stand-Alone Java Applikationen

J2EE Application Clients

Servlets

Java Server Pages Komponenten

Andere Enterprise Beans
                                                                  Java
                                                                  Prof. Dr. Michael Hendrix

                                J2EE Application Clients


mit dem "Application Deployment Tool" erzeugte Java Applikation


Unterschied zur Stand-Alone Applikation

    J2EE Komponente


Vorteile gegenüber Stand-Alone Applikation

    Zugriff auf die J2EE-Services   Security Authentication
                                    JNDI Lookups
                                                                           Java
                                                                           Prof. Dr. Michael Hendrix

                                      Servlets


                                                           J2EE Server

             Web
             Browser                             Servlet                 Enterprise
                                                                         Bean




Methoden des Servlets:

    public void init() throws ServletException
         wird vom Webserver direkt nach der Erzeugung des Servlets aufgerufen
         Code: lookup und create der Enterprise Bean

    public void doGet( . . .)
         Business-Methoden der Enterprise Bean
                                                                            Java
                                                                            Prof. Dr. Michael Hendrix

                                           JSP



                                                              J2EE Server

               Web
               Browser                            JSP                       Java
                                                                            Bean




                                                                        Enterprise
                                                                        Bean




Alternative:

    JSP-Zugriff auf Enterprise Beans über JSP Tag Libraries

								
To top