4. Codegenerierung durch Rational Rose

Reverse Engineering bei Rational Rose für Java
Lars Hofer
Hinweis: In der aktuellen Version dieses Dokuments wird nur beschrieben, wie man für eine
schon unter Rational Rose angelegte Klasse (bzw. Komponente) Reverse Engineering
durchführen kann. Wie man Klassen u.U. aus anderen Dateien einbindet, wird noch folgen.
Hinweis: Wie Java-Klassen und -Komponenten unter Rational Rose angelegt werden können
ist ebenfalls und ausführlicher im Dokument
http://ebola.ifs.univie.ac.at/~hofer/rational/Wuerfelspiel.doc
ersichtlich.
Im folgenden wird nun für eine einzige Klasse aufgezeigt, wie nachträglich eingeführte
Variablen (Attribute) und Methoden (Operationen) in das Rational Rose Modell übernehmen
kann – also Reverse Engineering durchführen kann.
1. Anlegen des Projektes und Einstellungen für Java
Beim Anlegen des Projektes sollte gleich angegeben werden, dass es sich um ein Java-Projekt
(jdk-116) handelt, da dadurch die Definitionen der Java-Klassen und deren Packages des
Java-APIs geladen wird und diese dann als Variablentyp, Rückgabewerttyp und dergleichen
angegeben werden können.
Als nächstes wird der für das Projekt notwendige CLASSPATH angegeben und auch
kontrolliert, ob der CLASSPATH auch auf die Klassen der Java-API zeigt.
Wichtige Hinweise:
Es ist besonders wichtig, dass der CLASSPATH zumindest auf die Klassen der Java-API
zeigt. Ist dies nicht der Fall, dann können später beim Reverse Engineering die Java-Klassen
nicht aufgelöst werden und somit kein Reverse Engineering durchgeführt werden.
Dieser CLASSPATH wird von der Windows-Umgebungsvariable CLASSPATH übernommen
und muss dort vorhanden und korrekt gesetzt sein. Des weiteren muss der CLASSPATH
bei Rose98 und Rose98i auf nicht komprimierte Klassen zeigen – diese dürfen also nicht in
einer classes.zip enthalten sein, sondern müssen für diese Version von Rational Rose
gegebenenfalls entpackt werden, da sonst auch nicht die Java-Klassen aufgelöst werden
können und somit auch kein Reverse Engineering durchgeführt werden kann (im Gegensatz
zu Rational Rose2000, welches auch mit komprimierten Klassen arbeiten kann).
Nachdem angegeben wurde, dass es sich hier um ein Java-Projekt handelt, wird als nächstes
kontrolliert, ob der CLASSPATH für die Java-API-Klassen korrekt gesetzt ist und es wird für
das eigene Projekt der CLASSPATH entsprechend gesetzt:
Dazu öffnet man:
Tools (Hauptmenü) | Java | Project Specification | Class Path
Hier sollte unter
Enviroment Settings
unbedingt die korrekt gesetzte Windows-Umgebungsvariable CLASSPATH vorhanden sein.
Unter
Directories
kann dann das Verzeichnis angegeben werden, wohin das eigene Projekt ausgegeben werden
soll.
2. Anlegen der Java-Klasse
Im Logical View Teilzweig wird nur per Kontextmenü (rechte Maustaste) und
New | Class
eine neue Klasse angelegt. Diese könnte natürlich in einem Package enthalten sein, aber bei
diesem Beispiel wird darauf verzichtet.
Dann wird die Klasse in das Class Diagram der Logical View gezogen, um sie auch
dort sichtbar zu machen und weiter zu bearbeiten.
In diesem Fall wurde eine Klasse „Hallo“ angelegt, für die dann später Reverse Engineering
durchgeführt wird.
3. Anlegen der Java-Komponente
Um die Java-Klasse Hallo in einer Java-Datei Hallo.java zu generieren, muss eine
Komponente gleichen Namens im Component View Teilzweig per Kontextmenü (rechte
Maustaste) und
New | Component
angelegt werden (befindet sich die Java-Klasse in einem Package, so sollte auch hier ein
Package mit dem selben Namen angelegt und die Komponente in diesem Package erzeugt
werden). Die Komponente wird dann in das Component Diagram der Component
View gezogen, um sie dort auch sichtbar zu machen.
In diesem Beispiel wird eine Komponente „Hallo“ angelegt:
Damit die Java-Klasse Hallo in dieser Komponente Hallo.java durch Rational Rose
erzeugt werden kann, muss durch ziehen der Hallo-Komponente vom Component View
Teilzweig auf die Klasse Hallo im Logical View Teilzweig in Relation gesetzt werden.
Dass dies durchgeführt wurde, sieht man daran, dass der Komponentenname in Klammern
dem Klassenname folgt.
4. Codegenerierung durch Rational Rose
Als nächstes wird diese Hallo-Klasse in einer Hallo.java-Datei angelegt.
Dies wird durch das Kontextmenü (rechte Maustaste) der Hallo-Klasse im Logical
View Teilzweig und
Java | Generate Java
durchgeführt.
Wenn dies zum ersten mal ausgeführt wird, so fragt Rational Rose nach dem Pfad, wohin
dieses Projekt ausgegeben werden soll:
Dazu wählt man einfach einen CLASSPATH der linken Seite und mappt die Klasse auf ihn.
Sind keine Fehler enthalten, so wird der jetzt notwendige Java-Code generiert, andernfalls
muss man die im Log-Fenster angeführten Fehler beachten und beseitigen.
5. Implementieren durchführen
Jetzt werden für diese Klasse Methoden und Variablen angelegt, die nicht im Rational Rose
Modell enthalten sind, um diese dann in dieses zu übernehmen.
Dies kann zum Beispiel anhand des Rational-Rose-eigenen Editor erfolgen. Hier kann auch
gleich kontrolliert werden, ob die Klasse entsprechend angelegt wurde.
Man geht so vor:
Öffnen des Kontextmenü (rechte Maustaste) der Hallo-Klasse im Logical View
Teilzweig und
Java | Browse Java Sourse.
Dies zeigt dann den durch Rational Rose erzeugen Code :
Für diese Klasse werden nun ein paar Variablen (Attribute) und Methoden (Operationen)
implementiert:
z.B:
//Source file: D:\Eigene Dateien\Rational Rose\Wuerfelspiel\Hallo.java
import java.util.Vector;
public class Hallo {
public int i = 0;
public String s = "hallo";
private long l;
private Vector v = new Vector();
public Hallo() {
}
public static void main(String[] args) {
l = 1.234;
System.out.println("Hallo:
}
}
i = " +
i +
", s = " +
s +
", l = " +
l +
" v = " +
v);
Die Änderungen werden gespeichert und das Editor-Fenster geschlossen.
6. Reverse Engineering – Externe Änderungen übernehmen:
Die an einer Klasse extern durchgeführten Änderungen, das sind




