Realisierung verteilter Anwendungen: Teil 6

Beim vorigen Mal: Einführung in Multitier-Architekturen Dynamische Seitengenerierung (JSP und Servlets)

Inhalt heute Komponentenarchitekturen (am Beispiel von

Enterprise Java Beans)Lernziel:

Grundverständnis des Designs der EJB-Architektur zur weiteren Vertiefung im Beruf

Ralf Möller, FH-Wedel

Enterprise Java Beans (EJB)

Teile von einigen der nachfolgenden Folien wurden übernommen aus:

VL Anwendungssysteme Gerald Weber

Ziele der EJB-Architektur

Standard-Applikationsserver-Architektur für JavaAbstraktion von Low-Level Aufgaben bei

Transaktionen, Multithreading, Connection PoolingKomponenten-Orientierung: Applikationen können

aus Teilen verschiedener Hersteller aufgebaut werden

Definierte Rollenverteilung für die Systemerstellung

Definition der Aufgaben der Rollen durch Contracts

EJB-Architektur

RMI

EJB-Server

Clients

RDBMS

CORBA

JDBC

Container

Legacy-Application

B

B

Beispiel: E-Commerce-System

Bean-Provider Cat.com bietet Produktkatalog MyCat an

App. Assembler WebVend erstellt Applikation BuyMe

Marktplatz GoodStuff ist Deployer, EJBServer und Container kommen von MegaBeans

MyCat.jar

MyCat.jar Order

CartJSP

M.O.C.

EJBServ.+Cont.

HTTPClientClient

Client

DD

DD = Deployment Descriptor

JMS (Java Message Service)JNDI (Java Naming and Directory Interface)

EJB Rollen

Bean Provider (Experte im Anwendungsbereich)Application Assembler: (Experte im

Anwendungsbereich)Deployer (Experte für spezielle

Systemumgebung)EJB Server Experte (TP-Experte, z.B. DB-Anbieter)EJB Container Provider (Experte für System-

programmierung, Load Balancing)System-Administrator

Welche Analyse-Klassen stellen EJBs dar?

EJBs repräsentieren grobkörnige Objekte: Sitzungsobjekte: Session Beans

Stateless: single-use service, haben keinen Zustand Stateful: speichern Zustand, aber nur transient

Persistente Objekte: Entity BeansBeispiel: Eirichtung einer Bean für eine

Rechnung, aber nicht für einen Rechnungsposten

Komponentenbegriff

Beans implementieren Business-Logik.Beans sind verteilte Objekte.Bean ist über eine Anzahl von Parametern

anpaßbar.Beans enthalten deklarative Informationen

über den Einsatzkontext (Deployment-Descriptor).

Client-Zugriff erfolgt durch festgelegte Interfaces

Java-Sprachebene: Elemente einer EJBean

Home Interface: Feste Arten von Klassen-Methoden. U.a. Life-cycle-Management Methoden (Erzeugung...)

Remote Interface: Instanzmethoden, Business-Methoden

Beanklasse: Implementiert beide Interfaces

Deployment Descriptor Verwendete andere Klassen

(Helper Classes)

Home Remote

Bean

HelperHelper

Beispiel: Die EntityBean MyCat

Home-Interface MyCatHome: create(String Name) findByPrimaryKey(String) findLike(String keyword)

Remote-Interface MyCat: getPrice() etc. setPrice() etc. buy(int pieces)

Bean-Klasse MyCatBean: Implementiert Methoden aus MyCatHome und MyCat.

Deployment Descriptor: type: entity role admin: Alle Methoden role customer: nicht

setPrice().

Locating a (session) Bean’s home interface

JNDI (Java Naming and Directory Interface)

Context initialContext = new InitialContext();

BankBeanHome myBeanHome = (BankBeanHome) initialContext.lookup("Systems/gsj21/Repository/Applications/BankExample1/Homes/BankSessionBean");

EJB Contracts: Client-View-Contract

