Java-Komponenten

1. Java-Komponenten Inhalt des Tutorials: • Übersicht zur JavaBean-Technologie • Entwicklung von JavaBeans • Beans als Grundbausteine bei der visuellen Programmierung • Komponenten am Beispiel von Enterprise Java Beans (EJB‘s) • Schritte zur Implementierung und Anwendung von EJB‘s

2. JavaBean - Java‘s Komponententechnologie Zielstellung der Anwendung von Java Beans: • Unterstützung der Idee einer arbeitsteiligen Softwareentwicklung • Spezialisierte Zulieferunternehmen • IV-technische Komponenten • Domain- bzw. fachspezifische Komponenten • Reduktion der Erstellungszeiten von Informationssystemen • Verwendung der Sprache Java für die Implementierung, .d.h. der Sprachumfang von Java wurde nicht erweitert. • Visuelle Programmierung mittels Bean-Builder Tools • BDK Bean Development Kit (Referenzimplementierung) • Java-Studio (Entwicklung bei SUN aber eingestellt) • VisualAge for Java (Umfangreiche Anwendung von Beans)

3. JavaBean - Java‘s Komponententechnologie Definition von Java Beans entsprechend SUN: „JavaBeans components, or Beans, are reusable software components that can be manipulated visually in a builder tool. Beans can be combined to create traditional applications, or their smaller web-oriented brethren, applets. In additional, applets can be designed to work as reusable Beans.“ Quelle: Javasoft API sprecifications

4. JavaBean - Java‘s Komponententechnologie Java Beans Komponenten Modell: • Eine Komponente ist ein identifizierbares Stück Software mit eindeutig und vor allem gut definierten Grenzen • Die Spezifikation der JavaBeans beschreiben eine Komponenten-Architektur für Java • Modell beschreibt auch wie die Komponenten mit ihrem Container interagieren • Container bieten Komponenten eine Umgebung zur Ausführung • Bedarf an zwei Typen von Programmierern • Komponenten-Entwickler (developers) • Komponenten-Monteure (assembler) • JavaBeans als Black Box Komponente (Prinzip der Kapselung)

5. JavaBean - Java‘s Komponententechnologie

6. JavaBean - Java‘s Komponententechnologie Überblick zu den Eigenschaften von Java Beans I: • Introspection (Selbstbeobachtung) - Java Beans können zur Laufzeit Auskunft hinsichtlich gebotener Funktionen und Eigenschaften geben • Auf den direkten Quellcode-Zugriff kann so verzichtet werden • Implizite Introspection-Funktion bietet alle Methoden des Bean • Explizite Introspection-Funktion über das BeanInfo Interface • Customisation (Anpassung) - Beans können entsprechend den aktuellen Erfordernissen über die Nutzung von Dialogen angepaßt werden. • Angebot an Standard-Dialogen • Angebot an angepaßten Dialogen • Event-Handling (Ereignisverarbeitung) - Verwendung des Delegation-Event-Handling-Model (Event-Sources und Event-Listener) • Persistenz - Möglichkeit der dauerhaften Abspeicherung alter und neuer Werte von Properties

7. JavaBean - Java‘s Komponententechnologie Überblick zu den Eigenschaften von Java Beans II: • Methoden - werden genutzt um entsprechende Properties des Beans zu ändern. Alle als „public“ definierte Methoden werden in einem Bean-Builder-Tool angeboten. • Einschränkung der angebotenen Methoden über BeanInfo-Klasse • Einschränkung auch beim Import des Bean in ein Builder-Tool möglich • Properties - (Eigenschaften) - Kapseln Daten einer Instanz eines Bean und können von außen abgefragt und geändert werden Signature pattern für Properties: getProperty() / setProperty() • Simple Properties - repräsentieren einen einzelnen Wert • Indexed Properties - Array gleichen Datentyps • Bound Properties - Kombination eines Properties mit einem Event (z.B. ausgelöst nach der Änderung eines Properties) • Constrained Properties - Zustimmung zur Änderung einer Propertie von z.B. einem anderen Bean holen