neu eingeführte Methoden (Operationen)
neu eingeführte Klassenvariablen
neue Imports
Änderungen an einer Methodensignatur (Parameter, Rückgabewert)
aber nicht


Variablen innerhalb von Methoden aus dem Rational Rose Modell
Code innerhalb von Methoden aus dem Rational Rose Modell
in das Rational Rose Modell zu übernehmen geht man so vor:
Öffnen des Kontextmenü (rechte Maustaste) der Hallo-Klasse im Logical View
Teilzweig und
Java | Reverse Engineer Java...
Dadurch wird ein Fenster geöffnet, um zu spezifizieren, welche Änderungen übernommen
werden sollen:
Rational Rose hat die zu der ändernden Klasse gehörende Datei ausfindig gemacht – diese
wird markiert und wenn alles fehlerlos klappt, werden durch Drücken auf
Reverse
alle externen Änderungen in das Rational Rose Modell übernommen, wobei dieser Prozess
ein wenig dauern kann.
Konnte alles fehlerfrei durchgeführt werden, so kann dieses Fenster per
Done
geschlossen werden und die Änderungen kontrolliert werden.
Sind dagegen Fehler aufgetreten, so werden diese im Log-Fenster aufgelistet.
Meldet Rational Rose, dass es eine bestimmte Klasse nicht auflösen (resolve) kann, dann ist
vermutlich der Windows-CLASSPATH nicht oder falsch gesetzt, oder bei Rose98i die
benötigten Klassen nicht enpackt worden.
Ob die externen Änderungen korrekt übernommen worden sind, sieht man durch Öffnen des
Hallo-Klassen-Teilzweiges in der Logical View:
Rational Rose hat also eine main-Methode und auch die Variablen i, l, s und v angelgt.
Jetzt wird durch Doppelklich auf diese Methoden und Variablen kontrolliert, ob auch die
Typen und Rückgabewerte der Methoden bzw. Variablen korrekt übernommen wurden:
Zum Beispiel für main:
main ist wie im Quellcode angegeben, public static, hat den Rückgabewert void und
besitzt eine String-Array als Argument: somit alles OK.
Oder für s:
Auch s wurde richtig angelegt und hat auch den korrekten Intialisierungswert.
7. Ressourcen:
Dieses Dokument ist unter
http://ebola.ifs.univie.ac.at/~hofer/rational/ReverseEngineering.doc
die hier entwickelte Projektdatei unter
http://ebola.ifs.univie.ac.at/~hofer/rational/ReverseEngineering.mdl
und die dazugehörende Java-Datei unter
http://ebola.ifs.univie.ac.at/~hofer/rational/Hallo.java
verfügbar.