Zweck
Sie werden J2EE-Komponenten im J2EE-Framework modellieren und diese in Rose als Klassen und Kollaborationen von Klassen
darstellen.
Im allgemeinen verwendet eine J2EE-Anwendung die Dienste einer relationalen Datenbank. Sie modellieren ein Datenmodell
für die Datenbank, das in Rose mit Hilfe des Rose Data Modeler dargestellt wird.
Führen Sie die folgenden Schritte aus, um eine J2EE-Anwendung in Rose zu modellieren:
Nähere Informationen zu J2EE finden Sie unter Konzept: Überblick über Java 2 Platform Enterprise Edition (J2EE).
Einen Überblick über die komponentenbasierte Entwicklung mit Hilfe der J2EE-Plattform finden Sie unter Konzept: Komponentenlösungen entwickeln.
Siehe auch:
Konfigurieren Sie Rational Rose wie unter Toolmentor: Rational Rose für ein Projekt einrichten beschrieben.
Darüber hinaus müssen Sie das Rose Java Add-in aktivieren und projektspezifische Einstellungen konfigurieren.
Detaillierte Informationen zur Konfiguration von Rose Java finden Sie in der Onlinehilfe zu Rational Rose unter Rose Java > How to > Set Project Properties.
In Toolmentor: Designmodell mit Rational Rose verwalten wird das
Erstellen von Paketen und Schichten im Arbeitsergebnis: Designmodell beschrieben, beginnend mit der von Rose
bereitgestellten RUP-Modellschablone. Diese Schablone stellt ein Gerüst des Designmodells bereit, einschließlich
Platzhalter für die Arten von Paketen, Subsystemen und Diagrammen, die während des Designs erstellt werden sollten (Aufgabe: Anwendungsfalldesign, Aufgabe:
Klassendesign und Aufgabe: Subsystemdesign).
Siehe auch:
Beachten Sie, dass die Paketstruktur in Ihrem Designmodell nicht mit der Paketstruktur in Ihrem Implementierungsmodell übereinstimmen muss. Beim Forward Engineering
der Java-Klassen ist es die Paketstruktur im Implementierungsmodell, die die Paketstruktur der generierten Java-Klassen
festlegt.
Nähere Informationen zu Paketen finden Sie unter dem Stichwort Package in der Onlinehilfe von
Rational Rose.
Sie müssen die Java-Sprachenpakete für Java und J2EE hinzufügen, damit die Dienste der J2EE-Plattform, der sogenannten
Systemschicht (?system layer?), bereitgestellt werden. Diese Pakete werden verwendet, wenn Sie eigene Klassen im Modell
erstellen. Wenn Ihre Klasse beispielsweise eine Operation definiert, die den Java-Typ String zurückgibt, dann muss das
Java-Sprachenpaket java.lang, das die Klasse String enthält, in Ihrem Modell enthalten sein.
Nähere Einzelheiten finden Sie in der Onlinehilfe von Rational Rose zu folgenden Themen:
Das Schemapaket enthält das Design der Datenbanktabellen in der Anwendung. Nähere Informationen finden Sie unter Toolmentor: Datenbanken mit Rational Rose Data Modeler entwerfen und
modellieren.
Dieser Abschnitt beschreibt nicht die Modellierung von EJBs (siehe EJBs modellieren) oder
die Modellierung der Präsentationsklassen wie HTML und JSP-Seiten (siehe Präsentationsschicht
modellieren).
Er enthält statt dessen Informationen zur Modellierung der übrigen JavaBeans und Java-Klassen (z. B. der
Dienstprogrammklassen) für eine beliebige Java-Anwendung. Einzelheiten hierzu finden Sie in folgenden Abschnitten:
Nähere Informationen zu EJBs finden Sie unter Richtlinie: Enterprise JavaBean (EJB).
Nachfolgend ist eine Zusammenfassung der Schritte aufgeführt, die zur Modellierung einer EJB in Rose ausgeführt werden:
Im allgemeinen sind EJBs in Designsubsystemen gruppiert.
Designsubsysteme werden verwendet, um das Verhalten in ein "Paket" einzubinden, das explizite und formale
Schnittstellen bereitstellt und das (laut Konvention) keine internen Inhalte bereitstellt.
Detaillierte Informationen zum Erstellen von Designsubsystemen finden Sie unter Toolmentor: Subsysteme mit Rational Rose verwalten.
Bevor Sie die EJB in Rose erstellen, müssen Sie ihren Typ festlegen: Entity-Bean, Session-Bean oder
nachrichtengesteuerte Bean. Für eine Entity-Bean müssen Sie festlegen, ob eine über Container realisierte
Transaktionspersistenz oder eine über JavaBeans realisierte Transaktionspersistenz verwendet werden soll. Für eine
Session-Bean müssen Sie festlegen, ob die Bean statusabhängig (stateful) oder statusunabhängig (stateless) sein soll.
Siehe Richtlinie: Enterprise JavaBean (EJB).
Rose Java stellt eine Reihe von Dialogen zum Erstellen und Verwalten von EJB-Klassen in Rose bereit.
Nähere Informationen finden Sie in der Onlinehilfe zu Rational Rose unter Rose Java > How to
> Work with EJBs and servlets.
Rose Java wird für folgende Zwecke verwendet:
-
zum Erstellen einer neuen EJB von Anfang an
-
zum Umwandeln einer vorhandenen Klasse im Modell in eine EJB. Rose Java wandelt die vorhandene Klasse in die
ferne EJB-Schnittstelle um und erstellt neue Klassen für die Home-Schnittstelle und Bean-Klasse.
-
zum Hinzufügen von finder-Methoden zur EJB
-
zum Aktualisieren der Home-Schnittstelle mit einer in der Bean-Implementierungsklasse definierten lifecycle-
oder finder-Methode.
-
zum Aktualisieren der Klasseneigenschaften der EJB (z. B. des Namens der Home-Schnittstelle), der
Persistenzeigenschaften (z. B. Bean-gesteuert oder containergesteuert) und der Eigenschaften des
Implementierungsdeskriptors (z. B. containergesteuerte Felder oder Umgebungseinträge).
Eine Entity- oder Session-Bean, die mit Rose Java erstellt wurde, enthält Folgendes:
-
die Home-Schnittstellenklasse
-
die ferne Schnittstellenklasse
-
die Bean-Klasse
-
Eigenschaften, die den generischen EJB-Implementierungsdeskriptor ejb-jar.xml definieren und die als
Eigenschaften der EJB-Bean-Klasse gespeichert sind
-
Operationen und Attribute, die von der EJB-Spezifikation vorausgesetzt werden (z. B. Callback-Methoden), müssen
in der Home-Schnittstelle, der fernen Schnittstelle und der Bean-Klasse erstellt worden sein
Diese Klassen, die vom EJB-Dienstprogramm von Rose Java erstellt wurden, werden entsprechend der im Sun-Standard
JSR-000026 UML/EJB Mapping Specification definierten Zuordnung modelliert. Nähere
Informationen finden Sie in der Onlinehilfe zu Rational Rose unter Rose Java > Concepts > About Support for
the Java 2 Platform, Enterprise Edition (J2EE).
Nähere Information zu den Spezifikationen EJB 1.1 oder 2.0 finden Sie auf der Website http://java.sun.com/. Folgen Sie den Links zu Docs & Training > Java 2 Platform,
Enterprise Edition > Enterprise JavaBeans Specification.
Nachdem Sie die EJB-Klassen erstellt haben, können Sie die gewünschten Operationen (z. B. Geschäftsmethoden) und
Attribute hinzufügen.
Rose Java stellt eine Reihe von Dialogen zum Erstellen und Verwalten von EJB-Klassen in Rose bereit.
Nähere Informationen finden Sie in der Onlinehilfe zu Rational Rose unter Rose Java > How to
> Work with EJBs and servlets > Adding methods to a bean class.
Nähere Informationen zur Definition von Operationen und Attributen finden Sie in folgenden Abschnitten:
Sie erstellen Klassendiagramme als Teil der Aufgabe:
Klassendesign, indem Sie die Beziehungen zwischen den Klassen (z. B. Zuordnungen, Abhängigkeiten und
Vererbungsbeziehungen) modellieren.
Die mit Rose bereitgestellte Rational Unified Process Rose-Modellschablone enthält einen Entwurf, den Sie als
Ausgangspunkt für die Klassendiagramme verwenden können, die Sie erstellen werden.
Nähere Informationen zur Modellierung der Beziehungen zwischen Klassen finden Sie unter Aufgabe: Klassendesign.
Als Teil der Aufgabe: Anwendungsfalldesign erstellen Sie Nachrichten in
Ablaufdiagrammen, die Sie anschließend verwenden, um die Interaktionen zwischen Designobjekten zu beschreiben.
Erstellen Sie eine Gruppe von Ablaufdiagrammen, um den Hauptereignisfluss und die alternativen Ereignisflüsse für jede
Anwendungsfallrealisierung in Ihrem Designmodell zu beschreiben.
Als EJB-Designer verwenden Sie ein Ablaufdiagramm für folgende Zwecke:
-
zum Festlegen der Operationen und Operationsargumente der Klassen, die an der Interaktion teilnehmen
-
zum Dokumentieren der Operationen, die während einer Interaktion von einer Klasse aufgerufen werden.
-
zum Dokumentieren der Operationen, die ein Objekt beim Empfang einer Nachricht ausführt, z. B. indem ein Script
an die Nachricht angehängt wird. Nähere Informationen finden Sie in der
Onlinehilfe unter Rational Rose > How to > Create and work in a model > Using scripts on sequence
diagrams.
Siehe auch:
Eine Entity-EJB stellt eine objektorientierte Sicht der persistenten Daten der Anwendung dar. Das Modellieren einer
EJB-Klasse als Entität (Entity) und Markieren der Klasse als persistent weist darauf hin, dass der Datenbankdesigner das EJB-Objekt während des Datenbankdesigns dem Datenmodell zuordnen muss.
Der Datenbankdesigner erstellt das Datenmodell der Anwendung als Teil des
Datenbankdesigns.
Rose unterstützt das Datenbankdesign mit dem Tool Rational Rose Data Modeler. Mit diesem Tool können persistente
Klassen in Ihrem Objektmodell in ein Datenmodell umgewandelt werden und umgekehrt.
Die Zuordnung zwischen Klassen im Objektmodell und Tabellen im Datenmodell ist im Feld Mapped From in der
Rose-Spezifikation der Datenmodelltabelle angegeben.
Siehe auch Arbeitsergebnis: Datenmodell und Richtlinie:
Datenmodell.
Detaillierte Informationen zum Tool Rose Data Modeler finden Sie unter Toolmentor: Datenbanken mit Rational Rose Data Modeler entwerfen und
modellieren.
Aspekte von Session-EJBs modellieren
Session-Beans können persistente Daten lesen oder schreiben. Siehe dazu Richtlinie: Design von Enterprise JavaBeans (EJBs) - Direktzugriff vs.
Entity-EJBs.
In einer solchen Situation sollten Sie DAO-Klassen verwenden, um die Details bezüglich EJB-Datenbankverbindung und
-Zugriff mittels der Schnittstelle javax.sql zu isolieren.
Aspekte von Bean-gesteuerten Entity-EJBs modellieren
Bean-gesteuerte Entity-Beans lesen und schreiben Datenbanktabellen mit Hilfe der JDBC API. Verwenden Sie DAO-Klassen,
um die Details bezüglich EJB-Datenbankverbindung und -Zugriff mittels der Schnittstelle javax.sql zu isolieren.
Aspekte von containergesteuerten Entity-EJBs modellieren
Für eine containergesteuerte Entity-EJB müssen keine DAO-Klassen entworfen werden, weil ihre Persistenz vom
EJB-Container verwaltet wird.
Transaktionen definieren eine Gruppe von atomaren Operationsaufrufen: Entweder es werden alle Operationsaufrufe
ausgeführt oder keiner der Operationsaufrufe wird ausgeführt. Im Kontext der Persistenz definiert eine Transaktion eine
Menge an Änderungen für eine Gruppe von Objekten, die entweder alle ausgeführt werden oder gar nicht. Transaktionen
bieten Konsistenz, weil sie sicherstellen, dass Gruppen von Objekten von einem konsistenten Zustand in einen anderen
versetzt werden.
Einen Überblick über die Transaktionsverwaltung finden Sie unter Konzept: Überblick über Java 2 Platform Enterprise Edition (J2EE) -
Transaktionsverwaltung.
Eine Beschreibung von Modell-EJB-Transaktionen finden Sie unter Aufgabe:
Anwendungsfalldesign - Transaktionen modellieren. Zur Implementierungszeit legen Sie auf der Basis des
Designmodells fest, ob die Transaktionen deklarativ demarkiert werden sollen, indem Sie im Implementierungsdeskriptor
als Transaktionsattribut einer EJB-Methode Required, RequiresNew, NotSupported, Supports, Mandatory oder Never
definieren, oder ob die Transaktionen über das Programm, unter Verwendung der Java Transaction API, demarkiert werden
sollen.
Legen Sie im Rahmen des Designs fest, ob die Anwendungssicherheit deklarativ gesteuert werden soll, indem
Sicherheitsrollen und Methodenberechtigungen im EJB-Implementierungsdeskriptor verwendet werden, oder ob sie über das
Programm, unter Verwendung der J2EE-Sicherheits-APIs gesteuert werden soll.
Verwenden Sie Ablaufdiagramme, um Sicherheitsszenarios durchzuspielen. Falls erforderlich, verwenden Sie in den
Ablaufdiagrammen Anmerkungen, um die Sicherheitsanforderungen zu dokumentieren.
Einen Überblick über das Sicherheitsmanagement finden Sie unter Konzept: Überblick über Java 2 Platform Enterprise Edition (J2EE) -
Sicherheitsmanagement.
Sie generieren die Java-Klassen einer EJB mittels Forward Engineering unter Verwendung von Rose Java wie im Abschnitt
Toolmentor: Mit Rational Rose Elemente aus einem Modell generieren
beschrieben. Der EJB-Implementierungsdeskriptor ejb-jar.xml wird beim Forward Engineering der Bean-Klasse der EJB
automatisch generiert.
Sie können eine vorhandene EJB mit Hilfe von Rose Java wie im Abschnitt Toolmentor: Reverse Engineering von Code mit Rational Rose
beschrieben rückentwickeln (Reverse Engineer). Eine .jar-Datei, die die EJB-Klassen und den Implementierungsdeskriptor
enthält, muss rückentwickelt werden, damit Rose Java die Beziehungen zwischen den Klassen, die rückentwickelt werden,
ermitteln kann (z. B. welche Klasse die Home-Schnittstelle ist).
Modellieren Sie die Benutzerschnittstellenschicht einer J2EE-Anwendung in derselben Weise wie Sie dies für eine andere
Webanwendung tun würden. Im allgemeinen eignen sich Analyseklasse mit dem Stereotyp <<boundary>> für
Klassen und Kollaborationen von Klassen in der Benutzerschnittstellenschicht. Schnittstellenklassen können abhängig vom
Design beispielsweise als JSP-Seiten, Servlets, HTML-Seiten oder eigenständige Java-Clients implementiert werden.
Nähere Informationen hierzu finden Sie unter:
Zugehörige Aktivitäten:
Siehe auch:
Forward Engineering und Reverse Engineering für Präsentationsklassen
Für Präsentationsklassen kann Forward Engineering und Reverse Engineering verwendet werden. Rose Java unterstützt
Folgendes:
-
Reverse Engineering einer Webanwendung (.war). Nähere Informationen hierzu finden Sie
in der Onlinehilfe zu Rational Rose unter Rose Java > How to > Reverse Engineer from Java Source
to Rose .
-
Erstellen einer neuen Servlet-Klasse zusammen mit den passenden Methoden. Nähere Informationen hierzu finden Sie in der Onlinehilfe zu Rational Rose unter Rose
Java > How to > Work with EJBs and servlets.
|