8. JavaBean - Java‘s Komponententechnologie Package für Java Beans: Erweiterung des JDK um das Package „java.beans.*“ • Bean spezifische Interfaces • BeanInfo - allg. Schnittstelle zur Beschreibung des Beans • Customizer - graph. Assistenten zur Einstellung der Eigenschaften von Beans • PropertyChangeListener - Interface für Events, die Änderungen Properties mitteilen • Visibility - Interface für Beans ohne GUI • ... • Bean spezifische Klassen • Beans - Methoden für Instanzen zur Behandlung im Design Modus von Builder Tools • BeanDescriptor - allg. Informationen über ein Bean öffentlich bereitstellen • Introspection - Methoden für die gleichnamige Eigenschaft • SimpleBeanInfo - einfache Implementierung des Interfaces BeanInfo • ... • Bean spezifische Exceptions • IntrospectionException - geworfen bei Fehlern während des Introspection Vorgangs • ...

9. JavaBean - Java‘s Komponententechnologie Implementierung von Java-Beans: • notwendige Klasse/Packages importieren • Klasse definierten, Objekt initialisieren über Konstruktor • Anwendungslogik implementieren • Event-Handling - Methoden zum registrieren bzw. entfernen interessierter Listener • Beispiel einer Bound-Methoden-Sigatur (getProperty()/setProperty()) //Propertie für Text setzen und lesen public void setText(String newText) { String oldText = text; text = newText; //Auslösung eines entsprechenden Event propertyChangeListeners.firePropertyChange("text", oldText, newText); } public String getText() { return text; }