Client kann durch RMI auf Bean zugreifen. Pro Deployment einer Bean ist ein Home-

Interface-Objekt in JNDI eingetragen und für den Client nutzbar.

Bean Instanzen implementieren das Remote-Interface Der Client erhält sie durch das Home-Interface.

Component Contract Beans werden in Container eingebettet Bean implementiert Business-M., Life-cycle-M. u.a.

Callbacks. Container ruft diese sinngemäß auf Container behandelt z.B. Transaktionen,

Security und Exceptions Container bietet JNDI-Environment, EJBContext Bean Provider vermeidet Programmierung, die das

Container Runtime Management stört Optional: Container behandelt Persistenz Deployment-Descriptor enthält entsp. Daten

Motivation der J2EE-Umgebungseinbettung

Beispiel: Verbindungen (connections)Verbindungsobjekte repräsentieren eine

Zugriffsmöglichkeit auf eine Ressource (z.B. JDBC)

Nachteile des häufigen Verbindungsaufbaus

Auf- und Abbau einer Verbindung ist aufwendig

Bei häufigem Zugriff entsteht großer Overhead

Häufig gilt: mehrere Komponenten greifen auf die gleiche Ressource zu

Wünschenswert: Pool von Verbindungen für mehrere Komponenten jeweils für eine Ressource

Beispiel: JDBC-Verbindungen

Connection con; ResultSet results; try {

con = DriverManager.getConnection( "jdbc:odbc://vodka.fh-wedel.de/Db", username, password); results = con.createStatement().executeQuery("...")

} catch (Exception e) { System.out.println(e); }

con.close();

Kontextabhängigkeit des DB-Treibers

try { Class.forName("org.gjt.mm.mysql.Driver")} catch (ClassNotFoundException cnfe) { System.out.println("Cannot load driver");}

Aber: der Treiber hängt von der Umgebung ab!Bei Einhaltung des Komponentengedankens muß

der Treibername zur Laufzeit erfragt werden!Hierzu dient ein Kontextobjekt (sog. EJB-Kontext)

Verbindungen im EJB-Kontext (ohne Pool)

