Toolmentor: Das Design einer J2EE-Anwendung in Rational Rose modellieren
Dieser Toolmentor beschreibt, wie das Design einer J2EE-Anwendung mit Hilfe von Rational Rose modelliert wird.
Tool: Rational Rose
Beziehungen
Zugehörige Elemente
Hauptbeschreibung

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:

Rational Rose für das J2EE-Projekt konfigurieren

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 Symbol für Onlinehilfe Rose Java > How to > Set Project Properties.

Das Designmodell organisieren

Pakete und Schichten im Designmodell erstellen

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.

Symbol für Onlinehilfe Nähere Informationen zu Paketen finden Sie unter dem Stichwort Package in der Onlinehilfe von Rational Rose.

Die Java-Sprachenpakete hinzufügen

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:

  • Symbol für Onlinehilfe Rose Java > Concepts > Using Java Frameworks

  • Symbol für Onlinehilfe  Rose Java > How to > Load Java class libraries in a model

Das Schemapaket hinzufügen

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.

JavaBeans und Java-Klassen 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:

EJBs modellieren

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:

Designsubsystem für die EJB erstellen

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.

Typ und Persistenzmechanismus der EJB festlegen

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).

Mit Rose Java EJB-Klassen erstellen

Rose Java stellt eine Reihe von Dialogen zum Erstellen und Verwalten von EJB-Klassen in Rose bereit.

  Symbol für Onlinehilfe  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.  Symbol für Onlinehilfe 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.

Operationen und Attribute definieren

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.

  Symbol für Onlinehilfe  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:

Die Beziehungen zwischen Klassen modellieren 

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.

Die Klassen modellieren: Interaktionen

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. Symbol für Onlinehilfe  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:

EJB-Persistenz modellieren

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 modellieren

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.

Sicherheit modellieren

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.

Forward Engineering der EJB-Komponenten

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.

Reverse Engineering für EJBs

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).  

Die Benutzerschnittstellenschicht modellieren

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). Symbol für Onlinehilfe 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. Symbol für Onlinehilfe Nähere Informationen hierzu finden Sie in der Onlinehilfe zu Rational Rose unter Rose Java > How to > Work with EJBs and servlets.