10. JavaBean - Java‘s Komponententechnologie Beispiel eines Java-Beans 1: package Beans; import java.awt.*; import java.awt.event.*; import java.beans.*; import java.io.Serializable; Das folgende Bean3 wird von Panel abgeleitet und implementiert die Interfaces Serializable für die Realisierung der Persistenzeigenschaften eines Beans und Runnable um innerhalb des Beans Threads verwenden zu können. public class Bean3 extends Panel implements Serializable, Runnable{ BorderLayout borderLayout1 = new BorderLayout(); TextField textField1 = new TextField(); Thread t = new Thread(this); private String text = "leer"; public String i ; public int a =0; private boolean ind=false; private transient PropertyChangeSupport propertyChangeListeners = new PropertyChangeSupport(this);

11. JavaBean - Java‘s Komponententechnologie Beispiel eines Java-Beans 2: Über den parameterlosen Konstruktor wird das Bean bzw. die Objektinstanz initialisiert, die eigentlichen Eigenschaften werden in der Methode jbInit(), welche innerhalb des Konstruktur aufgerufen wird festgelegt. //parameterloser Konstruktor public Bean3() { try { jbInit(); } catch (Exception ex) { ex.printStackTrace(); } } //Initialisierung der Bean-Komponente private void jbInit() throws Exception { this.setSize(new Dimension(186, 24)); textField1.setText("Bean3"); this.setLayout(borderLayout1); this.add(textField1, BorderLayout.NORTH); }

12. JavaBean - Java‘s Komponententechnologie Beispiel eines Java-Beans 3: Der folgende Thread realisiert die eigentliche Zeitzählung, wobei das Propertie “Text” durch die Methode “setText” entsprechend dem Ergebnis der Hochzählung gesetzt wird. //Thread für die Ausführung starten public void run(){ //Endlosschleife for (;;){ ind=true; a=a + 1; i=""+ a; setText(i); textField1.setText(text); try{ Thread.sleep(1000); }catch (InterruptedException ex){} } } Diese Methode realisiert den eigentlichen Start der Stopuhr und soll in einem Bean-Builder-Tool zur Verfügung stehen. // Start der Uhr public void start(){ if (ind) { t.resume(); } else{ t.start(); setText(i); } }

13. JavaBean - Java‘s Komponententechnologie Beispiel eines Java-Beans 4: Diese Methode realisiert den eigentlichen Stop der Stopuhr soll ebenfalls im Bean-Builder-Tool zur Verfügung stehen. // Stop der Uhr public void stop(){ t.suspend(); // Thread beenden } Diese Methode realisiert das Rücksetzen der Stopuhr auf 0 soll ebenfalls im Bean-Builder-Tool verwendet werden können. // Rücksetzen auf 0 public void reset(){ a= 0; i="0"; setText(i); textField1.setText(text); }

14. JavaBean - Java‘s Komponententechnologie Beispiel eines Java-Beans 5: Die folgenden beiden Methoden entsprechenden dem Entwurfsmuster (Methoden-Signatur) für Java-Beans und realisieren so das Property dieses Beans. Ebenso werden entsprechende Listener (z.B. ein anderes Bean) über Änderungen des Property durch ein entsprechedes Event “propertyChangeListener” informiert. //Propertie für Text setzen und lesen public void setText(String newText) { String oldText = text; text = newText; //Auslösung eines entsprechenden Event propertyChangeListeners.firePropertyChange("text", oldText, newText); } public String getText() { return text; }

15. JavaBean - Java‘s Komponententechnologie Beispiel eines Java-Beans 6: Die folgenden beiden Methoden realisieren in der späteren Bean-Applikation die Registrierung von auf Events wartenden Listenern. //entfernen eines registrierten Listener public synchronized void removePropertyChangeListener(PropertyChangeListener l) { propertyChangeListeners.removePropertyChangeListener(l); } //registrieren eines registrierten Listener public synchronized void addPropertyChangeListener(PropertyChangeListener l) { propertyChangeListeners.addPropertyChangeListener(l); } }

16. JavaBean - Java‘s Komponententechnologie Funktion der Bean-Info-Klasse: Problem: alle public definierten Methoden werden in einem Bean-Builder angezeigt, auch die ererbten. Wird keine eigene Bean-Info-Klasse definiert, erfolgt die Verwendung von „SimpleBeanInfo“ • Filterfunktionen (verbergen von Komplexität) • Bean Descriptor - Zuordnung komplexere Customizer-Dialoge • Property Descriptor - Auswahl definierter Properties • Method Descriptor - Auswahl konkreter Methoden • Event Set Descriptor - Auswahl der angebotener Events • Zuordnung eines korrespondierenden Icon • Dateinamen von BeanInfo-Klassen setzen sich immer aus der Orginal-komponente + BeanInfo zusammen.

17. JavaBean - Java‘s Komponententechnologie Beispiel eines Method-Desciptors (in BeanInfo): public MethodDescriptor[] getMethodDescriptors() { // First find the "method" object. Class args[] = {}; Method m, m1, m2; try { m = Bean3.class.getMethod("start", args); m1 = Bean3.class.getMethod("stop", args); m2 = Bean3.class.getMethod("reset", args); } catch (Exception ex) { // "should never happen" throw new Error("Missing method: " + ex); } // Now create the MethodDescriptor array: MethodDescriptor result[] = new MethodDescriptor[3]; result[0] = new MethodDescriptor(m); result[1] = new MethodDescriptor(m1); result[2] = new MethodDescriptor(m2); return result; }

18. JavaBean - Java‘s Komponententechnologie JAR-Files Packetierung von Java Beans: • Ein zu verteilendes Beans enthält typischerweise mehrere Files • JAR Java Archive Files für die Packetierung von Beans, dabei handelt es sich um ein ZIP-File, welches zusätzlich eine Manifest-Datei enthält. • Inhalte eines JAR-Files: • ein Satz von Java-Class Files • einen Satz serialisierter Objekte • optionales Help-File in HTML-Format • optionale Lokalisierungs-Informationen • optionales Icon im GIF Format • weitere Ressource-Files die vom Bean benötigt werden • Beispiel einer Manifest-Datei: // Example.lst Manifest-Version: 1.0 Name: Example.class Java-Bean: True

19. JavaBean - Java‘s Komponententechnologie Visuelle Entwicklung unter dem BDK: Bean-Box, Container-Panel entspricht der späteren Java-Anwendung ToolBox, enthält eigene und Beispiel-Komponenten Property-Sheet, Anzeige der Eigenschaften ausgewählter Komponenten Funktionen des BDK: • benötigte Beans per “Drag & Drop” plaziert. • Ausgewählt werden die Beans über eine Toolbox • vom Bean exportierte Properties bearbeiten • Anzeige der Properties je Bean über entsprechenden Dialog • Event-Source mit Event-Handler kombinieren (Drag & Drop) • Fertige Anwendungen z.B. Applets werden herausgeneriert • Anwendung (Beans und Compositions-Fenster) speichern • neue Beans aus JAR-Files einlesen • lauffähiges Applet erzeugen

20. JavaBean - Java‘s Komponententechnologie

21. JavaBean - Java‘s Komponententechnologie Design einer Entwicklung unter dem Visual Studio: GUI der Applikation: • Black Box Sicht auf die Komponenten • alle Beans haben hier eine grafische Präsentation (nicht immer!!) • Applikation (z.B. Applet) muß aus dem Builder-Tool generiert werden

22. JavaBean - Java‘s Komponententechnologie Entwicklung unter dem JavaStudio: Verwendete Beans: (visuelles Plazieren, angebotene Connectoren) • Button-Beans (Start, Stop, Reset) • Zähler (Impulsgeber alle 1 sek.) • Ausgabe-Bean (Stopuhr) • Label zur Beschriftung • Laufschrift-Bean Customize-Dialog:

23. EJB Enterprise Java Beans Enterprise-JavaBeans(EJB)-Architektur: • Server-seitige Java-Komponenten (Focus: Anwendungsdomaine) • SUN bietet Spezifikation für Beans, Server und Container • Referenzimplementierung J2EE • Vielzahl angebotener Applikation-Server • Portable Anwendungen auf der Basis von EJB‘s • Hardwareunabhängig • Betriebssystemunabhängig • Unterstützung verschiedener Sprachen und CORBA • Abstraktes Programmierinterface • Entlastung von “low-level“ Aufgaben • Transaktionsverwaltung • Multithreading • Ressourcenverwaltung • Unterstützung der Wiederverwendbarkeit • Entwicklung ist völlig unabhängig von der Installation, Konfiguration, Auslieferung und Betrieb

24. EJB Enterprise Java Beans Container-Konzept: • Behälter bzw. Umgebung für Softwarekomponenten • Container definiert nach außen einen abgeschlossenen Bereich • Angebot an Funktionen für enthaltene Komponente • Überwachung des Lebenszyklus und Synchronisation • Dienste: • Persistenzmechanismen via z.B. JDBC • Komponentenfabriken, • TA-Services, • Security, • Kommunikation RMI over IIOP • Schnittstelle enthaltener EJB‘s zur Außenwelt

25. EJB Enterprise Java Beans EJB - Eigenschaften: • Component Model (Session und Entity Beans) • Component Persistence • BMP - bean managed Persistence • CMP - container managed Persistence • Transaction-Management (Java-Transaction-API) • Exceptions (Client und Server) • Security • Naming und Directory Service (JNDI) • Protocoll-Support (RMI, IIOP,...) • CORBA-Support (Mapping and Services) • Attribute-based Programming (Deployment Descriptor File) • Deployment (EJB JAR-Files)

26. EJB Enterprise Java BeansMöglichkeiten EJB-basierter Architekturen

27. EJB Enterprise Java Beans Session- und Entity-Beans: • Stateless Session-Beans (javax.ejb.SessionBean) • genau dem Client zugeordnet von dem dieses instanziert wurde • nach „Herunterfahren“ des Server nicht mehr vorhanden • ist keine Referenz mehr vorhanden erfolgt eine Löschen • Stateful Session-Beans • Verwaltung von Zuständen durch Handle-Mechanismus • Speicherung der Zustände möglich, z.B. bei TA-Sicherung notwendig • Entity-Beans (javax.ejb.EntityBean) • Persistenzeigenschaften (zumeist Abbildung auf RDBMS) • Eindeutige Identifizierung über Primärschlüssel ist zwingend • Persistenzmechanismen des Containers - CMP • Persistenzmechanismen vom Bean verwaltet - BMP

28. EJB Enterprise Java Beans Aufbau einer EJB-Komponente: Besteht aus mindestens 3 Java-Klassen und dem Deployment-Deskriptor • Remote-Interface • Nutzung der EJB-Funktionalität über dieses Interface • Home-Interface • Realisierung das Erzeugen, Auffinden und Löschen des Beans • Bean-Implementierung • Implementiert die im Remote-Interface spezifizierten Methoden • XML - Deployment-Deskriptor (kurz DD) • Informationen und Anpassungen zum betrachteten Bean Die Verteilung (Deployment) der EJB‘s erfolgt zusammengefaßt innerhalb einer JAR-Datei.

29. EJB Enterprise Java Beans

30. EJB Enterprise Java Beans Beispiel eines Remote-Interfaces (Quelle: Merkle 2000) import java.util.*; import javax.ejb.EJBObject; import java.rmi.RemoteException; public interface Cart extends EJBObject { public void addBook(Book ref) throws RemoteException; public void removeBook(Book ref) throws BookException, RemoteException; public Collection getContents() throws RemoteException; public double getSummary() throws RemoteException; }

31. EJB Enterprise Java Beans Beispiel eines Home-Interfaces (Quelle: Merkle 2000) import java.io.Serializable; import java.rmi.RemoteException; import javax.ejb.CreateException; import javax.ejb.EJBHome; public interface CartHome extends EJBHome { Cart create(String person) throws RemoteException, CreateException; Cart create(String person, String creditcard) throws RemoteException, CreateException; }

32. EJB Enterprise Java Beans Beispiel einer EJB-Implementierung I (Quelle: Merkle 2000): import java.util.*; import java.rmi.*; import javax.ejb.*; public class CartEJB implements SessionBean { String customerName;customerId; Vector contents; public void ejbCreate(String person) throws CreateException { if (person == null) { throw new CreateException(“null not allowed.");} else {customerName = person;} customerId = "0";contents = new Vector(); }

33. EJB Enterprise Java Beans Beispiel einer EJB-Implementierung II (Quelle: Merkle 2000): public void ejbCreate(String person, String id) throws CreateException { // } public void addBook(Book ref) { //Buch zum Korb hinzufügen contents.addElement(ref); } public void removeBook(Book ref) throws BookException { //Buch aus dem Korb entfernen System.out.println(re); } } } public Collection getContents() { //welche Bücher befinden sich schon im Korb return contents; } public double getSummary() { //Preis der enthaltenen Bücher insgesamt return summary; }

34. EJB Enterprise Java Beans Aufgaben des Deployment-Deskriptor kurz DD: Auf der Basis des DD soll eine Anpassung entsprechender Attribute der EJB‘s ermöglicht und ein „Blackbox-Reuse unterstützt werden. Der DD kann als Beipackzettel für ein EJB, oder einer aus mehreren EJB‘s zusammengesetzten Applikation betrachtet werden. Im DD konfigurierbare Eigenschaften (Attribute): • Sicherheitsattribute • Transaktionsattribute • Umgebungsvariablen • Verknüpfungen mit anderen Komponenten • Verknüpfungen zu Datenquellen Struktur eines EJB-DD • Struktur-Sektion (Basis- und Umgebungsinformationen) • Assemblierungs-Sektion (Zugriffsrechte, Transaktionsattribute,...)

35. EJB Enterprise Java Beans Beispiel eines XML-Deploymentdescriptor: <?xml version="1.0" encoding="Cp1252"?> <!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 1.1//EN' 'http://java.sun.com/j2ee/dtds/ejb-jar_1_1.dtd'> <ejb-jar> <description>no description</description> <display-name>Ejb1</display-name> <enterprise-beans> <session> <display-name>CartEJB</display-name> <ejb-name>CartEJB</ejb-name> <home>CartHome</home> <remote>CartClient</remote> <ejb-class>CartEJB</ejb-class> <session-type>Stateful</session-type> <transaction-type>Container</transaction-type> </session> </enterprise-beans> </ejb-jar>

36. EJB Enterprise Java BeansDialog des J2EE-Wizard: (Erstellung der EJB-JAR)

37. EJB Enterprise Java BeansKonfigurationsdialog

38. EJB Enterprise Java Beans Dialog beim Deployment: (Applikation und EJB‘s)

39. EJB Enterprise Java Beans Unterstützung der EJB: • SilverStream SilverStream Application Server 3.0 • Netscape Netscape Application Server • Gemstone Gemstone/J 3.0 • BEA Weblogic 4.5 bzw. 5.0 • Inprise Inprise Application Server 4.0 • ProSyst EnterpriseBeans Server 3.0 • SUN J2EE-Referenz-Implementierung • Application Deployment Tool, • Verifier • Packager • Tools für Verwaltungsaufgaben (Benutzer, Gruppen,...)

40. EJB Enterprise Java Beans Rollenverteilung mit EJB‘s: Das EJB-Modell unterstützt eine arbeitsteilige Fertigung, Verarbei-tung, Auslieferung und Administration beanbasierter Applikationen: • EJB-Provider - Lieferant der Java-Kompoenten • Application Assembler - Anwendungsentwickler (komplexere EJB‘s) • EJB-Deployer - Installation und Konfiguration der Umgebung • System-Administrator - Administration Server- und Netzinfrastruktur • EJB-Server-Provider - Anbieter von Applikation-Server • EJB-Container-Provider - Laufzeitumgebung für EJB‘s (derzeit fast immer im Zusammenhang mit dem Applikation-Server)

41. Literaturhinweise für Java Griffel F. : Componentware, Konzepte und Techniken eines Softwareparadigmas, dpunkt.verlag 1998 Nogli A. : Auswahl eines Applikations-Servers, in Java SPEKTRUM 2/2000, SIGS-Verlag Merkle B., M. Johann: Produktüberblick von EJB-basierten Applikations-Servern, in Java SPEKTRUM 2/2000, SIGS-Verlag Szypersiki C. : Component Software, Beyond Object-Oriented Programming, Addison-Wesley, 1998 Wiedeking M. : Die Entwicklung verteilter Anwendungen mit Enterprise-JavaBeans, in Java SPEKTRUM 6/1999, SIGS-Verlag Pouatcha F., Rottach T.: Konfigurationsbeschreibung für EJB-Komponenten, in Java SPEKTRUM 6/1999, SIGS-Verlag Hendrich N.; Java für Fortgeschrittene, Springer-Verlag Berlin Heidelberg, Berlin 1997 Merkle B. : Tutorium zur Programmierung von Enterprise-JavaBeans, in Java SPEKTRUM 3/2000, SIGS-Verlag http://www.sigs.de/html/inhalt_bisheriger_hefte1.html

42. Interessante Links im Internet CORBA-spezifische Informationen: http://www.omg.org Verfügbare Applikations-Server: http://divya.com/links.html Java-World: http://www.javaworld.com freier EJB-Guide: http://www.nova-labs.com/ div. Artikel unter: http://developer.java.sun.com/developer/technicalArticles/EBeans/ EJB-Spezifikation: http://www.javasoft.com/products/ejb/ Java SPEKTRUM, alle 2 Monate, http://www.sigs.de Java Magazin, alle 2 Monate, http://www.javamagazin.de