import java.sql.*; import javax.sql.*;public class AccountBean implements EntityBean { public Collection ejbFindByLastName(String lName) { try { String dbdriver = new InitialContext().lookup("java:comp/env/DBDRIVER").toString(); Class.forName(dbdriver).newInstance(); Connection conn =

DriverManager.getConnection("java:comp/env/DBURL", "userID", "password");

<body> conn.close();}}

Reduzierung des Aufwandes

Im Applikationsserver laufen viele EJBsJede EJB führt kurze Interaktion mit DB durch ...... und meldet die Verbindung gleich wieder abIdee: Teilung von Verbindungen zwischen

mehreren EJBs und mehreren Aufrufen von EJB-Methoden

Notwendig: Verwaltung eines kritischen Abschnitt (bedingt durch Multithreading) und ggf. Transaktionsmanagement

Soll das jeder EJB-Programmierer selbst machen?

Connection Pooling durch Container

Idee: Connection Pooling wird durch Umgebung (container) für alls EJBs übernommen

Verbindungen im EJB-Context (mit Pool) (1)

import java.sql.*; import javax.sql.*; // import here vendor-specific JDBC drivers

public ProductPK ejbCreate() { try { // initialize JNDI lookup parameters Context ctx = new InitialContext(...); ...

// Following params could come from a JNDI look-up ConnectionPoolDataSource cpds =

(ConnectionPoolDataSource)ctx.lookup(cpsource);

Verbindungen im EJB-Context (mit Pool) (2)

... cpds.setDatabaseName("PTDB"); cpds.setUserIF("XYZ"); PooledConnection pc = cpds.getPooledConnection(); Connection conn = pc.getConnection(); // do business logic conn.close(); }...}

Zusammenfassung der Motivation für J2EE

Es gibt Aspekte der Anwendungsprogrammierung, die für alle Softwarekomponenten relevant sind

Es ist sinnvoll, sie nur einmal zu programmieren und von für verschiedene Komponenten zu nutzen

Es gibt bestimmte Abhängigkeiten der Komponenten vom konkreten Einsatzkontext

Eine Beispielanwendung Benutzer macht Eingaben in HTML-Formular Das ausgefüllte Formular wird durch ein Servlet

verarbeitet Das Servlet lokalisiert die Verarbeitungskomponente

(Session Bean) über JNDI (Java Naming and Directory Service)

Session Bean macht Berechnung Servlet kommuniziert Ergebnis zum Benutzer

J2EE Software und Setup

Java 2 SDK Enterprise Edition (J2EE), Version 1.2.1 (http://java.sun.com/j2ee/download.html)

Java 2 SDK, Standard Edition (J2SE)Version 1.2 oder neuer (http://java.sun.com/jdk/index.html).

Annahme: installiert in $HOME/J2EE/j2sdkee1.2.1 bzw. $HOME/J2EE/jdk1.2.2 PATH: $HOME/J2EE/jdk1.2.2/bin und $HOME/J2EE/j2sdkee1.2.1/bin

CLASSPATH: $HOME/J2EE/j2sdkee1.2.1/lib/j2ee.jar

J2EE Application Components

Application client componentsEnterprise JavaBeans componentsServlets and JavaServer Pages components

(auch Web components genannts)Applets

J2EE Application Components

Servlet mit HTML-Dateien werden zu einem Web Archive (WAR) zusammengefaßt

Session Bean und Klassen zu einem JAR Archiv zusammengefaßt

Enterprise Archive (EAR) Datei zur Verifikation, zum Testen und zum Deployment in die Produktionsumgebung enthält alle Teil-Archive

Erzeugen der HTML-Seite bonus.html

Der HTML-Code in .../J2EE/ClientCode

<HTML><BODY BGCOLOR = "WHITE"> <BLOCKQUOTE><H3>Bonus Calculation</H3><FORM METHOD="GET" ACTION="BonusServlet"><P> Enter social security Number:<P> <INPUT TYPE="TEXT" NAME="SOCSEC"></INPUT><P> Enter Multiplier:<P> <INPUT TYPE="TEXT" NAME="MULTIPLIER"></INPUT><P> <INPUT TYPE="SUBMIT" VALUE="Submit"> <INPUT TYPE="RESET"></FORM> </BLOCKQUOTE></BODY></HTML>

Das Servlet

Retrieves the user dataLooks up the session beanPasses the data to the session beanUpon receiving a value back from the session

bean, creates an HTML page to display the returned value to the user

Datei in .../J2EE/ClientCode/BonusServlet.java

Initialisierungsmethode für Servlet

public class BonusServlet extends HttpServlet { CalcHome homecalc; public void init(ServletConfig config) throws ServletException{ //Look up home interface try{ InitialContext ctx = new InitialContext(); Object objref = ctx.lookup("calcs"); homecalc = (CalcHome)PortableRemoteObject.narrow (objref, CalcHome.class);

... }}

doGet Methode

Eingabe: request und response ObjektRequests repräsentieren die Eingabe vom

BrowserResponses repräsentieren einen

Ausgabekanal zum BrowserAufgaben:

Finden des Home-Interfaces des Anwendungsobjekts

Aufruf der Methode calcBonus Generieren des Antwort-HTML-Seite

doGet Methode (Ausschnitt)

public void doGet (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String socsec = null; int multiplier = 0; double calc = 0.0; PrintWriter out; response.setContentType("text/html"); String title = "EJB Example"; out = response.getWriter(); out.println("<HTML><HEAD><TITLE>") out.println(title); out.println("</TITLE></HEAD><BODY>");

doGet Methode (Ausschnitt)

try{ Calc theCalculation;

//Retrieve Bonus and Social Security Information String strMult = request.getParameter("MULTIPLIER"); Integer integerMult = new Integer(strMult); multiplier = integerMult.intValue(); socsec = request.getParameter("SOCSEC"); //Calculate bonus double bonus = 100.00; theCalculation = homecalc.create(); calc = theCalculation.calcBonus(multiplier, bonus);} catch(Exception CreateException){ CreateException.printStackTrace();}

doGet Methode (Ausschnitt)

//Display Dataout.println("<H1>Bonus Calculation</H1>");out.println("<P>Soc Sec: " + socsec);out.println("<P>Multiplier: " + multiplier);

out.println("<P>Bonus Amount: " + calc);out.println("</BODY></HTML>");out.close();}

Erstellung der Session Bean

Zustandlose Bean reicht ausCalcBean.javaCalc.javaCalcHome.javain .../J2EE/Beans

CalcHome

package Beans;import java.rmi.RemoteException;import javax.ejb.CreateException;import javax.ejb.EJBHome;public interface CalcHome extends EJBHome {

Calc create() throws CreateException,

RemoteException;}

Calc Remote Interface

package Beans;import javax.ejb.EJBObject;import java.rmi.RemoteException;public interface Calc extends EJBObject { public double calcBonus(int multiplier, double bonus)

throws RemoteException;}

CalcBean (Ausschnitt)

public class CalcBean implements SessionBean { public double calcBonus(int multiplier, double bonus) { double calc = (multiplier*bonus); return calc; } public void ejbCreate() { } public void setSessionContext(SessionContext ctx) { } public void ejbRemove() { } public void ejbActivate() { } public void ejbPassivate() { } public void ejbLoad() { } public void ejbStore() { }}

Übersetzung von Session Bean und Servel

#!/bin/shcd .../J2EEJ2EE_HOME=.../J2EE/j2sdkee1.2.1CPATH=.:$J2EE_HOME/lib/j2ee.jarjavac -d . -classpath "$CPATH" Beans/CalcBean.java Beans/CalcHome.java Beans/Calc.java

cd .../J2EE/ClientCodeJ2EE_HOME=.../J2EE/j2sdkee1.2.1CPATH=.:$J2EE_HOME/lib/j2ee.jar:/home/monicap/J2EEjavac -d . -classpath "$CPATH" BonusServlet.java

Starten des Applikationsservers

j2sdkee1.2.1/bin/j2ee -verbose

deploytool Fenster für J2EE Applications und Komponenten Inspektorfenster für Information über ausgewählte

Applikation oder Komponenten Server-Informationsfenster für installierte

Applikationen

... und des Deploy-Tools

Deploy-Tool

Zusammenbau der Applikation

Erzeugen eines J2EE-Applikation (BonusApp.ear).

Erzeugen einer Enterprise Bean (CalcBean.jar).

Erzeugen einer Web Komponente (Bonus.war).

Angabe eines JNDI Names für die Enterprise bean (calcs).

Angabe eines sog. Root Context für die J2EE-Applikation (BonusRoot).

Enterprise Bean

Web Komponente

JNDI-Eintrag und Root Context

Verifikation und Deployment der Applikation

Start der ApplikationAnnahme : Web-Server verwendet Port 8000

(ggf. Konfigurierung in .../J2EE/j2sdkee1.2/config)Eingabe der URL

http://localhost:8000/BonusRoot/bonus.htmlin einem Brower

Ausgabe erfolgt in neuer HTML-Seite Bonus Calculation Soc Sec: 777777777 Multiplier: 25 Bonus Amount 2500.0

Diskussion Die EJB-Architektur befindet sich zur Zeit in der

Entwicklung Es wurde in dieser Vorlesung ein grober Eindruck der

Ziele und wesentlichen Ideen vermittelt, und ... es wurden die grundlegenden Entwicklungsschritte

für einer N-Tier-Anwendung erläutert

Und beim nächsten Mal:

TransaktionsmanagementSecurityPersistenzund eventuell etwas über Lastverteilung

(load balancing)