Die Reihe Xpert.press vermittelt Professionals in den Bereichen Softwareentwicklung, Internettechnologie und IT-Management aktuell und kompetent relevantes Fachwissen über Technologien und Produkte zur Entwicklung und Anwendung moderner Informationstechnologien.
Bernhard Rumpe
Agile Modellierung mit UML Codegenerierung, Testfälle, Refactoring
Mit 160 Abbildungen und 30 Tabellen
123
Bernhard Rumpe Institut für Software Systems Engineering Technische Universität Braunschweig Mühlenpfordtstr. 23 38106 Braunschweig e-mail:
[email protected]
Bibliografische Information der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.
ISSN 1439-5428 ISBN 3-540-20905-0 Springer Berlin Heidelberg New York
Dieses Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte, insbesondere d ie der Übersetzung, des Nachdr ucks , des Vortrags, der Entnahme von Abbildungen und Tabellen, der Funksendung, der Mikroverfilmung oder der Vervielfältigung auf anderen Wegen und der Speicherung in Datenverarbeitungsanlagen bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten. Eine Vervielfältigung dieses Werkes oder von Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen der gesetzlichen Bestimmungen des Urheberrechtsgesetzes der Bundesrepublik Deutschland vom 9. September 1965 in der jeweils geltenden Fassung zulässig. Sie ist grundsätzlich vergütungspflichtig. Zuwiderhandlungen unterliegen den Strafbestimmungen des Urheberrechtsgesetzes. Springer ist ein Unternehmen von Springer Science+Business Media springer.de © Springer-Verlag Berlin Heidelberg 2005 Printed in Germany Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutzgesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften. Text und Abbildungen wurden mit größter Sorgfalt erarbeitet. Verlag und Autor können jedoch für eventuell verbliebene fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Satz: Druckfertige Daten des Autors Herstellung: LE-TeX Jelonek, Schmidt & Vöckler GbR, Leipzig Umschlaggestaltung: KünkelLopka Werbeagentur, Heidelberg Gedruckt auf säurefreiem Papier 33/3142/YL - 5 4 3 2 1 0
Vorwort
Softwaresysteme sind heutzutage in der Regel komplexe Produkte, fur ¨ deren erfolgreiche Produktion der Einsatz ingenieurm¨aßiger Techniken unerl¨asslich ist. Diese nun mittlerweile mehr als 30 Jahre alte und h¨aufig zitierte Erkenntnis hat dazu gefuhrt, ¨ dass in den letzten drei Jahrzehnten innerhalb der Informatik im Gebiet des Software Engineering intensiv an Sprachen, Methoden und Werkzeugen zur Unterstutzung ¨ des Softwareerstellungsprozesses gearbeitet wird. Trotz großer Fortschritte hierbei muss allerdings festgestellt werden, dass im Vergleich zu anderen, durchg¨angig viel a¨ lteren Ingenieursdisziplinen noch viele Fragen unbeantwortet sind und immer neue Fragestellungen auftauchen. So macht auch ein oberfl¨achlicher Vergleich zum Beispiel mit dem Gebiet des Bauwesens schnell deutlich, dass dort internatonale Standards eingesetzt werden, um Modelle von Geb¨auden zu erstellen, die Modelle zu analysieren und anschließend die Modelle in Bauten zu realisieren. Hierbei sind dann auch die Rollen- und Aufgabenverteilungen allgemein akzeptiert, so dass etwa Berufsgruppen wie Architekten, Statiker sowie Spezialisten fur ¨ den Tiefund Hochbau existieren. Eine derartige modellbasierte Vorgehensweise wird zunehmend auch in der Softwareentwicklung favorisiert. Dies bedeutet insbesondere, dass in den letzten Jahren international versucht wird, eine allgemein akzeptierte Modellierungssprache festzulegen, so dass etwa wie im Bauwesen, von einem Software-Architekten erstellte Modelle von einem Software-Statiker“ ” analysiert werden konnen, ¨ bevor sie von Spezialisten fur ¨ die Realisierung, also Programmierern in ausfuhrbare ¨ Programme umgesetzt werden.
VI
Vorwort
Diese standardisierte Modellierungssprache ist die Unified Modeling Language, die in einem schrittweisen Prozess durch ein international besetztes Konsortium stetig weiterentwickelt wird. Aufgrund der vielf¨altigen Interessenlagen im Standardisierungsprozess ist mit der aktuellen Version 2.0 der UML eine Sprachfamilie entstanden, deren Umfang, semantische Fundierung und methodische Verwendung noch viele Fragen offen l¨asst. Diesem Problem hat sich Herr Rumpe in den letzten Jahren in seinen wissenschaftlichen und praktischen Arbeiten gewidmet, deren Ergebnisse er nun in zwei Buchern ¨ einer breiten Leserschaft zug¨anglich macht. Hierbei hat Herr Rumpe das methodische Vorgehen in den Vordergrund gestellt. Im Einklang mit der heutigen Erkenntnis, dass leichtgewichtige, agile Entwicklungsprozesse insbesondere in kleineren und mittleren Entwicklungsprojekten große Vorteile bieten, hat Herr Rumpe Techniken fur ¨ einen agilen Entwicklungsprozess entwickelt. Auf dieser Basis hat er dann eine geeignete Modellierungssprache definiert, in dem er ein so genanntes Sprachprofil fur ¨ die UML definiert hat. In diesem Sprachprofil UML/P hat er die UML geeignet abgespeckt und an einigen Stellen so abgerundet, dass nun eine handhabbare Version der UML insbesondere fur ¨ einen agilen Entwicklungsprozess vorliegt. Herr Rumpe hat diese Sprache UML/P ausfuhrlich ¨ in dem diesem Buch vorangehenden Buch Modellierung mit UML“ erl¨autert. Das Buch bietet ” eine wesentliche Grundlage fur ¨ das hier vorliegende Buch, deren Inhalt allerdings auch in diesem Buch noch einmal kurz zusammengefasst wird. Das hier vorliegende Buch mit dem Titel Agile Modellierung mit UML“ widmet ” sich nun in erster Linie dem methodischen Umgang mit der UML/P. Hierbei behandelt Herr Rumpe drei Kernthemen einer modellbasierten Softwareentwicklung. Dies sind • • •
¨ die Codegenerierung, also der automatisierte Ubergang vom Modell zu einem ausfuhrbaren ¨ Programm, das systematische Testen von Programmen mithilfe einer modellbasierten, strukturierten Festlegung von Testf¨allen sowie die Weiterentwicklung von Modellen durch den Einsatz von Transformations- und Refactoring-Techniken.
Alle drei Kernthemen werden von Herrn Rumpe zun¨achst systematisch aufgearbeitet und die zugrunde liegenden Begriffe und Techniken werden eingefuhrt. ¨ Darauf aufbauend stellt er dann jeweils seinen Ansatz auf der Basis der Sprache UML/P vor. Diese Zweiteilung und klare Trennung zwischen Grundlagen und Anwendungen machen die Darstellung außerordentlich gut verst¨andlich und bieten dem Leser auch die Moglichkeit, ¨ diese Erkenntnisse unmittelbar auf andere modellbasierte Ans¨atze und Sprachen zu ubertragen. ¨
Vorwort
VII
Insgesamt hat dieses Buch einen großen Nutzen sowohl fur ¨ den Praktiker in der Softwareentwicklung, fur ¨ die akademische Ausbildung im Fachgebiet Softwaretechnik als auch fur ¨ die Forschung im Bereich der modellbasierten Entwicklung der Software. Der Praktiker lernt, wie er mit modernen modellbasierten Techniken die Produktion von Code verbessern und damit die Qualit¨at erheblich steigern kann. Dem Studierenden werden sowohl wichtige wissenschaftliche Grundlagen als auch unmittelbare Anwendungen der dargestellten grundlegenden Techniken vermittelt. Dem Wissenschaftler bie¨ tet das Buch einen umfassenden Uberblick uber ¨ den heutigen Stand der Forschung in den drei Kernthemen des Buchs. Das Buch stellt somit einen wichtigen Meilenstein in der Entwicklung von Konzepten und Techniken fur ¨ eine modellbasierte und ingenieurm¨aßige Softwareentwicklung dar und bietet somit auch die Grundlage fur ¨ weitere Arbeiten in der Zukunft. So werden praktische Erfahrungen mit dem Umgang der Konzepte ihre Tragbarkeit validieren. Wissenschaftliche, konzeptionelle Arbeiten werden insbesondere das Thema der Modelltransformation etwa auf der Basis von Graphtransformationen genauer erforschen und daruber ¨ hinaus das Gebiet der Modellanalyse im Sinne einer Modellstatik vertiefen. Ein derartiges vertieftes Verst¨andnis der Informatik-Methoden im Bereich der modellbasierten Softwareentwicklung ist eine entscheidende Voraussetzung fur ¨ eine erfolgreiche Kopplung mit anderen ingenieurm¨aßigen Methoden etwa im Bereich von eingebetteten Systemen oder im Bereich von intelligenten, benutzungsfreundlichen Produkten. Die Dom¨anenunabh¨angigkeit der Sprache UML/P bietet auch hier noch viele Moglichkeiten. ¨
Gregor Engels Paderborn im September 2004
Inhaltsverzeichnis
1
Einfuhrung ¨ ................................................. 1.1 Ziele und Inhalte von Band 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Erg¨anzende Ziele dieses Buchs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ¨ 1.3 Uberblick ................................................ 1.4 Notationelle Konventionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 2 4 6 7
2
¨ Kompakte Ubersicht zur UML/P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 Klassendiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.1 Klassen und Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.2 Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.3 Repr¨asentation und Stereotypen . . . . . . . . . . . . . . . . . . . . . 2.2 Object Constraint Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ¨ 2.2.1 Ubersicht uber ¨ OCL/P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.2 Die OCL-Logik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.3 Container-Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.4 Funktionen in OCL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Objektdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Einfuhrung ¨ in Objektdiagramme . . . . . . . . . . . . . . . . . . . . 2.3.2 Komposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.3 Bedeutung eines Objektdiagramms . . . . . . . . . . . . . . . . . . 2.3.4 Logik der Objektdiagramme . . . . . . . . . . . . . . . . . . . . . . . . 2.4 Statecharts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.1 Eigenschaften von Statecharts . . . . . . . . . . . . . . . . . . . . . . . 2.4.2 Darstellung von Statecharts . . . . . . . . . . . . . . . . . . . . . . . . . 2.5 Sequenzdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9 10 10 11 14 15 15 18 19 26 28 29 30 31 32 33 33 37 44
3
Prinzipien der Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1 Konzepte der Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.1 Konstruktive Interpretation von Modellen . . . . . . . . . . . . 3.1.2 Tests versus Implementierung . . . . . . . . . . . . . . . . . . . . . . . 3.1.3 Tests und Implementierung aus dem gleichen Modell .
49 52 54 56 59
X
Inhaltsverzeichnis
3.2 Techniken der Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 Plattformabh¨angige Codegenerierung . . . . . . . . . . . . . . . 3.2.2 Funktionalit¨at und Flexibilit¨at . . . . . . . . . . . . . . . . . . . . . . . 3.2.3 Steuerung der Codegenerierung . . . . . . . . . . . . . . . . . . . . . 3.3 Semantik der Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4 Parametrisierung eines Werkzeugs . . . . . . . . . . . . . . . . . . . . . . . . . 3.4.1 Implementierung von Werkzeugen . . . . . . . . . . . . . . . . . . 3.4.2 Darstellung von Skripttransformationen . . . . . . . . . . . . . 4
60 60 63 67 68 71 71 73
Transformationen fur ¨ die Codegenerierung . . . . . . . . . . . . . . . . . . . . 77 ¨ 4.1 Ubersetzung von Klassendiagrammen . . . . . . . . . . . . . . . . . . . . . . 78 4.1.1 Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 4.1.2 Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 4.1.3 Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 4.1.4 Qualifizierte Assoziation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 4.1.5 Komposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 4.1.6 Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 4.1.7 Objekterzeugung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 ¨ 4.2 Ubersetzung von Objektdiagrammen . . . . . . . . . . . . . . . . . . . . . . . 102 4.2.1 Konstruktiv eingesetzte Objektdiagramme . . . . . . . . . . . 102 4.2.2 Beispiel einer konstruktiven Codegenerierung . . . . . . . . 104 4.2.3 Als Pr¨adikate eingesetzte Objektdiagramme . . . . . . . . . . 106 4.2.4 Objektdiagramm beschreibt Strukturmodifikation . . . . 109 4.2.5 Objektdiagramme und OCL . . . . . . . . . . . . . . . . . . . . . . . . . 112 4.3 Codegenerierung aus OCL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 4.3.1 OCL-Aussage als Pr¨adikat . . . . . . . . . . . . . . . . . . . . . . . . . . 113 4.3.2 OCL-Logik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 4.3.3 OCL-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 4.3.4 Typen als Extension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 4.3.5 Navigation und Flattening . . . . . . . . . . . . . . . . . . . . . . . . . . 120 4.3.6 Quantoren und Spezialoperatoren . . . . . . . . . . . . . . . . . . . 121 4.3.7 Methodenspezifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 4.3.8 Vererbung von Methodenspezifikationen . . . . . . . . . . . . . 125 4.4 Ausfuhrung ¨ von Statecharts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 4.4.1 Methoden-Statecharts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 4.4.2 Umsetzung der Zust¨ande . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 4.4.3 Umsetzung der Transitionen . . . . . . . . . . . . . . . . . . . . . . . . 132 ¨ 4.5 Ubersetzung von Sequenzdiagrammen . . . . . . . . . . . . . . . . . . . . . 136 4.5.1 Sequenzdiagramm als Testtreiber . . . . . . . . . . . . . . . . . . . . 136 4.5.2 Sequenzdiagramm als Pr¨adikat . . . . . . . . . . . . . . . . . . . . . . 138 4.6 Zusammenfassung zur Codegenerierung . . . . . . . . . . . . . . . . . . . 140
Inhaltsverzeichnis
XI
5
Grundlagen des Testens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 5.1 Einfuhrung ¨ in die Testproblematik . . . . . . . . . . . . . . . . . . . . . . . . . 144 5.1.1 Testbegriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 5.1.2 Ziele der Testaktivit¨at . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 5.1.3 Fehlerkategorien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 5.1.4 Begriffsbestimmung fur ¨ Testverfahren . . . . . . . . . . . . . . . 150 5.1.5 Suche geeigneter Testdaten . . . . . . . . . . . . . . . . . . . . . . . . . . 152 5.1.6 Sprachspezifische Fehlerquellen . . . . . . . . . . . . . . . . . . . . . 153 5.1.7 UML/P als Test- und Implementierungssprache . . . . . . 155 5.1.8 Eine Notation fur ¨ die Testfalldefinition . . . . . . . . . . . . . . . 158 5.2 Definition von Testf¨allen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 5.2.1 Operative Umsetzung eines Testfalls . . . . . . . . . . . . . . . . . 161 5.2.2 Vergleich der Testergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . 163 5.2.3 Werkzeuge JUnit und VUnit . . . . . . . . . . . . . . . . . . . . . . . . . 166
6
Modellbasierte Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 6.1 Testdaten und Sollergebnis mit Objektdiagrammen . . . . . . . . . . 172 6.2 Invarianten als Codeinstrumentierungen . . . . . . . . . . . . . . . . . . . 175 6.3 Methodenspezifikationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 6.3.1 Methodenspezifikationen als Codeinstrumentierung . . 177 6.3.2 Methodenspezifikationen zur Testfallbestimmung . . . . 178 6.3.3 Testfalldefinition mit Methodenspezifikationen . . . . . . . 181 6.4 Sequenzdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 6.4.1 Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 6.4.2 Vollst¨andigkeit und Matching . . . . . . . . . . . . . . . . . . . . . . . 185 6.4.3 Nicht-kausale Sequenzdiagramme . . . . . . . . . . . . . . . . . . . 186 6.4.4 Mehrere Sequenzdiagramme in einem Test . . . . . . . . . . . 186 6.4.5 Mehrere Trigger im Sequenzdiagramm . . . . . . . . . . . . . . . 187 6.4.6 Interaktionsmuster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 6.5 Statecharts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 6.5.1 Ausfuhrbare ¨ Statecharts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 6.5.2 Statechart als Ablaufbeschreibung . . . . . . . . . . . . . . . . . . . 192 6.5.3 Testverfahren fur ¨ Statecharts . . . . . . . . . . . . . . . . . . . . . . . . 194 ¨ 6.5.4 Uberdeckungsmetriken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 6.5.5 Transitionstests statt Testsequenzen . . . . . . . . . . . . . . . . . . 199 6.5.6 Weiterfuhrende ¨ Ans¨atze . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 6.6 Zusammenfassung und offene Punkte beim Testen . . . . . . . . . . 201
7
Testmuster im Einsatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 7.1 Dummies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 7.1.1 Dummies fur ¨ Schichten der Architektur . . . . . . . . . . . . . . 211 7.1.2 Dummies mit Ged¨achtnis . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 7.1.3 Sequenzdiagramm statt Ged¨achtnis . . . . . . . . . . . . . . . . . . 214 7.1.4 Abfangen von Seiteneffekten . . . . . . . . . . . . . . . . . . . . . . . . 215 7.2 Testbare Programme gestalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
XII
Inhaltsverzeichnis
7.3
7.4
7.5
7.6
7.2.1 Statische Variablen und Methoden . . . . . . . . . . . . . . . . . . . 7.2.2 Seiteneffekte in Konstruktoren . . . . . . . . . . . . . . . . . . . . . . 7.2.3 Objekterzeugung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.4 Vorgefertigte Frameworks und Komponenten . . . . . . . . Behandlung der Zeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3.1 Simulation der Zeit im Dummy . . . . . . . . . . . . . . . . . . . . . 7.3.2 Variable Zeiteinstellung im Sequenzdiagramm . . . . . . . 7.3.3 Muster zur Simulation von Zeit . . . . . . . . . . . . . . . . . . . . . 7.3.4 Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nebenl¨aufigkeit mit Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4.1 Eigenes Scheduling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4.2 Sequenzdiagramm als Scheduling-Modell . . . . . . . . . . . . 7.4.3 Behandlung von Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4.4 Muster fur ¨ die Behandlung von Threads . . . . . . . . . . . . . 7.4.5 Probleme der erzwungenen Sequentialisierung . . . . . . . Verteilung und Kommunikation . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.1 Simulation der Verteilung . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.2 Simulation von Singletons . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.3 OCL-Bedingungen uber ¨ mehrere Lokationen . . . . . . . . . 7.5.4 Kommunikation simuliert verteilter Prozesse . . . . . . . . . 7.5.5 Muster fur ¨ Verteilung und Kommunikation . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
216 219 219 220 222 224 224 227 228 229 230 231 232 234 235 237 237 239 241 242 244 245
8
Refactoring als Modelltransformation . . . . . . . . . . . . . . . . . . . . . . . . . 247 8.1 Einfuhrende ¨ Beispiele fur ¨ Transformationen . . . . . . . . . . . . . . . . 248 8.2 Methodik des Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 8.2.1 Technische und methodische Voraussetzungen fur ¨ Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 8.2.2 Qualit¨at des Designs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 8.2.3 Refactoring, Evolution und Wiederverwendung . . . . . . 256 8.3 Theorie der Modelltransformationen . . . . . . . . . . . . . . . . . . . . . . . 258 8.3.1 Modelltransformationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 8.3.2 Semantik einer Modelltransformation . . . . . . . . . . . . . . . . 259 8.3.3 Beobachtungsbegriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 8.3.4 Transformationsregeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 8.3.5 Korrektheit von Transformationsregeln . . . . . . . . . . . . . . 272 8.3.6 Ans¨atze der transformationellen Softwareentwicklung 274
9
Refactoring von Modellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 9.1 Quellen fur ¨ UML/P-Refactoring-Regeln . . . . . . . . . . . . . . . . . . . . 278 9.1.1 Definition und Darstellung von Refactoring-Regeln . . . 280 9.1.2 Refactoring in Java/P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 9.1.3 Refactoring von Klassendiagrammen . . . . . . . . . . . . . . . . 288 9.1.4 Refactoring in der OCL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 9.1.5 Einfuhrung ¨ von Testmustern als Refactoring . . . . . . . . . . 296
Inhaltsverzeichnis
9.2 Additive Methode fur ¨ Datenstrukturwechsel . . . . . . . . . . . . . . . . 9.2.1 Vorgehensweise fur ¨ den Datenstrukturwechsel . . . . . . . 9.2.2 Beispiel: Darstellung von Geldbetr¨agen . . . . . . . . . . . . . . 9.2.3 Beispiel: Einfuhrung ¨ des Chairs im Auktionssystem . . . 9.3 Zusammenfassung der Refactoring-Techniken . . . . . . . . . . . . . .
XIII
299 299 302 306 314
10 Zusammenfassung und Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
1 Einfuhrung ¨
Der wahre Zweck eines Buches ist, den Geist hinterrucks ¨ zum eigenen Denken zu verleiten. Christopher Darlington Morley
Jungste ¨ Beispiele zeigen eindrucksvoll, wie teuer falsche oder fehlerhafte Software beim Absturz einer Rakete oder bei Maut-Projekten werden konnen. ¨ Um die stetig wachsende Komplexit¨at von Software-basierten Projekten und Produkten sowohl im Bereich betrieblicher Informations- als auch eingebetterer Systeme beherrschbar zu machen, wurde in den letzten Jahren ein wirkungsvolles Portfolio an Konzepten, Techniken und Methoden entwickelt, die die Softwaretechnik zu einer erwachsenen Ingeniersdisziplin heranreifen lassen. Das Portfolio ist zwar noch nicht vollst¨andig ausgereift, muss aber insbesondere in dem derzeitigen industriellen Softwareentwicklungsprozess sehr viel mehr noch etabliert werden. Die F¨ahigkeiten moderner Programmiersprachen, Klassenbibliotheken und vorhandener Softwareentwicklungswerkzeuge erlauben uns heute den Einsatz von Vorgehensweisen, die noch vor kurzer Zeit nicht realisierbar schienen. Als Teil dieses Portfolios behandelt dieses Buch eine auf der UML basierende Methodik, bei der vor allem Techniken zum praktischen Einsatz der UML im Vordergrund stehen. Als wichtigste Techniken werden dabei • • •
Generierung von Code aus Modellen, Modellierung von Testf¨allen und Weiterentwicklung durch Refactoring von Modellen
erkannt und in diesem Buch studiert. Dabei basiert dieser Band 2 sehr stark auf dem ersten Band Modellie” rung mit UML. Sprache, Konzepte und Methodik.“ [Rum04c], in dem das Sprachprofil UML/P detailliert erkl¨art ist. Es ist daher zu empfehelen, bei der Lekture ¨ dieses Bands [Rum04b] den ersten Band [Rum04c] griffbereit zu
2
1 Einfuhrung ¨
halten, obwohl Teile von Band 1 in kompakter Form in Kapitel 2 wiederholt werden.
1.1 Ziele und Inhalte von Band 1 Gemeinsames Mission Statement beider B¨ande: Es ist ein Kernziel, fur ¨ das genannte Portfolio grundlegende Techniken zur modellbasierten Entwicklung zur Verfugung ¨ zu stellen. Dabei wird in Band 1 eine Variante der UML vorgestellt, die speziell zur effizienten Entwicklung qualitativ hochwertiger Software und Software-basierter Systeme geeignet ist. Darauf aufbauend enth¨alt dieser Band Techniken zur Generierung von Code, von Testf¨allen und zum Refactoring der UML/P. UML-Standard: Der UML 2.0-Standard muss sehr viele Anforderungen aus unterschiedlichen Gegebenheiten heraus erfullen ¨ und ist daher notwendigerweise uberladen. ¨ Viele Elemente des Standards sind fur ¨ unsere Zwecke nicht oder nicht in der gegebenen Form sinnvoll, w¨ahrend andere Sprachkonzepte ganz fehlen. Deshalb wird in diesem Buch ein angepasstes und mit UML/P bezeichnetes Sprachprofil der UML vorgestellt. UML/P wird dadurch fur ¨ die vorgeschlagenen Entwicklungstechniken im Entwurf, in der Implementierung und in der Wartung optimiert und so in agilen Entwicklungsmethoden besser einsetzbar. Band 1 konzentriert sich vor allem auf die Einfuhrung ¨ des Sprachprofils ¨ und einer allgemeinen Ubersicht zur vorgeschlagenen Methodik. Die UML/P ist als Ergebnis mehrerer Grundlagen- und Anwendungsprojekte entstanden. Insbesondere das in Anhang D, Band 1 dargestellte Anwendungsbeispiel wurde soweit moglich ¨ unter Verwendung der hier beschriebenen Prinzipien entwickelt. Das Auktionssystem ist auch deshalb zur Demonstration der in den beiden Buchern ¨ entwickelten Techniken geeignet ideal, weil Ver¨anderungen des Gesch¨aftsmodells oder der Unternehmensumgebung in dieser Anwendungsdom¨ane besonders h¨aufig sind. Flexible und dennoch qualitativ hochwertige Softwareentwicklung ist fur ¨ diesen Bereich essentiell. Objektorientierung und Java: Fur ¨ neue Gesch¨aftsanwendungen wird heute prim¨ar Objekttechnologie eingesetzt. Die Existenz vielseitiger Klassenbibliotheken und Frameworks, die vorhandenen Werkzeuge und nicht zuletzt der weitgehend gelungene Sprachentwurf begrunden ¨ den Erfolg der Programmiersprache Java. Das UML-Sprachprofil UML/P und die darauf aufbauenden Entwicklungstechniken werden daher auf Java zugeschnitten. Brucke ¨ zwischen UML und agilen Methoden: Gleichzeitig bilden die beiden Bucher ¨ zwischen den eher als unvereinbar geltenden Ans¨atzen der agilen Methoden und der Modellierungssprache UML eine elegante Brucke. ¨ Agile Methoden und insbesondere Extreme Programming besitzen eine Reihe von interessanten Techniken und Prinzipien, die das Portfolio der Softwaretechnik fur ¨ bestimmte Projekttypen bereichern. Merkmale dieser Tech-
1.1 Ziele und Inhalte von Band 1
3
niken sind der weitgehende Verzicht auf Dokumentation, die Konzentration auf Flexibilit¨at, Optimierung der Time-To-Market und Minimierung der verbrauchten Ressourcen bei gleichzeitiger Sicherung der geforderten Qualit¨at. Damit sind agile Methoden fur ¨ die Ziele dieses Buchs als Grundlage gut geeignet. Neue agile Vorgehensweise auf Basis der UML/P: Die UML wird als Notation fur ¨ eine Reihe von Aktivit¨aten, wie Gesch¨aftsfallmodellierung, Sollund Ist-Analyse sowie Grob- und Fein-Entwurf in verschiedenen Granularit¨atsstufen eingesetzt. Die Artefakte der UML stellen damit einen wesentlichen Grundstein fur ¨ die Planung und Kontrolle von Meilenstein-getriebenen Softwareentwicklungsprojekten dar. Deshalb wird die UML vor allem in plan-getriebenen Projekten mit relativ hoher Dokumentationsleistung und der daraus resultierenden Schwerf¨alligkeit eingesetzt. Nun ist die UML aber kompakter, semantisch reichhaltiger und besser geeignet, komplexe Sachverhalte darzustellen, als eine normale Programmiersprache. Sie bietet dadurch fur ¨ die Modellierung von Testf¨allen sowie fur ¨ die transformationelle Evolution von Softwaresystemen wesentliche Vorteile. Auf Basis einer Diskussion agiler Methoden und der darin enthaltenen Konzepte wird in Band 1 eine neue agile Methode skizziert, die das UML/P-Sprachprofil als Grundlage fur ¨ viele Aktivit¨aten nutzt, ohne die Schwerf¨alligkeit typischer UML-basierter Methoden zu importieren. Die beschriebenen Ziele wurden in Band 1 in folgenden Kapitel umgesetzt: 1 Einfuhrung ¨ 2 Agile und UML-basierte Methodik beschreibt die Vorgehensweise zum Einsatz der UML/P im Kontext vorhandener agiler Methoden. 3 Klassendiagramme fuhrt ¨ Form und Verwendung von Klassendiagrammen ein. 4 Object Constraint Language diskutiert eine syntaktisch auf Java angepasste, sprachlich erweiterte und semantisch konsolidierte Fassung der textuellen Beschreibunsgsprache OCL. 5 Objektdiagramme diskutiert Sprache und methodischen Einsatz der Objektdiagramme sowie deren Integration mit der OCL-Logik, um damit eine “Logik der Diagramme“ zu ermoglichen, ¨ in der unerwunschte ¨ Situationen, Alternativen und Kombinationen beschrieben werden konnen. ¨ 6 Statecharts beinhaltet neben der Einfuhrung ¨ der Statecharts eine Sammlung von Transformationen zur deren semantikerhaltender Vereinfachung. 7 Sequenzdiagramme beschreibt Form, Bedeutung und Verwendung von Sequenzdiagrammen.
4
1 Einfuhrung ¨
A Sprachdarstellung durch Syntaxklassendiagramme bietet eine Kombination aus Extended-Backus-Naur-Form (EBNF) und spezialisierten Klassendiagrammen zur Darstellung der abstrakten Syntax (Metamodell) der UML/P. B Java beschreibt die abstrakte Syntax des genutzten Teils von Java. C Syntax der UML/P beschreibt die abstrakte Syntax der UML/P. D Anwendungsbeispiel: Internetbasiertes Auktionssystem erl¨autert Hintergrundinformation zu dem in beiden B¨anden verwendeten Beispiel des Auktionssystems.
1.2 Erg¨anzende Ziele dieses Buchs Um die Effizienz in einem Projekt zu steigern, ist es notwendig, den Entwicklern effektive Notationen, Techniken und Methoden zur Verfugung ¨ zu stellen. Weil das prim¨are Ziel jeder Softwareentwicklung das lauff¨ahige und korrekt implementierte Produktionssystem ist, sollte der Einsatz der UML nicht nur zur Dokumentation von Entwurfen ¨ dienen. Stattdessen ist die automatisierte Umsetzung in Code durch Codegeneratoren, die Definition von Testf¨allen mit der UML/P zur Qualit¨atssicherung und die Evolution von UML-Modellen mit Refactoring-Techniken essentiell. Die Kombination von Codegenerierung, Testfallmodellierung und Refactoring bietet dabei wesentliche Synergie-Effekte, die zum Beispiel bei der Qualit¨atssicherung, bei der erhohten ¨ Wiederverwendung und der gesteigerten F¨ahigkeit zur Weiterentwicklung beitragen. Codegenerierung: Zur effizienten Erstellung eines Systems ist eine gut parametrisierte Codegenerierung aus abstrakten Modellen essentiell. Die diskutierte Form der Codegenerierung erlaubt die kompakte und von der Technik weitgehend unabh¨angige Entwicklung von Modellen. fur ¨ spezifische Dom¨anen und Anwendungen. Erst bei der Generierung werden technologieabh¨angige Aspekte wie zum Beispiel Datenbankanbindung, Kommunikation oder GUI-Darstellung hinzugefugt. ¨ Dadurch wird die UML/P als Programmiersprache einsetzbar, und es entsteht kein konzeptueller Bruch zwischen Modellierungs- und Programmiersprache. Allerdings ist es wichtig, ausfuhrbare ¨ und abstrakte Modelle im Softwareentwicklungsprozess explizit zu unterscheiden und jeweils ad¨aquat einzusetzen. Modellierung automatisierbarer Tests: Die systematische und effiziente Durchfuhrung ¨ von Tests ist ein wesentlicher Bestandteil zur Sicherung der Qualit¨at eines Systems. Ziel ist dabei, dass Tests nach ihrer Erstellung automatisiert ablaufen konnen. ¨ Codegenerierung wird daher nicht nur zur Entwicklung des Produktionssystems, sondern insbesondere auch fur ¨ Testf¨alle eingesetzt, um so die Konsistenz zwischen Spezifikation und Implementierung zu prufen. ¨ Der Einsatz der UML/P zur Testfallmodellierung ist daher
1.2 Erg¨anzende Ziele dieses Buchs
5
ein wesentlicher Bestandteil einer agilen Methodik. Dabei werden insbesondere Objektdiagramme, die OCL und Sequenzdiagramme zur Modellierung von Testf¨allen eingesetzt. Abbildung 1.1 skizziert die ersten beiden Ziele dieses Buchs.
Abbildung 1.1. Notationen der UML/P
¨ Evolution mit Refactoring: Die diskutierte Flexibilit¨at, auf Anderungen der Anforderungen oder der Technologie schnell zu reagieren, erfordert eine Technik zur systematischen Anpassung des bereits vorhandenen Modells beziehungsweise der Implementierung. Die Evolution eines Systems in Bezug auf neue Anforderungen oder einem neuen Einsatzgebiet sowie der Behebung von Strukturdefiziten der Softwarearchitektur erfolgt idealerweise durch Refactoring-Techniken. Ein weiterer Schwerpunkt ist daher die Fundierung und Einbettung der Refactoring-Techniken in die allgemeinere Vorgehensweise zur Modelltransformation und die Diskussion, welche Arten von Refactoring-Regeln fur ¨ die UML/P entwickelt oder von anderen Ans¨atzen ubernommen ¨ werden konnen. ¨ Besonders betrachtet werden dabei Klassendiagramme, Statecharts und OCL. Sowohl bei der Testfallmodellierung als auch bei den Refactoring-Techniken werden aus den fundierenden Theorien stammende Erkenntnisse dargestellt und auf die UML/P transferiert. Ziel des Buchs ist es, diese Konzepte anhand zahlreicher praktischer Beispiele zu erkl¨aren und in Form von Testmustern beziehungsweise Refactoring-Techniken fur ¨ UML-Diagramme aufzubereiten. Model Driven Architecture (MDA): Initiiert durch das Industriekonsortium OMG1 wird derzeit an der Intensivierung des werkzeugbasierten Einsatzes der UML in der Softwareentwicklung gearbeitet. Die als MDA be1
Die Object Management Group (OMG) ist fur ¨ die Definition der UML in Form einer Technical Recommendation“ zust¨andig. ”
6
1 Einfuhrung ¨
zeichnete Technik bietet im Bereich Codegenerierung a¨ hnliche Charakteristiken wie der hier diskutierte Ansatz. Jedoch fehlt eine geeignet angepasste Methodik. Der in diesem Buch vorgestellte Ansatz zum Refactoring bietet dazu eine ad¨aquate Erg¨anzung zur horizontalen“ Transformation. ” Abgrenzung: Mit den behandelten Techniken konzentriert sich dieses Buch vor allem auf die Unterstutzung ¨ der Entwurfs-, Implementierungsund Wartungsaktivit¨aten, allerdings ohne diese in allen Facetten abzudecken. Wichtig, aber unbehandelt sind auch Techniken und Notationen zur Erhebung und zum Management von Anforderungen, zur Projektplanung ¨ und -durchfuhrung, ¨ zur Kontrolle sowie zum Versions- und Anderungsmanagement. Stattdessen wird an geeigneten Stellen auf entsprechende weiterfuhrende ¨ Literatur verwiesen.
¨ 1.3 Uberblick ¨ Abbildung 1.2 erlaubt einen guten Uberblick uber ¨ den Matrix-artigen Aufbau weiter Teile beider B¨ande. W¨ahrend dieser Band sich verst¨arkt um methodische Fragestellungen kummert ¨ wird die UML/P im Band 1 erkl¨art.
¨ Abbildung 1.2. Ubersicht uber ¨ den Inhalt beider B¨ande
Das Kapitel 2 gibt eine kurze und kompakte Zusammenfassung von Band 1, [Rum04c]. Dabei wird vor allem das dort eingefuhrte ¨ Sprachprofil der UML/P sehr kompakt und daher unvollst¨andig vorgestellt. Die Kapitel 3 und 4 diskutieren prinzipielle und technische Problemstellungen zur Codegenerierung. Dies beinhaltet die Architektur und die Steuerung eines Codegenerators genauso wie die Frage, welche Teile der UML/P fur ¨ Test- beziehungsweise fur ¨ Produktionscode geeignet sind. Darauf aufbauend wird ein Mechanismus zur Beschreibung von Codegenerierung eingefuhrt. ¨ Erg¨anzend dazu wird anhand ausgew¨ahlter Teile der verschiedenen UML/P-Notationen gezeigt, wie daraus Test- und Produktionscode ge-
1.4 Notationelle Konventionen
7
neriert werden kann. Dabei werden sowohl Alternativen diskutiert als auch die Kombination von Transformationen demonstriert. Die Kapitel 5 und 6 erortern ¨ die aus der Literatur bekannten Begriffsbildungen fur ¨ Testverfahren und die beim Testen zu beachtenden Besonderheiten, die aufgrund der Nutzung der UML/P als Test- und Implementierungssprache entstehen. Es wird beschrieben, wie eine Architektur fur ¨ die automatisierte Testausfuhrung ¨ aussieht und wie UML/P-Diagramme eingesetzt werden, um Testf¨alle zu definieren. Kapitel 7 zeigt anhand von Testmustern die Verwendbarkeit der UML/PDiagramme zur Definition von Testf¨allen. Diese Testmuster enthalten Erfahrungswissen zur Definition von testbaren Programmen insbesondere fur ¨ funktionale Tests von verteilten und nebenl¨aufigen Softwaresystemen. Die Kapitel 8 und 9 diskutieren Techniken zur Transformation von Modellen und Code und stellen damit Refactoring als semantikerhaltende Transformation auf eine fundierte Basis. Fur ¨ Refactoring wird ein expliziter und praktisch verwendbarer Beobachtungsbegriff eingefuhrt ¨ und es wird diskutiert, wie vorhandene Refactoring-Techniken auf die UML/P ubertragen ¨ werden konnen. ¨ Schließlich wird eine additive Vorgehensweise vorgeschlagen, die großere ¨ Refactorings unter Verwendung von OCL-Invarianten unterstutzt. ¨
1.4 Notationelle Konventionen In diesem Buch werden mehrere Diagrammarten und textuelle Notationen genutzt. Damit sofort erkennbar ist, welches Diagramm oder welche textuelle Notation jeweils dargestellt ist, wird abweichend von der UML 2.0 rechts oben eine Marke in einer der in Abbildung 1.3 dargestellten Formen angegeben. Diese Form ist auch zur Markierung textueller Teile geeignet und flexibler als die UML 2.0-Markierung. Eine Marke wird einerseits als Orientierungshilfe und andererseits als Teil der UML/P eingesetzt, da ihr der Name des Diagramms und Diagramm-Eigenschaften in Form von Stereotypen beigefugt ¨ werden konnen. ¨ Vereinzelt kommen Spezialformen von Marken zum Einsatz, die weitgehend selbsterkl¨arend sind. Die textuellen Notationen wie Java-Code, OCL-Beschreibungen und textuelle Teile in Diagrammen basieren ausschließlich auf dem ASCII-Zeichensatz. Zur besseren Lesbarkeit werden einzelne Schlusselw ¨ orter ¨ hervorgehoben oder unterstrichen. Im Text werden folgende Sonderzeichen genutzt: • •
c “ sind formaler Teil der Die Repr¨asentationsindikatoren . . .“ und ” ” UML/P und beschreiben, ob die in einem Diagramm dargestellte Repr¨asentation vollst¨andig ist. Stereotypen werden in der Form Stereotypname angegeben. Merkmale haben die Form {Merkmalsname=Wert} oder {Merkmalsname}.
8
1 Einfuhrung ¨
Abbildung 1.3. Marken fur ¨ Diagramme und Textteile
Danksagung Wie auch an Band 1 haben an der Erstellung dieses Buchs eine Reihe von Personen direkt oder indirekt mitgewirkt. Neben einem Verweis auf die Danksagung von Band 1 mochte ¨ ich insbesondere meinen Kolleginnen und Kollegen an der Technischen Universit¨at Braunschweig fur ¨ die freundliche Aufnahme sowie meinen Mitarbeiterinnen und Mitarbeitern fur ¨ die hervorragende Unterstutzung ¨ bei der Fertigstellung dieses Buchs bedanken. Im Kontext des gerade in Aufbau befindlichen neuen Instituts fur ¨ Software Systems Engineering ist es durchaus ambitioniert zwei Bucher ¨ parallel zu einer Reihe neuer Vorlesungen, Seminaren und Praktika fertigzustellen.
2 ¨ Kompakte Ubersicht zur UML/P
Die Grenzen meiner Sprache sind die Grenzen meiner Welt. Ludwig Wittgenstein
Dieses Kapitel beinhaltet eine kompakte Zusammenfassung der in Band 1 [Rum04c] eingefuhrten ¨ UML/P. Diese Zusammenfassung beschreibt einige, aber nicht alle Besonderheiten und Abweichungen des UML/P-Profils vom UML 2.0 Standard. Fur ¨ eine genauere Lekture ¨ sei Band 1 empfohlen. Kenner der UML konnen ¨ dieses Kapitel bei Bedarf sp¨ater nachschlagen. Die verwendeten Beispiele zur Einfuhrung ¨ der Sprache beziehen sich im Wesentlichen auf die in Band 1 beschriebene Auktionssystem-Anwendung.
2.1 2.2 2.3 2.4 2.5
Klassendiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Object Constraint Language . . . . . . . . . . . . . . . . . . . . . . . . . . Objektdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Statecharts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sequenzdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10 15 28 33 44
10
¨ 2 Kompakte Ubersicht zur UML/P
2.1 Klassendiagramme Klassendiagramme bilden das architekturelle Ruckgrat ¨ vieler Systemmodellierungen. Dementsprechend haben Klassendiagramme und darin besonders Klassen eine Reihe von Aufgaben zu erfullen ¨ (Abbildung 2.1): Klassendiagramme beschreiben die Struktur beziehungsweise Architektur eines Systems, auf der nahezu alle anderen Beschreibungstechniken basieren. Das Konzept Klasse ist durchg¨angig in Modellierung und Programmierung eingesetzt und bietet daher ein Ruckgrat ¨ fur ¨ Traceability von Anforderungen und Fehlern entlang der verschiedenen Aktivit¨aten eines Projekts. Klassendiagramme bilden das Skelett fur ¨ fast alle weiteren Notationen und Diagrammarten, da diese sich jeweils auf die in Klassendiagrammen definierten Klassen und Methoden stutzen. ¨ So werden in der Analyse Klassendiagramme genutzt, um Konzepte der realen Welt zu strukturieren, w¨ahrend in Entwurf und Implementierung Klassendiagramme vor allem zur Darstellung einer strukturellen Sicht des Softwaresystems genutzt werden. Die Aufgaben einer Klasse sind: • • • • • • •
Kapselung von Attributen und Methoden zu einer konzeptuellen Einheit Auspr¨agung von Instanzen als Objekte Typisierung von Objekten Implementierungsbeschreibung Klassencode (die ubersetzte, ¨ ausfuhrbare ¨ Form der Implementierungsbeschreibung) Extension (Menge aller zu einem Zeitpunkt existierenden Objekte) Charakterisierung der mo¨ glichen Strukturen eines Systems Abbildung 2.1. Aufgabenvielfalt einer Klasse
2.1.1 Klassen und Vererbung Die Abbildung 2.2 enth¨alt eine Einordnung der wichtigsten Begriffe fur ¨ Klassendiagramme. In Abbildung 2.3 ist ein einfaches Klassendiagramm bestehend aus einer Klasse zu sehen. Je nach Grad der Detaillierung konnen ¨ Attribute und Methoden der Klassen weggelassen oder nur teilweise angegeben werden. Auch Typen von Attributen und Methoden, Sichtbarkeitsangaben und weitere Modifikatoren sind optional. Zur Strukturierung von Klassen in uberschaubare ¨ Hierarchien wird die Vererbungsbeziehung eingesetzt. Abbildung 2.4 demonstriert Vererbung und Interface-Implementierung anhand der Gemeinsamkeiten mehrerer Nachrichtenarten des in Kapitel D, Band 1 beschriebenen Auktionssystems. Die Erweiterung von Interfaces ist darin nicht abgebildet. Sie wird wie die Vererbung zwischen Klassen dargestellt.
2.1 Klassendiagramme
11
Klasse. Eine Klasse besteht aus einer Sammlung von Attributen und Methoden, die den Zustand und das Verhalten ihrer Instanzen (Objekte) festlegt. Klassen sind durch Assoziationen und Vererbungsbeziehungen miteinander verknupft. ¨ Ein Klassenname erlaubt es, die Klasse zu identifizieren. Attribut. Die Zustandskomponenten einer Klasse werden als Attribute bezeichnet. Sie beinhalten grunds¨atzlich Name und Typ. Methode. Die Funktionalit¨at einer Klasse ist in Methoden abgelegt. Eine Methode besteht aus einer Signatur und einem Rumpf, der die Implementierung beschreibt. Bei einer abstrakten Methode fehlt der Rumpf. Modifikator. Zur Festlegung von Sichtbarkeit, Instanziierbarkeit und Ver¨anderbarkeit des modifizierten Elements konnen ¨ die Modifikatoren public, protected, private, readonly, abstract, static und final auf Klassen, Methoden und Attribute angewandt werden. Fur ¨ die ersten vier genannten Modifikatoren gibt es in UML/P die graphischen Varianten +“, #“ und -“ ” ” ” und ?“. ” Konstanten sind als spezielle Attribute mit den Modifikatoren static und final definiert. Vererbung. Stehen zwei Klassen in Vererbungsbeziehung, so vererbt die Oberklasse ihre Attribute und Methoden an die Unterklasse. Die Unterklasse kann weitere Attribute und Methoden hinzufugen ¨ und Methoden redefinieren – soweit die Modifikatoren dies erlauben. Die Unterklasse bildet einen Subtyp der Oberklasse, der es nach dem Substitutionsprinzip erlaubt, Instanzen der Unterklasse dort einzusetzen, wo Instanzen der Oberklasse erforderlich sind. Interface. Ein Interface (Schnittstelle) beschreibt die Signaturen einer Sammlung von Methoden. Im Gegensatz zur Klasse werden keine Attribute (nur Konstanten) und keine Methodenrumpfe ¨ angegeben. Interfaces sind verwandt zu abstrakten Klassen und konnen ¨ untereinander ebenfalls in einer Vererbungsbeziehung stehen. Typ ist ein Grunddatentyp wie int, eine Klasse oder ein Interface. Interface-Implementierung ist eine der Vererbung a¨ hnliche Beziehung zwischen einem Interface und einer Klasse. Eine Klasse kann beliebig viele Interfaces implementieren. Assoziation ist eine bin¨are Beziehung zwischen Klassen, die zur Realisierung struktureller Information verwendet wird. Eine Assoziation besitzt einen Assoziationsnamen, fur ¨ jedes Ende einen Rollennamen, eine Kardinalit¨at und eine Angabe uber ¨ die Navigationsrichtungen. Kardinalit¨at. Die Kardinalit¨at (Multiplicity) wird fur ¨ jedes Assoziationsende angegeben. Sie ist von der Form 0..1“, 1“ oder *“ und beschreibt, ob eine Asso” ” ” ziation in dieser Richtung optional oder eindeutig ist beziehungsweise mehrfache Bindung erlaubt. Abbildung 2.2. Begriffsdefinition fur ¨ Klassendiagramme
2.1.2 Assoziationen Eine Assoziation dient dazu, Objekte zweier Klassen in Beziehung zu setzen. Mithilfe von Assoziationen konnen ¨ komplexe Datenstrukturen gebildet werden und Methoden benachbarter Objekte aufgerufen werden. Abbildung 2.5
12
¨ 2 Kompakte Ubersicht zur UML/P
Abbildung 2.3. Eine Klasse im Klassendiagramm
Abbildung 2.4. Vererbung und Interface-Implementierung
beschreibt einen Ausschnitt aus dem Auktionssystem mit mehreren Assoziationen in unterschiedlichen Formen. Eine Assoziation besitzt im Normalfall einen Assoziationsnamen und fur ¨ jedes der beiden Enden je eine Assoziationsrolle, eine Angabe der Kardinalit¨at und eine Beschreibung der moglichen ¨ Navigationsrichtungen. Einzelne Angaben konnen ¨ im Modell auch weggelassen werden, wenn sie zur Darstellung des gewunschten ¨ Sachverhalts keine Rolle spielen und die Eindeutigkeit nicht verloren geht. Assoziationen konnen ¨ grunds¨atzlich uni- oder bidirektional sein. Ist keine explizite Pfeilrichtung angegeben, so wird von einer bidirektionalen Assoziation ausgegangen. Formal werden die Navigationsmoglichkeiten ¨ in dieser Situation als unspezifiziert und damit nicht als eingeschr¨ankt betrachtet.
2.1 Klassendiagramme
13
Abbildung 2.5. Klassendiagramm mit Assoziationen
Eine besondere Form der Assoziation ist die Komposition. Sie wird durch eine ausgefullte ¨ Raute an einem Assoziationsende dargestellt. In einer Komposition sind die Teilobjekte in einer starken auch den Lebenszyklus betreffenden Abh¨angigkeit vom Ganzen. Der UML-Standard bietet eine Reihe zus¨atzlicher Merkmale fur ¨ Assoziationen an, die Assoziationseigenschaften genauer regeln. Abbildung 2.6 beinhaltet einige h¨aufig eingesetzte Merkmale, wie zum Beispiel {ordered}, das einen geordneten Zugriff mit Index erlaubt. Mit {frozen} wird angezeigt, dass nach der Initialisierung eines Auktionsobjekts die beiden Assoziationen zu den Policy-Objekten nicht mehr ver¨andert werden. Mit {addOnly} wird modelliert, dass in der Assoziation nur Objekte hinzugefugt ¨ werden durfen, ¨ das Entfernen jedoch verboten ist.
Abbildung 2.6. Merkmale fur ¨ Assoziationen
Qualifizierte Assoziation bieten die Moglichkeit, ¨ aus einer Menge von zugeordneten Objekten mithilfe des Qualifikators ein einzelnes Objekt zu selektieren. Abbildung 2.7 zeigt mehrere auf unterschiedliche Weise qualifizierte Assoziationen. W¨ahrend in explizit qualifizierten Assoziationen die Art des Qualifikators w¨ahlbar ist, stehen in geordneten Assoziationen ganzzahlige Intervalle beginnend mit der 0 zur Verfugung. ¨
14
¨ 2 Kompakte Ubersicht zur UML/P
Abbildung 2.7. Qualifizierte Assoziationen
2.1.3 Repr¨asentation und Stereotypen Klassendiagramme haben oft das Ziel, die fur ¨ eine bestimmte Aufgabe notwendige Datenstruktur einschließlich ihrer Zusammenh¨ange zu beschrei¨ ben. Eine vollst¨andige Liste aller Methoden und Attribute ist fur ¨ einen Uberblick dabei eher hinderlich. Ein Klassendiagramm stellt daher meist eine unvollst¨andige Sicht des Gesamtsystems dar. So konnen ¨ einzelne Klassen oder Assoziationen fehlen. Innerhalb der Klassen ko¨ nnen Attribute und Methoden weggelassen oder unvollst¨andig dargestellt werden.
Abbildung 2.8. Formen der Darstellung einer Klasse
Um einem UML-Diagramm anzusehen, ob die darin enthaltene Information vollst¨andig ist, werden in UML/P die Repr¨asentationsindikatoren
2.2 Object Constraint Language
15
c “ zur Darstellung . . .“ zur Markierung unvollst¨andiger Information und ” ” vollst¨andiger Information verwendet (Abbildung 2.8). c “ und . . .“ wirken nicht auf die Klasse selbst, sonDie Indikatoren ” ” c “ beim dern auf ihre Darstellung innerhalb des Klassendiagramms. Ein ” Klassennamen besagt, dass sowohl die Attribut- als auch die Methodenliste vollst¨andig ist. Demgegenuber ¨ bedeutet der Unvollst¨andigkeits-Indikator . . .“, dass die Darstellung unvollst¨andig sein kann. ” Die beiden Repr¨asentationsindikatoren sind nur eine spezielle From von Merkmalen mit eigener syntaktischer Darstellung. Die UML bietet sehr allgemein die Moglichkeit, ¨ Modellelemente mit Stereotypen und Merkmalen zu markieren (Abbildung 2.9), die deren allgemeine Syntax die Formen stereotyp, {merkmal} oder {merkmal=wert} hat. Stereotyp. Ein Stereotyp klassifiziert Modellelemente wie beispielsweise Klassen oder Attribute. Durch einen Stereotyp wird die Bedeutung des Modellelements spezialisiert und kann so beispielsweise bei der Codegenerierung spezifischer behandelt werden. Ein Stereotyp kann eine Menge von Merkmalen besitzen. Merkmal. Ein Merkmal beschreibt eine Eigenschaft eines Modellelements. Ein Merkmal wird notiert als Paar bestehend aus Schlusselwort ¨ und Wert. Mehrere solche Paare konnen ¨ zu einer Liste zusammengefasst werden. Modellelemente sind die (wesentlichen) Bausteine der UML-Diagramme. Beispielsweise hat das Klassendiagramm als Modellelemente Klassen, Interfaces, Attribute, Methoden, Vererbungsbeziehungen und Assoziationen. Merkmale und Stereotypen konnen ¨ auf Modellelemente angewandt werden, sind aber selbst keine Modellelemente. Abbildung 2.9. Begriffsdefinition Merkmal und Stereotyp
2.2 Object Constraint Language Die Object Constraint Language (OCL) ist eine eigenschaftsorientierte Modellierungssprache, die eingesetzt wird, um Invarianten sowie Vor- und Nachbedingungen von Methoden zu modellieren. Die in der UML/P enthaltene OCL/P ist eine syntaktsich an Java angepasste und erweiterte Variante des OCL-Standards. ¨ 2.2.1 Ubersicht uber ¨ OCL/P Abbildung 2.10 erl¨autert die wichtigsten Begriffe der OCL. Eines der herausragenden Merkmale von OCL-Bedingungen ist ihre grunds¨atzliche Einbettung in einen Kontext, bestehend aus UML-Modellen. Das Klassendiagramm in Abbildung 2.11 stellt einen solchen Kontext bereit, in dem zum Beispiel folgende Aussage formuliert werden kann:
16
¨ 2 Kompakte Ubersicht zur UML/P
Bedingung. Eine Bedingung ist eine boolesche Aussage uber ¨ ein System. Sie beschreibt eine Eigenschaft, die ein System oder ein Ergebnis besitzen soll. Ihre Interpretation ergibt grunds¨atzlich einen der Wahrheitswerte true oder false. Kontext. Eine Bedingung ist in einen Kontext eingebettet, uber ¨ den sie Aussagen macht. Der Kontext wird definiert durch eine Menge von in der Bedingung verwendbaren Namen und ihren Signaturen. Dazu geh¨oren Klassen-, Methodenund Attributnamen des Modells und insbesondere im Kontext einer Bedingung explizit eingefuhrte ¨ Variablen. Interpretation einer Bedingung wird anhand einer konkreten Objektstruktur vorgenommen. Dabei werden die im Kontext eingefuhrten ¨ Variablen mit Werten beziehungsweise Objekten belegt. Invariante beschreibt eine Eigenschaft, die in einem System zu jedem (beobachteten) Zeitpunkt gelten soll. Die Beobachtungszeitpunkte konnen ¨ eingeschr¨ankt sein, um zeitlich begrenzte Verletzungen zum Beispiel w¨ahrend der Ausfuhrung ¨ einer Methode zu erlauben. Vorbedingung einer Methode charakterisiert die Eigenschaften, die gelten mussen, ¨ damit diese Methode ein definiertes und sinnvolles Ergebnis liefert. Ist die Vorbedingung nicht erfullt, ¨ so wird uber ¨ das Ergebnis keine Aussage getroffen. Nachbedingung einer Methode beschreibt, welche Eigenschaften nach Ausfuhrung ¨ der Methode gelten. Dabei kann auf Objekte in dem Zustand zuruckgegriffen ¨ werden, der unmittelbar vor dem Methodenaufruf (zur Zeit“ der Interpreta” tion der Vorbedingung) gultig ¨ war. Nachbedingungen werden anhand zweier Objektstrukturen interpretiert, die die Situationen vor und nach dem Methodenaufruf darstellen. Methodenspezifikation ist ein Paar bestehend aus Vor- und Nachbedingung. Query ist eine von der Implementierung angebotene Methode, deren Aufruf keine Ver¨anderung des Systemzustands hervorruft. Es durfen ¨ neue Objekte als Aufrufergebnis erzeugt werden. Allerdings durfen ¨ diese nicht mit dem Systemzustand durch Links verbunden sein. Dadurch sind Queries ohne Seiteneffekte und konnen ¨ in OCL-Bedingungen verwendet werden. Abbildung 2.10. Begriffsdefinitionen zur OCL
Abbildung 2.11. Ausschnitt des Auktionssystems
OCL
context Auction a inv Bidders2: a.activeParticipants == { p in a.bidder | p.isActive }.size
2.2 Object Constraint Language
17
Die Aussage mit dem Namen Bidders2 wird quantifiziert uber ¨ alle Objekte a der Klasse Auktion. Darin enthalten sind Navigationsausdrucke ¨ wie a.bidder, die es erlauben uber ¨ Assoziationen zu navigieren. Eine Mengenkomprehension {p in ...| ...} selektiert alle aktiven Personen einer Auktion. Diese Mengenkomprehension ist eine komfortable Erweiterung gegenuber ¨ dem OCL-Standard. Sie wird sp¨ater in mehreren Formen ausfuhrli¨ cher besprochen. Wird in einem Kontext statt einem expliziten Namen nur die Klasse festgelegt, so wird implizit der Name this als vereinbart angenommen. In diesem Fall kann auf Attribute auch direkt zugegriffen werden. Geschlossene Bedingungen besitzen einen leeren Kontext: inv: forall a in Auction: a.startTime <= Time.now() implies a.numberOfBids == 0
OCL
Mithilfe des let-Konstrukts konnen ¨ Zwischenergebnisse einer Hilfsvariablen zugewiesen werden, um diese im Rumpf des Konstrukts gegebenenfalls mehrfach zu nutzen: context inv SomeArithmeticTruth: let middle = (a+b)/2 in a<=b implies a<=middle and
OCL
middle<=b
Das let-Konstrukt kann auch dazu genutzt werden, Hilfsfunktionen zu vereinbaren: context Auction a inv Time2: let min(Time x, Time y) = (x<=y) ? x : y in min(a.startTime, min(a.closingTime,a.finishTime)) == a.startTime
OCL
Wie bereits gesehen, kann die Fallunterscheidung .?.:. aber auch die verbose, a¨ quivalente Fassung if-then-else eingesetzt werden. Im Gegensatz zur imperativen Fallunterscheidung sind immer der then- und der else-Zweig anzugeben. Eine spezielle Form der Fallunterscheidung erlaubt die Behandlung von Typkonversionen, wie sie bei Subtyphierarchien gelegentlich auftreten. OCL/P bietet dafur ¨ eine typsichere Konstruktion an, die eine Kombination einer Typkonversion und einer Abfrage nach dessen Konvertierbarkeit darstellt: OCL
context Message m inv: let Person p = m instanceof BidMessage ? m.bidder : null in ...
18
¨ 2 Kompakte Ubersicht zur UML/P
Zus¨atzlich zu einer normalen Fallunterscheidung wird im then-Zweig der Fallunterscheidung der Typ der Variable m auf den Subtyp gesetzt und ermoglicht ¨ dadurch die Selektion m.bidder. Die Typsicherheit bleibt trotz Konversion erhalten. Als Grunddatentypen stehen die aus Java bekannten Sorten boolean, char, int, long, float, byte, short und double und darauf arbeitende Operatoren ohne Seiteffekte zur Verfugung. ¨ Ausgeschlossen sind damit die Inkrementoperatoren ++ und -- sowie alle Zuweisungsformen. Neu sind die booleschen Operatoren implies und <=>, die zur Darstellung von Im¨ plikationen und Aquivalenzen dienen, und die Postfixoperatoren @pre und **. Priorit¨at Operator
Assoziativit¨at Operand(en), Bedeutung
14
links links rechts rechts rechts links links links links links links links links links links links links links links rechts
13
12 11 10 9
8 7 6 5 4 3 2,7 2,3 2
@pre ** +, -, ˜ ! (type) *, /, % +, <<, >>, >>> <, <=, >, >= instanceof in ==, != & ˆ | && || implies <=> ? :
Wert des Ausdrucks in der Vorbedingung Transitive Hulle ¨ einer Assoziation Zahlen Boolean: Negation Typkonversion (Cast) Zahlen Zahlen, String (+) Shifts Vergleiche Typvergleich Element von Vergleiche Zahlen, Boolean: striktes und Zahlen, Boolean: xor Zahlen, Boolean: striktes oder Boolesche Logik: und Boolesche Logik: oder Boolesche Logik: impliziert Boolesche Logik: a¨ quivalent Auswahlausdruck (if-then-else)
Tabelle 2.12: Prioritäten der OCL-Operatoren
Der Datentyp String wird wie in Java nicht als Grunddatentyp, sondern als standardm¨aßig zur Verfugung ¨ stehende Klasse verstanden. 2.2.2 Die OCL-Logik Die richtige Definition der einer Bedingungssprache zugrunde liegenden Logik ist fur ¨ einen praxistauglichen Einsatz der Sprache wichtig. Deshalb wurde fur ¨ OCL/P eine zweiwertige Logik und ein spezieller Umgang mit dem
2.2 Object Constraint Language
19
problematischen Undefined“ gew¨ahlt. Eine detaillierte Diskussion dieser ” Aspekte ist in Band 1 zu finden. Fur ¨ die Logik ist die Abbildung des undefinierten Werts auf den Wahrheitswert false am elegantesten, weil damit eine zweiwertige Logik entsteht. Sowohl Spezifikationen als auch Beweisfuhrungen ¨ werden dadurch besonders einfach, weil ein dritter Fall nicht existiert. Unglucklicherweise ¨ ist diese, fur ¨ die Spezifikation so angenehme Semantik nicht vollst¨andig implementierbar, da zu bestimmen w¨are, ob eine Berechnung nicht terminiert, und dann der Wert false auszugeben w¨are.1 Dennoch ist die gew¨ahlte Form praktikabel (siehe Band 1). Die Wahrheitstabellen der OCL-Operatoren mit dieser impliziten Abbildung von undef auf false sind in Abbildung 2.13 festgelegt.
Abbildung 2.13. Interpretationen der booleschen Operatoren
2.2.3 Container-Datenstrukturen Container sind die Grundlage der in der OCL so wichtigen Navigation uber ¨ Assoziationen. Ausgehend von einem einzelnen Objekt konnen ¨ durch einen Navigationsausdruck eine Menge oder eine Liste von erreichbaren Objekten beschrieben und ihren Elementen gewisse Eigenschaften zugeordnet werden. Die OCL/P bietet drei Typkonstruktoren fur ¨ Container an (Abbildung 2.14). Fur ¨ einen Vergleich von Containern ist eine bin¨are Operation notwendig, die auf den Elementen einen Test auf Gleichheit durchfuhrt. ¨ Sind die Elemente Grunddatentypen oder wieder Container, dann wird fur ¨ die Elemente der Vergleich == verwendet. Sind die Elemente aber Objekte, so wird der Vergleich equals eingesetzt. Das entspricht einem Wertevergleich fur ¨ Grunddatentypen und Container sowie normalerweise einem Vergleich der 1
Das Terminierungsproblem ist jedoch unentscheidbar.
20
¨ 2 Kompakte Ubersicht zur UML/P
Set(X) beschreibt Mengen uber ¨ einem Datentyp X. Auf diesen Mengen stehen die ublichen ¨ Operatoren wie Vereinigung oder Hinzufugen ¨ zur Verfugung. ¨ Fur ¨ den Typ X kann jeder Grunddatentyp, jede Klasse und jeder Containertyp eingesetzt werden. Als Vergleich werden Wertevergleich fur ¨ Grunddatentypen und die Objektidentit¨at fur ¨ Klassen verwendet. Allerdings konnen ¨ Objekte ausgew¨ahlter Klassen wie zum Beispiel String den Vergleich equals nutzen und uber¨ schreiben und damit ebenfalls einen Wertevergleich uber ¨ ihre Attribute anbieten. List(X) beschreibt geordnete Listen und die dafur ¨ sinnvollen Operationen. List(X) erlaubt die Verwaltung ihrer Objekte in einer linearen Ordnung, beginnend bei dem Index 0. Collection(X) ist ein Supertyp fur ¨ die beiden genannten Typen Set(X) und List(X). Er beinhaltet deren gemeinsame Funktionalit¨at. Abbildung 2.14. Typkonstruktoren der OCL
Objektidentit¨at auf Objekten. Fur ¨ spezielle Objekttypen, wie zum Beispiel String, wird jedoch equals uberschrieben ¨ und damit ein Wertevergleich angeboten. Die Subtypbeziehung von Set(X) und List(X) zu Collection(X) erlaubt es, fur ¨ jeden beliebigen Typ X statt Werten des Typs Collection(X) Werte der Typen Set(X) oder List(X) einzusetzen. Die Aufschreibung von Mengen und Listen basiert im Wesentlichen auf der Extension von Klassen, Mengenkomprehensionen und Navigationsausdrucken: ¨ Auction.size < 1700; Set{}; Set{"text",""} == {"text",""}; List{8,5,8}; List{’a’..’c’} == List{’a’,’b’,’c’};
OCL
Mengen- und Listenkomprehension OCL/P bietet gegenuber ¨ dem OCL-Standard eine funktionalen Sprachen entlehnte reichhaltige Sammlung von Moglichkeiten ¨ zur eigenschaftsorientierten und zur aufz¨ahlenden Beschreibung von Mengen und Listen. Die allgemeine Syntax einer Listenkomprehension ist von der Form: List{ expr | characterization }
OCL
Dabei werden in der Charakterisierung (rechts) neue Variablen definiert, die in dem Ausdruck (links) genutzt werden konnen. ¨ Die Charakterisierung besteht deshalb aus mehreren, durch Kommata getrennten Generatoren, Filtern und lokalen Variablendefinitionen. Ein Generator v in list l¨asst eine neue Variable v uber ¨ einer Liste list variieren. Beispielsweise konnen ¨ so Quadratzahlen beschrieben werden:
2.2 Object Constraint Language inv: List{ x*x | x in List{1..5} } == List{1,4,9,16,25}
21 OCL
Der Filter beschreibt eine Einschr¨ankung auf einer Liste von Elementen. Ein solcher Filter evaluiert zu einem Wahrheitswert, der daruber ¨ entscheidet, ob ein Element in einer Liste aufgenommen ist. In Kombination mit einem Generator konnen ¨ so Filter fur ¨ Teillisten beschrieben werden: OCL
inv: List{ x*x | x in List{1..8}, !even(x) } == List{1,9,25,49}
Zur weiteren Unterstutzung ¨ des Beschreibungskomforts ko¨ nnen Zwischenergebnisse berechnet und lokalen Variablen zugewiesen werden. inv: List{ y | x in List{1..8}, int y = x*x, !even(y) } == List{1,9,25,49}
OCL
Container-Operationen Mengen, Listen und Container allgemein besitzen die in den Abbildungen 2.15, 2.16 und 2.17 aufgelisteten Operationen. Deren Signatur stellt eine Integration der aus der Java-Realisierung von Mengen bekannten und der vom OCL-Standard angebotenen Funktionalit¨at dar. Die Operationen size, isEmpty und asList konnen ¨ in OCL wie Attribute ohne Klammern geschrieben werden, denn eine Query ohne Argumente kann grunds¨atzlich wie ein Attribut behandelt werden. Eine Schreibweise als Query mit Klammern ist wegen der Kompatibilit¨at zu Java ebenfalls moglich. ¨ Set(X) Set(X) boolean boolean int boolean Set(X) Set(X) Set(X) Set(X) int X List(X)
add(X o); Signatur addAll(Collection(X) c); contains(X o); containsAll(Collection(X) c); count(X o); isEmpty; remove(X o); removeAll(Collection(X) c); retainAll(Collection(X) c); symmetricDifference(Set(X) s); size; flatten; // NB: X ist ein Collection-Typ asList; Abbildung 2.15. Signatur von Mengen des Typs Set(X)
Im Gegensatz zu einer Java-Implementierung ist fur ¨ OCL-Ausdrucke ¨ das Konzept der Exceptions nicht vorhanden. Stattdessen sind alle Operatoren
22
¨ 2 Kompakte Ubersicht zur UML/P
der OCL robust, so dass ihre Interpretation immer sinnvolle Ergebnisse ergibt. List(X) List(X) List(X) List(X) List(X) boolean boolean X X X List(X) int int boolean int List(X) List(X) List(X) List(X) List(X) int List(X) List(Y) Set(X)
add(X o); Signatur add(int index, X o); prepend(X o); addAll(Collection(X) c); addAll(int index, Collection(X) c); contains(X o); containsAll(Collection(X) c); get(int index); first; last; rest; indexOf(X o); lastIndexOf(X o); isEmpty; count(X o); remove(X o); removeAtIndex(int index); removeAll(Collection(X) c); retainAll(Collection(X) c); set(int index, X o); size; subList(int fromIndex, int toIndex); flatten; // NB: X hat die Form Collection(Y) asSet; Abbildung 2.16. Signatur von Listen des Typs List(X)
Weil in der OCL Container keine Objektidentit¨at besitzen, sind auf Containern beide Gleichheits-Operatoren == und equals identisch: context Set(X) sa, Set(X) sb inv: sa.equals(sb) <=> sa==sb
OCL
Bei dem Vergleich von Mengen wird, wie bereits besprochen, auf den Vergleich der Elemente equals fur ¨ Objekte und == fur ¨ Grunddatentypen zuruckgegriffen. ¨ In der OCL ist == fur ¨ Container von Objekten von der frei definierbaren Gleichheit equals auf den Elementen abh¨angig und unterscheidet sich von dem Vergleich in Java. Fur ¨ Listen sicher ungewohnlich, ¨ aber fur ¨ praktische Belange angenehm, da systematischer, ist die aus Java bekannte Indizierung der Listenelemente beginnend mit 0: List{0,1,2}.add(3) List{’a’,’b’,’c’}.add(1,’d’)
== List{0,1,2,3}; == List{’a’,’d’,’b’,’c’};
OCL
2.2 Object Constraint Language
23
List{0,1,2}.prepend(3) == List{3,0,1,2}; List{0,1,2}.set(1,3) == List{0,3,2}; List{0,1,2}.get(1) == 1; List{0,1,2}.first == 0; List{0,1,2}.last == 2; List{0,1,2}.rest == List{1,2}; List{0,1,2,1}.remove(1) == List{0,2}; List{0,1,2,3}.removeAtIndex(1) == List{0,2,3}; List{0,1,2,3,2,1}.removeAll(List{1,2}) == List{0,3}; List{0..4}.subList(1,3) == List{1,2};
Collection(X) Collection(X) boolean boolean boolean int Collection(X) Collection(X) Collection(X) int Collection(Y) List(Y) Set(X) List(X)
add(X o); Signatur addAll(Collection(X) c); contains(X o); containsAll(Collection(X) c); isEmpty; count(X o); remove(X o); removeAll(Collection(X) c); retainAll(Collection(X) c); size; flatten; // NB: X hat die Form Collection(Y) oder Set(Y) flatten; // NB: X hat die Form List(Y) asSet; asList;
Abbildung 2.17. Signatur von Containern des Typs Collection(X)
Tief geschachtelte Container-Strukturen enthalten eine gewisse Strukturierungsinformation, die in manchen F¨allen zur Spezifikation von Systemen hilfreich ist. So kann mit dem Typ Set(Set(Person)) eine Gruppierung von Mengen von Personen beschrieben werden. let Set(Set(Person)) ssp = { a.bidder | a in Auction } in ...
OCL
Der Operator flatten erlaubt es, solche Container-Strukturen großerer ¨ Schachtelungstiefe flach zu drucken. ¨ Der flatten-Operator verschmilzt die beiden oberen“ Ebenen von ” Containern, ohne sich um die interne Struktur des darin verborgenen Elementtyps X zu kummern. ¨ Man spricht auch von schmalem (engl.: shallow) Flachdrucken. ¨ Eine genaue Beschreibung dazu ist in Band 1 zu finden. Bei Navigationsketten wird der flatten-Operator implizit eingesetzt, so dass das Ergebnis einer Navigationskette nie eine Container-Struktur darstellt, die tiefer verschachtelt ist als die Ausgangsstruktur. Einzige Ausnah-
24
¨ 2 Kompakte Ubersicht zur UML/P
me bildet die Navigationskette ausgehend von einem einzelnen Objekt, die je nach Form der Assoziation zu einer Menge oder Sequenz fuhren ¨ kann.
Abbildung 2.18. Abstraktes Modell zur Erkl¨arung von Navigationsergebnissen
Ausgehend von einem einfachen Objekt h¨angt das Ergebnis von der Kardinalit¨at der Assoziation gem¨aß Abbildung 2.18 ab: let Auction a Policy po Set(Person) spe List(Message) lm in ...
= = = =
...; a.policy; a.person; a.message
OCL
Quantoren und spezielle Operationen Die beiden Quantoren forall und exists erlauben die Beschreibung einer Eigenschaft, uber ¨ alle Elemente einer Gruppe beziehungsweise wenigstens einem der Elemente. In einigen vorhergehenden Beispielen wurde bereits gezeigt, wie Quantoren eingesetzt werden, um uber ¨ die Elemente eines Containers Aussagen zu formulieren. Quantoren konnen ¨ uber ¨ mehrere Variablen kombiniert werden: inv Nachrichten1: forall a in Auction, p in Person, m in a.message: p in a.bidder implies m in p.message
OCL
Der dritte Quantor dieses Beispiels zeigt, dass die Ausgangsmenge, uber ¨ die quantifiziert wird, nicht nur die Extension einer Klasse, sondern ein beliebiger mengen- oder listenwertiger Ausdruck sein kann. Der Existenzquantor ist dual zum Allquantor: inv: (exists var in setExpr: expr) <=> !(forall var in setExpr: !expr)
OCL
Beide Quantoren werden meist nur auf endliche Container oder Extensionen angewandt. Dies hat den Vorteil der (zumindest prinzipiellen) Berechenbarkeit, indem die quantifizierte Variable mit allen Werten beziehungsweise
2.2 Object Constraint Language
25
Objekten belegt und der Rumpf damit interpretiert wird. Fur ¨ die quantifizierte Menge ist wesentlich, dass den Klassen, wie zum Beispiel Person, die Extension in Form aller aktuell existierenden Objekte zugeordnet wird, die zwar unbeschr¨ankt aber endlich ist. Neben endlichen Mengen von Objekten erlaubt die OCL/P auch die Benutzung von Quantoren uber ¨ unendlichen Grunddatentypen wie zum Beispiel int und ist hier naturlich ¨ unberechenbar. Bei Mengen und Listen wird ebenfalls uber ¨ potentielle (und nicht die gerade im System befindlichen Mengen-Implementierungen) quantifiziert. Die Aussage inv ListQuantor: forall Set(Person) lp: lp.size != 5
OCL
interpretiert die Variable lp uber ¨ alle potentiellen Listen uber ¨ die tats¨achlich zu einem Zeitpunkt existierenden Objekte. Damit ist eine Quantifizierung uber ¨ Set(Person) eine Kombination der Interpretation eines unendlichen Quantors auf einem Grunddatentyp und einem endlichen Quantor uber ¨ den darin befindlichen Referenztyp. Entsprechend sind Quantoren uber ¨ Listen unendlich und konnen ¨ daher nur zur Spezifikation eingesetzt werden. Da die Potenzmenge einer endlichen Menge ebenfalls endlich ist, ist die obige Quantifizierung uber ¨ Set(Person) endlich und sogar erfull¨ bar. Fur ¨ die Selektion eines Elements aus einer Container-Struktur gibt es den speziellen Operator any. Dieser Operator ist fur ¨ Mengen nicht eindeutig festgelegt, wie die folgenden definierenden Gleichungen zeigen: (any listExpr) == listExpr.get(0); (any setExpr) == any setExpr.asList; (any var in collection: expr) == any { var in collection | expr }
OCL
Fur ¨ eine elementweise Bearbeitung von Mengen und Listen gibt es neben den Komprehensionsformen den iterate-Operator, der eine Schleife mit Zustandsspeicher aus der funktionalen wie auch der imperativen Programmierung nachbildet: iterate { elementVar in setExpr; Type accumulatorVar = initExpr : accumulatorVar = expr }
OCL
Der iterate-Operator kann zum Beispiel eingesetzt werden, um die Summe einer Menge von Zahlen zu berechnen: inv Summe: let int total = iterate { elem in Auction; int acc = 0 : acc = acc+elem.numberOfBids } in ...
OCL
26
¨ 2 Kompakte Ubersicht zur UML/P
Fur ¨ die Behandlung undefinierter Werte wird der defined-Operator eingefuhrt, ¨ der genau dann true liefert, wenn sein Argument definiert ist. Fur ¨ undefinierte Argumente evaluiert dieser Operator zu false: context Auction a inv: let Message mess = a.person.message[0] in defined(mess) implies ...
OCL
Ein ganz spezifisches Problem der OCL stellt die Definition transitiver Hullen ¨ uber ¨ Navigationswege dar: OCL ist eine Logik erster Ordnung und daher nicht in der Lage, eine transitive Hulle ¨ zu spezifizieren. Deshalb existiert in OCL/P ein spezieller Operator **, der auf eine Asssoziation angewandt deren Signatur beibeh¨alt. In Kombination mit Vererbung gibt es deshalb die vier in Abbildung 2.19 angegebenen F¨alle.
Abbildung 2.19. Typisierung der transitiven Hulle ¨
2.2.4 Funktionen in OCL Mithilfe von Paaren aus Vor- und Nachbedingung ko¨ nnen einerseits die Effekte von Methoden des zugrunde liegenden Modells spezifiziert werden. Umgekehrt kann das Modell Methoden fur ¨ die Spezifikation von OCLBedingungen zur Verfugung ¨ stellen. Eine solche Methode wird Query genannt und wird durch den Stereotyp query gekennzeichnet. Queries sind seiteneffektfrei im Sinne der in Band 1 beschriebenen Form. Fur ¨ die Modellierung komplexer Eigenschaften ist es oft sinnvoll oder sogar notwendig, zus¨atzliche Queries zu definieren, die jedoch nicht implementiert werden. Solche Spezifikationsqueries werden mit dem Stereotyp OCL gekennzeichnet.
2.2 Object Constraint Language
27
Methodenspezifikation Fur ¨ die Beschreibung einzelner Methoden wird eine Methodenspezifikation eingesetzt, die im Vor-/Nachbedingungstil formuliert wird. Der Kontext einer Methodenspezifikation wird durch eine Methode, der sie beinhaltenden Klasse sowie den zugehorigen ¨ Parametern festgelegt. Zwei Bedingungen, die Vorbedingung und die Nachbedingung, die beide mit Namen versehen werden konnen, ¨ charakterisieren den Effekt der Methode. Die Vorbedingung beschreibt, unter welchen Bedingungen eine Methode aufgerufen werden kann, so dass eine definierte und robust implementierte Reaktion entsteht. Die Nachbedingung charakterisiert das Ergebnis des Methodenaufrufs und die Ver¨anderungen auf dem Objektzustand. Das Methodenergebnis wird in der Nachbedingung mit result bezeichnet. Statische Methoden werden mit static markiert. In ihrem Rumpf darf wie bei einer Implementierung kein this eingesetzt werden.
Abbildung 2.20. Ausschnitt der Personenklasse
Die Nachbedingung der Methodenspezifikation kann einen expliziten Bezug auf den Zustand vor dem Methodenaufruf durch Verwendung des Postfix @pre enthalten. Methode addMessage aus Abbildung 2.20, dient dazu, bei einer Person eine weitere Nachricht hinzuzufugen: ¨ context Person.addMessage(Message m) pre: m.time >= messageList.last.time post: messageList ==
[email protected](m)
OCL
Der Operator @pre darf nur auf einzelne Attribute oder Navigationselemente angewandt werden. a@pre evaluiert zu dem Wert des Attributs a zur Zeit des Methodenaufrufs und erlaubt so den Vergleich zwischen altem und neuen Wert. Ist die Vorbedingung nicht erfullt, ¨ so ist mit der Spezifikation uber ¨ das Verhalten der Methode nichts ausgesagt. Deshalb ist es moglich ¨ eine komplexe Methode durch mehrere Spezifikationen zu beschreiben. Es wird festgelegt, dass bei uberlappenden ¨ Vorbedingungen beide Nachbedingungen zu erfullen ¨ sind. Mit dieser Kompositionstechnik lassen sich Methodenspezifikationen sogar vererben und in Subklassen spezialisieren. Details dazu lassen sich in Band 1 finden.
28
¨ 2 Kompakte Ubersicht zur UML/P
Fur ¨ komplexe Methodenspezifikationen existiert eine erweiterte Form des let-Konstrukts, das es erlaubt Variablen zu definieren, die in beiden Bedingungen belegt sind: context Class.method(parameters) let var = expression pre: ... var ... post: ... var ...
OCL
2.3 Objektdiagramme Objektdiagramme modellieren tats¨achliche Strukturen auf exemplarischer Basis. Sie sind daher besonders geeignet, statische Strukturen in eigentlich dynamischen objektorientierten Systemen oder spezielle Situationen darzustellen, die etwa als Vor- oder Nachbedingung bei Tests verwendet werden. Die Integration mit der OCL fuhrt ¨ zu einer Logik fur ¨ Objektdiagramme“, ” die einen methodisch verbesserten Einsatz von Objektdiagrammen erlaubt. Objekt im Objektdiagramm. Ein Objekt ist Instanz einer Klasse und enth¨alt die von ihr festgelegten Attribute. Diese Attribute sind mit einem Wert initialisiert (ggf. noch uninitialisiert). Im Objektdiagramm werden prototypische Objekte verwendet, um exemplarische Situationen zu illustrieren. Zwischen den im Diagramm sichtbaren prototypischen Objekten und den echten Objekten des Systems besteht normalerweise keine 1:1-Beziehung (siehe dazu auch die Diskussion in Abschnitt 5.2, Band 1). Objektname erlaubt die eindeutige Benennung des Objekts im Objektdiagramm. Als Objektname wird ein sprechender Name gew¨ahlt, der normalerweise im echten System nicht wiederzufinden ist, da dort systemspezifische Objektidentifikatoren verwendet werden. Attribut beschreibt eine Zustandskomponente eines Objekts. Ein Attribut im Objektdiagramm ist charakterisiert durch den Attributnamen, den Typ und einen konkreten Wert. Weitere Charakteristika, wie Sichtbarkeit, konnen ¨ dem Attribut angeheftet werden. In abstrakten Objektdiagrammen konnen ¨ statt konkreten Werten auch Variablennamen oder Ausdrucke ¨ eingesetzt werden, deren Inhalt im Diagramm unspezifiziert“ bleibt. Attributtyp oder -wert ko¨ nnen auch ausge” lassen werden. Link ist eine Auspr¨agung einer Assoziation zwischen zwei Objekten, deren Klassen jeweils an der Assoziation partizipieren. Navigationsrichtung, Assoziationsund Rollennamen konnen ¨ auf dem Link ebenfalls dargestellt werden. Kompositionslink ist eine Sonderform des Links, bei dem neben der reinen Verbindung weitere Abh¨angigkeiten des Teilobjekts vom Ganzen bestehen. Ein Kompositionslink ist eine Auspr¨agung einer Komposition. Abbildung 2.21. Begriffsdefinitionen fur ¨ Objektdiagramme
2.3 Objektdiagramme
29
2.3.1 Einfuhrung ¨ in Objektdiagramme Eine Kurzbeschreibung der wichtigsten Begriffe bei Objektdiagrammen ist in Abbildung 2.21 enthalten. Diese Begriffe werden nachfolgend detaillierter erkl¨art. Abbildung 2.22 zeigt ein einfaches Objektdiagramm aus dem Auktionssystem, das nur aus einem Objekt besteht. Dieses Objekt beschreibt eine Strom-Auktion.
Abbildung 2.22. Einzelnes Auktionsobjekt
Objektdiagramme sind grunds¨atzlich konform zu der durch Klassendiagramme vorgegebenen Struktur. Objektdiagramme sind Klassendiagrammen sehr a¨ hnlich, unterscheiden sich aber in einigen substantiellen Punkten und sind daher eine eigenst¨andige Notation. Objekte beinhalten Attribute, die meistens mit konkreten Werten angegeben werden. Es konnen ¨ mehrere Objekte derselben Klasse auftreten, weshalb jedes Objekt einen eigenen (gegebenenfalls anonymen) Namen hat.
Abbildung 2.23. Darstellungsformen des Auktionsobjekts
30
¨ 2 Kompakte Ubersicht zur UML/P
In einem Objektdiagramm werden keine Vererbungsbeziehungen dargestellt. Stattdessen konnen ¨ die aus Oberklassen geerbten Attribute in der Unterklasse explizit aufgelistet werden. Die Vererbungsstruktur zwischen Klassen wird also in einem Objektdiagramm expandiert“. W¨ahrend Klassendia” gramme ein drittes Feld zur Darstellung von Methoden kennen, werden Methoden im Objektdiagramm nicht aufgefuhrt. ¨ Eine Methodenliste existiert also bei Objekten im Objektdiagramm nicht. Ein Link verbindet zwei Objekte. So wie ein Objekt Instanz einer Klasse ist, so ist ein Link Instanz einer Assoziation. Abbildung 2.24 zeigt eine Objektstruktur fur ¨ eine Auktion, die mindestens die angegebenen drei Personen beinhaltet. Eine davon ist nur als Beobachter zugelassen.
Abbildung 2.24. Objektstruktur einer Auktion
Besitzt eine Assoziation an einem Ende einen Qualifikator, so kann in einem Objektdiagramm der konkrete Qualifikatorwert an jedem Link der Assoziation angegeben werden. Abbildung 2.25 zeigt ein solches Objektdiagramm. 2.3.2 Komposition Die Komposition wird auch im Objektdiagramm durch eine ausgefullte ¨ Raute an einem Assoziationsende dargestellt. W¨ahrend in Klassendiagrammen eine Klasse in mehreren Kompositionen vorkommen darf, ist es nicht erlaubt, ein Teilobjekt im Objektdiagramm mehreren Kompositionslinks zuzuordnen. Um die Abh¨angigkeit der Teilobjekte vom Ganzen und den Kompositionscharakter st¨arker hervorzuheben, kann die alternative Darstellung aus Abbildung 2.26 rechts verwendet werden.
2.3 Objektdiagramme
31
Abbildung 2.25. Qualifizierte Links
Abbildung 2.26. Alternative Darstellungen einer Komposition
2.3.3 Bedeutung eines Objektdiagramms Aufgrund der Dynamik von Objektsystemen variiert die Anzahl der Objekte in einem System st¨andig. Außerdem konnen ¨ Objektstrukturen ihre Links dynamisch ver¨andern. Dadurch konnen ¨ unbeschr¨ankt viele Variationen von Objektstrukturen entstehen, die normalerweise nicht vollst¨andig dargestellt werden konnen. ¨ Ein Objektdiagramm modelliert daher einen Systemausschnitt mit zeitlich limitierter Gultigkeit, ¨ im Extremfall einen zu einem einzigen Zeitpunkt gultigen ¨ Snapshot Wie in Band 1 diskutiert, haben die mit Objektdiagrammen modellierten Strukturen einen prototypischen, musterartigen Charakter. Sie zeigen exemplarisch eine Situation, ohne dass diese Situation notwendigerweise normativen Charakter annimmt. Die im Objektdiagramm dargestellte Situation muss im tats¨achlich ablaufenden System nicht auftreten. Sie kann jedoch auch mehr als einmal, zeitlich aufeinanderfolgend oder zur gleichen Zeit auftreten. In jeder der auftretenden Situationen konnen ¨ unterschiedliche oder auch (teilweise) dieselben Objekte beteiligt sein. Objektdiagramme konnen ¨ also im System uberlappende ¨ Strukturen darstellen. Deshalb ist zwischen der Darstellung eines Objekts im Objektdiagramm und den echten Objekten eines
32
¨ 2 Kompakte Ubersicht zur UML/P
Systems deutlich zu unterscheiden. Die in den Objektdiagrammen dargestellten Objekte werden daher auch als prototypisch bezeichnet. Die Moglichkeit ¨ zu Instantiierung von prototypischen Objekten bildet eine Grundlage fur ¨ die Einbindung der Objektdiagramme in die OCL-Logik. 2.3.4 Logik der Objektdiagramme Kernelement der Einbindung der exemplarischen Objektdiagramme in die OCL ist die Moglichkeit, ¨ ein Objektdiagramm in einfacher Weise selbst als Aussage uber ¨ die beschriebenen Objekte zu verstehen. Wie in Band 1 durch eine Transformation von Objektdiagrammen nach OCL beschrieben, sind die benannten Objekte freie Variablen solcher Aussagen, w¨ahrend anonyme Objekte existenzquantifiziert sind. Deshalb sind alle im Objektdiagramm verwendeten Namen in der nutzenden OCL-Bedingung einzufuhren. ¨ Der Name eines Objektdiagramms steht fur ¨ die darin festgestellte Aussage und kann in der OCL frei eingesetzt werden. So kann mit der folgenden Aussage gefordert werden, dass in jeder Auktion, die bereits begonnen hat, eine Willkommensnachricht versandt wurde. Dabei werden die zwei Objektdiagramme aus Abbildung 2.27 verwendet, von denen Welcome1A die Voraussetzung fur ¨ die Forderung Welcome1B darstellt.
Abbildung 2.27. Objektdiagramme fur ¨ die Willkommensnachricht
inv Welcome1: forall Auction a, TimingPolicy timePol: OD.Welcome1A implies exists Message welcome: OD.Welcome1B
OCL
Die Aussage lautet: Wenn Objekte a und timePol existieren und dem ” Objektdiagramm Welcome1A genugen, ¨ dann existiert Objekt welcome und es gelten alle im Objektdiagramm Welcome1B formulierten Eigenschaften“. Durch das Ersetzen konkreter Werte durch Variablen oder OCL-Ausdrucke ¨ konnen ¨ abstrake Objektdiagramme gebildet werden. Die abstrakten Werte konnen ¨ in eine OCL-Bedingung importiert und dort zur Spezifikation
2.4 Statecharts
33
von Eigenschaften genutzt werden. Um zum Beispiel eine Testauktion aufzusetzen, die 100 Personen hat, kann das Objektdiagramm NPersons aus Abbildung 2.28 verwendet werden.
import Auction test32 inv Test32: forall int x in {1..100}: OD.NPersons
OCL
Abbildung 2.28. Auktion mit parametrisiertem Personen-Objekt
W¨ahrend sich der Beschreibungskomfort der aus OCL und Objektdiagrammen integrierten Notation gegenuber ¨ der OCL verbessert hat, ist die Beschreibungsm¨achtigkeit nur gegenuber ¨ den Objektdiagrammen besser geworden, weil so • • • •
Alternativen, unerwunschte ¨ Situationen Kompositionen und Verallgemeinerungen (Muster)
moglich ¨ geworden sind. Dazu werden im Wesentlichen die Logik-Operatoren Disjunktion, Negation, Konjunktion und Quantoren eingesetzt. Damit steigt die Ausdruckskraft von Objektdiagrammen von exemplarischen zu allgemein gultigen ¨ Aussagen.
2.4 Statecharts Statecharts sind eine Weiterentwicklung der Automaten zur Beschreibung von Objektverhalten. Jedes komplexere System besitzt steuernde und kontrollierende Anteile, die mit Statecharts modelliert werden konnen. ¨ Die hier vorgestellte Variante der Statecharts nutzt die OCL als Bedingungssprache und Java-Anweisungen als Aktionen. 2.4.1 Eigenschaften von Statecharts Automaten gibt es in unterschiedlichsten Auspr¨agungen. So konnen ¨ Automaten ausfuhrbar ¨ sein, zur Erkennung von Sequenzen von Buchstaben oder Nachrichten, zur Beschreibung des Zustandsraums eines Objekts oder zur Spezifikation von Antwortverhalten auf einen Stimulus genutzt werden. Der
34
¨ 2 Kompakte Ubersicht zur UML/P
¨ Ubersichtsartikel [vdB94] zeigt, dass es fur ¨ Statecharts eine Reihe syntaktischer Varianten und semantischer Interpretationsmo¨ glichkeiten gibt, die den jeweiligen Anwendungsgebieten angepasst sind. Die Statecharts der UML/P lassen sich durch Steuerung mit geeigneten Stereotypen fur ¨ die Modellierung, Codegenerierung oder Testfallbeschreibung einsetzen. Abbildung 2.29 zeigt ein Statechart, das eine vereinfachende Abstraktion des Zustandssystems einer Auktion darstellt. Abbildung 2.30 beinhaltet eine uberlappende ¨ Liste von Aufgaben, die ein Statechart ubernehmen ¨ kann.
Abbildung 2.29. Statechart
Die (uberlappenden) ¨ Aufgaben eines Statecharts konnen ¨ sein: • • • • • • •
Darstellung des Lebenszyklus eines Objekts Implementierungsbeschreibung einer Methode Implementierungsbeschreibung des Verhaltens eines Objekts Abstrakte Anforderungsbeschreibung an den Zustandsraum eines Objekts Darstellung der Reihenfolge von erlaubten Eintreten von Stimuli (Aufrufreihenfolge) Charakterisierung der mo¨ glichen oder erlaubten Verhalten eines Objekts Bindeglied zwischen Zustands- und Verhaltensbeschreibung Abbildung 2.30. Aufgabenvielfalt eines Statecharts
¨ Eine kompakte Ubersicht der Statechart-Konstrukte ist in den Abbildungen 2.31, 2.32 und 2.33 zusammengefasst. Ein Statechart beschreibt das Antwortverhalten eines Objekts, das entsteht, wenn ein Stimulus auf dieses Objekt trifft. Ein Stimulus kann dabei
2.4 Statecharts
35
Zustand. Ein Zustand (synonym: Diagrammzustand) repr¨asentiert eine Teilmenge der moglichen ¨ Objektzust¨ande. Ein Diagrammzustand wird durch einen Zustandsnamen und je einer optionalen Zustandsinvariante, entry-Aktion, exit-Aktion und do-Aktivit¨at modelliert. Startzustand. In einem Startzustand beginnen Objekte ihren Lebenszyklus. Mehrere Startzust¨ande erlauben mehrere Arten der Objekterzeugung darzustellen. In einem Methoden-Statechart markiert der Startzustand den Beginn der Methode. Die Bedeutung eines Startzustands als Teil eines anderen Zustands ist in Abschnitt 6.4.2, Band 1 beschrieben. Endzustand. Ein Endzustand beschreibt, dass das Objekt in diesem Zustand seine Pflicht erfullt ¨ hat und nicht mehr gebraucht wird. Allerdings konnen ¨ Endzust¨ande wieder verlassen werden. In einem Methoden-Statechart markiert ein Endzustand das Ende der Methodenbearbeitung. Die Bedeutung eines Endzustands als Teil eines anderen Zustands ist in Abschnitt 6.4.2, Band 1 beschrieben. Teilzustand. Zust¨ande konnen ¨ hierarchisch geschachtelt werden. Ein Gesamtzustand enth¨alt mehrere Teilzust¨ande. Zustandsinvariante ist eine OCL-Bedingung, die fur ¨ einen Diagrammzustand charakterisiert, welche Objektzust¨ande ihm zugeordnet sind. Zustandsinvarianten verschiedener Zust¨ande durfen ¨ im Allgemeinen uberlappen. ¨ Abbildung 2.31. Begriffsdefinitionen fur ¨ Statecharts, Teil 1: Zust¨ande Stimulus wird von anderen Objekten oder der Laufzeitumgebung verursacht und fuhrt ¨ zur Ausfuhrung ¨ einer Transition. Ein Stimulus kann zum Beispiel ein Methodenaufruf, ein Remote Procedure Call, der Empfang einer asynchron versandten Nachricht oder die Mitteilung einer Zeituberschreitung ¨ (Timeout) sein. Transition. Eine Transition fuhrt ¨ von einem Quellzustand in einen Zielzustand und beinhaltet eine Beschreibung des Stimulus sowie der Reaktion in Form einer Aktion. Zus¨atzliche OCL-Bedingungen erlauben die Schaltbereitschaft und die Reaktion einer Transition weiter zu pr¨azisieren. Schaltbereitschaft. Eine Transition ist genau dann schaltbereit, wenn sich das Objekt im Quellzustand der Transition befindet, der Stimulus korrekt ist und die Vorbedingung der Transition zutrifft. Sind mehrere Transitionen in derselben Situation schaltbereit, so ist das Statechart nichtdeterministisch und es ist nicht festgelegt, welche Transition ausgew¨ahlt wird. Vorbedingung der Transition. Zus¨atzlich zum Quellzustand und dem Stimulus ist es moglich, ¨ die Schaltbereitschaft einer Transition durch eine OCL-Bedingung einzuschr¨anken, die fur ¨ die Attributwerte und den Stimulus erfullt ¨ sein muss. Nachbedingung der Transition (auch: Aktionsbedingung). Neben einer operationellen Beschreibung der Reaktion auf einen Stimulus kann durch eine OCLBedingung eine eigenschaftsorientierte Einschr¨ankung der moglichen ¨ Reaktion gegeben werden. Abbildung 2.32. Begriffsdefinitionen fur ¨ Statecharts, Teil 2: Transitionen
einen Methodenaufruf, eine asynchrone Nachricht oder einen Timeout darstellen. Die Bearbeitung des Stimulus wird atomar durchgefuhrt. ¨ Sie ist also
36
¨ 2 Kompakte Ubersicht zur UML/P
Aktion. Eine Aktion ist eine durch operationellen Code (also zum Beispiel Java) oder durch eine OCL-Bedingung beschriebene Ver¨anderung des Zustands eines Objekts und seiner Umgebung. Eine Transition enth¨alt ublicherweise ¨ eine Aktion. Entry-Aktion. Ein Zustand kann eine entry-Aktion beinhalten, die ausgefuhrt ¨ wird, wenn der Zustand betreten wird. Sind Aktionen operationell beschrieben, so wird die entry-Aktion nach der Transitionsaktion ausgefuhrt. ¨ Liegt eine eigenschaftsorientierte Beschreibung vor, so gilt die Konjunktion beider Beschreibungen. Exit-Aktion. Analog zur entry-Aktion kann ein Zustand eine exit-Aktion beinhalten. In einer operationellen Form wird diese vor der Transitionsaktion ausgefuhrt, ¨ in der eigenschaftsorientierten Form gilt ebenfalls die Konjunktion. Do-Aktivit¨at. Ein Zustand kann eine permanent andauernde Aktivit¨at beinhalten, die do-Aktivit¨at genannt wird. Ihre Implementierung kann uber ¨ verschiedene Mechanismen zur Erzeugung oder Simulation von Parallelit¨at, wie eigene Threads, Timer, o.¨a. vorgenommen werden. Nichtdeterminismus. Existieren in einer Situation mehrere alternative Transitionen, die schaltbereit sind, so spricht man von Nichtdeterminismus des Statecharts. Das Verhalten des Objekts ist damit unterspezifiziert. Es gibt mehrere methodisch sinnvolle Moglichkeiten, ¨ Unterspezifikation im Verlauf eines Softwareentwurfs einzusetzen und aufzuheben. Abbildung 2.33. Begriffsdefinitionen fur ¨ Statecharts, Teil 3: Aktionen
nicht unterbrechbar und nicht parallel zu anderen Transitionen desselben Statecharts. W¨ahrend ein Objekt typischerweise einen unendlichen Zustandsraum hat, besteht ein Statechart aus einer endlichen, typischerweise sogar sehr kleinen Menge von Diagrammzust¨anden. Die Diagrammzust¨ande stellen daher eine Abstraktion des Objektzustandsraums dar. Die Beziehung zwischen Diagramm- und Objektzust¨anden kann durch Hinzufugen ¨ von OCLBedingungen pr¨azise definiert werden. Gleiches gilt fur ¨ die Vorbedingungen und Effekte von Transitionen. Abh¨angig vom Detaillierungsgrad und der Darstellungsform dieser Bedingungen kann ein Statechart daher als ausfuhr¨ bare Implementierung oder als abstrakte Anforderungsbeschreibung angesehen werden. Statecharts konnen ¨ deshalb von der Anforderungsanalyse bis zur Implementierung eingesetzt werden. Abbildung 2.34 illustriert, wie die endlich vielen Diagrammzust¨ande und Transitionen eines Statecharts mit einem darunter liegenden unendlichen Transitionssystem in Beziehung gesetzt werden, das das Verhalten des Objekts beschreibt. Die Interpretation eines Diagrammelements durch jeweils eine Menge von Zust¨anden beziehungsweise Transitionen hat einige Effekte, auf deren detaillierte Untersuchung in Band 1 hingewiesen wird. Hier seien nur zusammenfassend wesentliche Eigenschaften festgestellt:
2.4 Statecharts
37
Abbildung 2.34. Interpretation eines Diagramms
• • •
•
•
•
Statecharts basieren auf Mealy-Automaten, die neben der Verarbeitung von Stimuli auch die Ausgabe von Ergebnissen, zum Beispiel in Form ¨ von Methodenaufrufen und die Anderung des Objektzustands zulassen. Innerhalb des durch das Statechart beschriebenen Objekts existiert keine Parallelit¨at. Die Statcharts der UML/P haben deshalb keine Parallelzust¨ande ( And-States“). ” Statecharts erlauben grunds¨atzlich Nichtdeterminismus. Dieser kann zu echtem Nichtdeterminismus der Implementierung fuhren, ¨ aber auch als Unterspezifikation des Modells interpretiert und durch detailliertere Angaben sp¨ater behoben werden. Spontane (ε-)Transitionen modellieren Beobachtungen, bei der der auslosende ¨ Stimulus unsichtbar bleibt (zum Beispiel ein interner Methodenaufruf oder ein Timer). Damit sind spontane Transitionen nur eine besondere Form des Nichtdeterminismus. Ein Statechart kann unvollst¨andig sein, indem es fur ¨ bestimmte Kombinationen aus Zust¨anden und Stimuli keine Transitionen zur Verfugung ¨ stellt. In diesem Fall ist uber ¨ die Implementierung nichts ausgesagt, also eine robuste Implementierung moglich. ¨ Insbesondere wird nicht gefordert, dass die Implementierung den Stimulus ignoriert. Mit einem geeigneten Stereotyp l¨asst sich bei Unvollst¨andigkeit ein spezifisches Verhalten, zum Beispiel durch Transition in einen Fehlerzustand festlegen.
Die beiden prim¨aren Aufgaben von Statecharts sind die Darstellung von Lebenszyklen von Objekten und des Verhaltens einzelner Methoden. 2.4.2 Darstellung von Statecharts Abbildung 2.35 zeigt einen einzelnen Zustand, der von der Klasse Auction eingenommen werden kann und neben dem Namen AuctionOpen eine Zustandsinvariante, je eine entry-Aktion und exit-Aktion sowie eine do-Aktivit¨at beinhaltet.
38
¨ 2 Kompakte Ubersicht zur UML/P
Abbildung 2.35. Ein Zustand der Klasse Auktion mit Invariante und Aktionen
Da ein Diagrammzustand einer Menge von Objektzust¨anden entspricht, kann die in OCL beschriebene Zustandsinvariante dazu verwendet werden, diese Beziehung herzustellen. Zustandsinvarianten mussen ¨ nicht disjunkt sein. Sind sie disjunkt, so spricht man von Datenzust¨anden, ansonsten von Kontrollzust¨anden. Der Datenzustand eines Objekts wird durch die Attribute des eigenen und gegebenenfalls abh¨angiger Objekte bestimmt. Der Kontrollzustand manifestiert sich im laufenden System zus¨atzlich durch den Programmz¨ahler und den Aufrufkeller. Eine Zustandsinvariante kann nur uber ¨ den Datenzustand sprechen. Hierarchie kann bei Zust¨anden zur Verhinderung einer Zustandsexplosion eingesetzt werden. Ein hierarchisch unterteilter Zustand hat wie jeder andere Zustand einen Namen und kann eine Zustandsinvariante, eine entryund exit-Aktion und eine do-Aktivit¨at enthalten. Die flache und hierarchische Darstellung von Zust¨anden im Statechart sind wie in Abbildung 2.36 illustriert a¨ quivalent, wenn die Zustandsinvarianten entsprechend beachtet werden.
Abbildung 2.36. Einfuhrung ¨ und Expansion von Hierarchie
2.4 Statecharts
39
Abbildung 2.29 zeigt die Markierung fur ¨ Start- und Endzust¨ande auf oberster Ebene. Innerhalb eines hierarchisch zergliederten Zustands konnen ¨ ebenfalls Start- und Endzust¨ande markiert werden. Sie haben dann allerdings eine etwas andere Bedeutung (siehe Band 1). Wenn das Objekt im Quellzustand einer Transition ist und die Schaltbedingung erfullt, ¨ dann kann die Transition durchgefuhrt ¨ werden. Dabei wird eine Aktion ausgefuhrt ¨ und der Zielzustand der Transition eingenommen. Stimuli Fur ¨ Stimuli, die zur Auslosung ¨ einer Transition fuhren, ¨ werden funf ¨ verschiedene Kategorien unterschieden: • • • • •
Eine Nachricht wird empfangen, ein Methodenaufruf erfolgt, das Ergebnis eines Return-Statements wird als Antwort auf einen fruher ¨ abgeschickten Aufruf zuruckgegeben, ¨ eine Exception wird abgefangen oder die Transition tritt spontan auf.
Fur ¨ das empfangende Objekt macht es keinen Unterschied, ob ein Methodenaufruf asynchron oder als normaler Methodenaufruf ubermittelt ¨ wird. Im Statechart wird deshalb auch keine Unterscheidung zwischen diesen beiden Arten von Stimuli getroffen. Es ergeben sich deshalb die in Abbildung 2.37 dargestellten Arten von Stimuli fur ¨ Transitionen.
Abbildung 2.37. Arten von Stimuli fur ¨ Transitionen
Die letztgenannten drei Formen von Stimuli spielen nur in Methodenstatecharts eine Rolle, in denen das Innenleben von Methoden beschrieben wird. Die Transitionen spiegeln dann eine Abstraktion des Kontrollflusses der Methode wider. Abbildung 2.38 enth¨alt eine vereinfachte Darstellung des Ablaufs der Methode login(), die im Client-Applet verwendet wird, um nach eingegebenen Namen und Passwort die Verbindung zum Server herzustellen und die Auktionsdaten zu laden.
40
¨ 2 Kompakte Ubersicht zur UML/P
Abbildung 2.38. Statechart fur ¨ die login-Methode
Schaltregeln Die Schaltbereitschaft einer Transition l¨asst sich wie folgt charakterisieren: 1. Das Objekt muss in einem Objektzustand sein, der zum Quellzustand der Transition korrespondiert. 2. Entweder ist die Transition spontan und beno¨ tigt daher keinen auftretenden Stimulus oder der fur ¨ die Transition notwendige Stimulus ist aufgetreten. 3. Die in der Stimulusbeschreibung angegebenen Werte (zum Beispiel Methodenparameter) stimmen mit den tats¨achlichen Werten des angekommenen Stimulus uberein. ¨ Sind in der Stimulusbeschreibung Variablen angegeben, so werden diese mit den tats¨achlichen Werten belegt. 4. Die Vorbedingung, die uber ¨ den Objektzustand und die Parameter des angekommenen Stimulus evaluiert wird, gilt. Es kann vorkommen, dass eine Vorbedingung in keiner Situation erfullt ¨ werden kann. In diesem Fall ist die Transition sinnlos, da sie nie durchgefuhrt ¨ wird. Ist eine Transition schaltbereit so muss sie nicht notwendigerweise auch durchgefuhrt ¨ werden. Es ist durch Nichtdeterminismus (Unterspezifikation) moglich, ¨ dass mehrere Transitionen gleichzeitig schaltbereit sind. Nichtdeterminismus im Statechart bedeutet aber nicht notwendigerweise, dass die Implementierung nichtdeterministisch ist. Abbildung 2.39 zeigt zwei erlaubte Situationen uberlappender ¨ Schaltbereiche. In beiden F¨allen (a) und (b) sind jeweils beide Alternativen moglich. ¨ Mit expliziten Priorit¨aten kann Fall (a) deterministisch aufgelost ¨ werden. Fur ¨
2.4 Statecharts
41
Abbildung 2.39. Situationen uberlappender ¨ Schaltbereiche
Nichtdeterminismus auf verschiedenen Hierarchiestufen wird daruber ¨ hinaus mit dem Stereotyp prio:inner bzw. prio:outer allgemein festgelegt, ob innere oder a¨ ußere Transitionen den Vorzug erhalten. Im Fall eines unvollst¨andigen Statechart kann ebenfalls durch Einsatz eines Stereotypen das Verhalten pr¨azisiert werden. 1. Mit completion:ignore wird der Stimulus ignoriert. 2. Ein Fehlerzustand wird eingenommen, wenn ein solcher Zustand mit error markiert ist. Fur ¨ das Bearbeiten von Exceptions kann ein weiterer Zustand mit exception markiert werden. 3. Vollige ¨ Unterspezifikation am Statechart wird durch den Stereotyp completion:chaos zugelassen. Wie in Abschnitt 6.2.6, Band 1 diskutiert, ergeben sich damit Unterschiede in der Interpretation des Lebenszyklus eines Objekts. In den ersten beiden Interpretationen wird der Lebenszyklus als maximal m¨oglich, in der letzten als minimal zugesichert verstanden. Die Verwendung von completion:chaos ist vor allem in der Spezifikationsphase interessant, wenn durch Verfeinerungen das Verhalten noch detailliert, aber nicht ver¨andert werden soll. Aktionen Aktionen beschreiben die Reaktion auf den Empfang eines Stimulus in einem bestimmten Zustand, indem sie dem Zustand als entry- beziehungsweise exit-Aktion oder der Transition als Reaktion hinzugefugt ¨ werden. UML/P stellt zwei Arten von Aktionen zur Verfugung. ¨ Eine prozedurale Form erlaubt die Nutzung von Zuweisungen und Kontrollstrukturen und eine beschreibende Aktionsform ermoglicht ¨ es, den Effekt einer Aktion zu charakterisieren, ohne festzulegen, wie diese Aktion tats¨achlich realisiert wird. Prozedurale Aktionen werden mit Java realisiert, beschreibende Aktionen ( Aktionsbedingungen“) mit OCL spezifiziert. Abbildung 2.40 beinhal” tet einen Ausschnitt aus einem Statechart fur ¨ die Klasse Auction, in der eine
42
¨ 2 Kompakte Ubersicht zur UML/P
Transition mit prozeduraler Aktionsbeschreibung und einer Nachbedingung zu sehen ist.
Abbildung 2.40. Transition mit prozeduraler und beschreibender Aktion
Aktionsbedingungen konnen ¨ einerseits als redundantes Addendum zu Aktionsanweisungen formuliert werden, um damit zum Beispiel bei Tests eingesetzt zu werden, und andererseits konnen ¨ Aktionsbedingungen die Anweisungen erg¨anzen. So kann ein Teil des Verhaltens bereits prozedural festgelegt und ein anderer Teil noch durch eine OCL-Bedingung beschreibend charakterisiert sein. Die Kombination von entry- und exit-Aktionen aus Zust¨anden und Transitionsaktionen h¨angt von der Form der vorgegebenen Transition ab. Abbildung 2.41 zeigt den Transfer prozeduraler Aktionen auf die Transitionen und demonstriert, in welcher Reihenfolge entry- beziehungsweise exit-Aktionen in hierarchischen Zust¨anden ausgefuhrt ¨ werden. Prozedurale Aktionen werden also sequentiell komponiert.
Abbildung 2.41. Entry- und exit-Aktion in hierarchischen Zust¨anden
2.4 Statecharts
43
Sind die Aktionen eines Statecharts durch OCL-Aktionsbedingungen spezifiziert, so wird, wie in Abbildung 2.42 gezeigt, statt der sequentiellen Komposition die logische Konjunktion verwendet.
Abbildung 2.42. Bedingungen als entry- und exit-Aktion in Zust¨anden
Eine Alternative zur logischen Komposition ist in Band 1 erkl¨art und charakterisiert eine abschnittsweise Gultigkeit ¨ der Bedingungen, die zum Beispiel bei Transitionsschleifen notwendig ist. Erg¨anzungen Zustandsinterne Transitionen sind eigenst¨andige Transitionen, bei denen die entry- oder exit-Aktion des Zustands nicht durchgefuhrt ¨ werden. Abbildung 2.43 zeigt, wie eine zustandsinterne Transition verstanden werden kann.
Abbildung 2.43. Zustandsinterne Transitionen
Wenn ein Zustand eine Situation des Objekts repr¨asentiert, in der eine Aktivit¨at herrscht, zum Beispiel eine Warnmeldung blinkt, kann sie durch
44
¨ 2 Kompakte Ubersicht zur UML/P
eine do-Aktivit¨at beschrieben werden. Abbildung 2.44 charakterisiert deren Interpretation durch einen Timer.
Abbildung 2.44. do-Aktivit¨at als zeitgesteuerte Wiederholung einer Aktion
Die in den beiden Abbildungen 2.43 und 2.44 eingefuhrten ¨ Konzepte werden durch Transformation auf bereits vorhandene Konzepte der Statecharts erkl¨art. In Band 1 ist ein aus 19 Regeln bestehendes Transformationssystem angegeben, das Statecharts vollst¨andig auf flache Mealy-Automaten reduziert und so fur ¨ eine weitere Bearbeitung zug¨anglich macht. Damit besitzen Statecharts einen Transformations-Kalkul, ¨ der fur ¨ die semantikerhaltende Verfeinerung geeignet ist.
2.5 Sequenzdiagramme Sequenzdiagramme werden zur Modellierung von Interaktionen zwischen Objekten eingesetzt. Ein Sequenzdiagramm stellt einen exemplarischen Ausschnitt aus dem Ablauf eines Softwaresystems dar. Es modelliert die dabei auftretenden Interaktionen und Aktivit¨aten und kann um OCL-Bedingungen erweitert werden. Ein Sequenzdiagramm beschreibt, in welcher Reihenfolge Methodenauf¨ rufe durchgefuhrt ¨ und beendet werden. Ahnlich wie bei Statecharts werden daher Verhaltensaspekte modelliert. Es ergeben sich jedoch einige wesentliche Unterschiede: • •
•
Ein Sequenzdiagramm stellt die Interaktion zwischen Objekten in den Vordergrund. Der innere Zustand eines Objekts wird dagegen nicht dargestellt. Ein Sequenzdiagramm ist grunds¨atzlich exemplarisch. Genau wie beim Objektdiagramm kann daher die dargestellte Information w¨ahrend des Ablaufs eines Systems beliebig h¨aufig, mehrfach parallel oder auch gar nicht auftreten. Aufgrund der Exemplarizit¨at sind Sequenzdiagramme nicht zur vollst¨andigen Modellierung von Verhalten geeignet und werden vor allem w¨ahrend der Anforderungsdefinition und, wie in diesem Band gezeigt, zur Modellierung von Testf¨allen eingesetzt.
2.5 Sequenzdiagramme
45
Abbildung 2.45 beinhaltet ein typisches Sequenzdiagramm. Die wesentlichen im Sequenzdiagramm auftretenden Konzepte sind in Abbildung 2.46 kurz erl¨autert.
Abbildung 2.45. Sequenzdiagramm zur Annahme eines Gebots
Objekt im Sequenzdiagramm hat dieselbe Bedeutung wie im Objektdiagramm (siehe Abbildung 2.21), wird allerdings nur mit Namen und Typ dargestellt. Mehrere Objekte desselben Typs sind erlaubt. Name oder Typ sind optional. Zeitlinie. Im Sequenzdiagramm werden zeitlich aufeinanderfolgende Ereignisse von oben nach unten dargestellt. Jedes Objekt hat eine Zeitlinie, die das Voranschreiten der Zeit dieses Objekts darstellt. Die Zeit ist nicht maßstabsgetreu und muss auch nicht in allen Objekten gleich sein. Die Zeitlinie dient daher nur zur Darstellung zeitlicher Reihenfolgen von Interaktionen. Interaktion. Eine Interaktion zwischen zwei Objekten kann durch eine von mehreren Arten von Stimuli ausgelost ¨ sein. Dazu gehoren ¨ Methodenaufrufe, Returns, Exceptions und asynchrone Nachrichten. Im Sequenzdiagramm konnen ¨ die Parameter von Interaktionen angegeben oder ausgelassen werden. Aktivit¨atsbalken. Zur Bearbeitung eines Methodenaufrufs ist ein Objekt eine gewisse Zeit aktiv. Zur Darstellung dieser Aktivit¨at dient der Aktivit¨atsbalken, der bei Rekursion auch geschachtelt auftreten kann. Bedingung. Zur detaillierten Beschreibung von Eigenschaften w¨ahrend eines Ablaufs konnen ¨ OCL-Bedingungen (engl. Guards“) eingesetzt werden. ” Abbildung 2.46. Begriffsdefinitionen fur ¨ Sequenzdiagramme
46
¨ 2 Kompakte Ubersicht zur UML/P
Im Sequenzdiagramm werden Objekte in einer Reihe nebeneinander dargestellt und mit einer nach unten gerichteten Zeitlinie versehen. Es wird vereinfachend angenommen, dass eine gleichzeitige oder uberkreuzende ¨ Versendung von Nachrichten nicht auftritt. Diese Vereinfachung ist motiviert aus dem Einsatz von Sequenzdiagrammen fur ¨ Testzwecke, in denen Nebenl¨aufigkeit explizit kontrolliert wird, um determinierte Testergebnisse zu erhalten. Dadurch wird die Modellierung mit Sequenzdiagrammen wesentlich vereinfacht, es sind aber unter Umst¨anden bestimmte, in einer Implementierung mogliche ¨ Sachverhalte nicht durch Sequenzdiagramme darstellbar. Die Arten der moglichen ¨ Interaktionen sind in Abbildung 2.47 dargestellt. Jede Interaktion mit Ausnahme des rekursiven Aufrufs wird durch einen waagrechten Pfeil dargestellt, der symbolisiert, dass die dabei verbrauchte Zeit vernachl¨assigt wird. An den Pfeilen werden Methodenaufrufe, Returns oder Exceptions mit oder ohne Argumente in Java angegeben.
Abbildung 2.47. Interaktionsformen im Sequenzdiagramm
Wenn eine Methode statisch ist, so wird sie wie auch im Klassendiagramm unterstrichen. In diesem Fall endet der Pfeil an einer Klasse, die damit analog zu einem Objekt eingesetzt wird. Wird ein Objekt w¨ahrend der Interaktion neu erzeugt, wird dies dargestellt, indem die Zeitlinie des Objekts sp¨ater beginnt. Abbildung 2.48 beinhaltet zwei typische Formen von Objekterzeugung. Wie Abbildung 2.45 zeigt, konnen ¨ in einem Sequenzdiagramm zus¨atzlich zu bestimmten Zeitpunkten des Ablaufs geltende Bedingungen angegeben werden. In diesen OCL-Bedingungen werden die im Sequenzdiagramm auftretenden Objekte und Werte in Beziehung gesetzt. Dazu ist der Zugriff auf benannte Objekte sowie Variablen moglich, ¨ die als Argumente in Methodenaufrufen eingesetzt sind. Eine OCL-Bedingung kann die auftretenden Objekte und Parameter sowie den Effekt einer Nachricht auf einem Objekt genauer beschreiben, wobei sich der Kontext aus dem Sequenzdiagramm ergibt. Ein Zugriff auf Attribute ist durch die Qualifizierung mit dem Objekt moglich. ¨ Ist ein OCL-Ausdruck
2.5 Sequenzdiagramme
47
Abbildung 2.48. Erzeugung eines neuen Objekts
allerdings ausschließlich uber ¨ einer Zeitlinie, so ist er diesem Objekt zugeordnet und auf die Attribute dieses Objekts kann direkt zugegriffen werden. Die Gultigkeit ¨ einer OCL-Bedingung bezieht sich auf den Zeitpunkt unmittelbar nach der letzten aufgetretenen Interaktion beziehungsweise dem letzten aufgetretenen Aktivit¨atsbalken. Das bedeutet, die OCL-Bedingung ist nur unmittelbar nach dieser Interaktion einzuhalten. Soll in der Bedingung auf einen fruheren ¨ Wert eines Attributs zugegriffen werden, so ist dieser explizit in einer Zwischenvariable abzulegen. Wie Abbildung 2.49 zeigt, wird dazu ein an OCL angelehntes let-Konstrukt verwendet, das neue Variablen einfuhrt, ¨ die nur innerhalb des Sequenzdiagramms zugreifbar sind.
Abbildung 2.49. Hilfsvariablen speichern Werte
Semantik eines Sequenzdiagramms Auf den exemplarischen Charakter eines Sequenzdiagramms wurde bereits hingewiesen. Fur ¨ den methodischen Einsatz von Sequenzdiagrammen sind mehrere Formen der Exemplarizit¨at zu unterscheiden. Die Exemplarizit¨at eines Sequenzdiagramms basiert analog zum Objektdiagramm auf der Beschreibung einer Menge von Objekten, die in dieser Form in beliebiger
48
¨ 2 Kompakte Ubersicht zur UML/P
H¨aufigkeit oder auch gar nicht, in einem System auftreten kann. Außerdem ist der Ablauf an sich exemplarisch, der in dieser Form sogar beliebig h¨aufig nebeneinander und verschachtelt, aber auch gar nicht auftreten kann. Zu diesen Formen der Exemplarizit¨at kommt hinzu, dass ein Sequenzdiagramm eine Abstraktion eines Ablaufs darstellt, da es weder alle Objekte des Systems, noch alle auftretenden Interaktionen beinhalten kann. Bei einem Sequenzdiagramm konnen ¨ auch zwischendurch Interaktionen fehlen. Findet ein Methodenaufruf im System w¨ahrend des Beobachtungszeitraums mehrfach statt, so entsteht zus¨atzlich eine mehrdeutige Situation, welcher tats¨achliche Methodenaufruf mit der im Diagramm dargestellten Interaktion korrespondiert. Mithilfe geeigneter Stereotypen kann jedoch die Beobachtungsform gec “ zeigt bei Objeknauer festgelegt werden. Der Repr¨asentationsindikator ” ten im Sequenzdiagramm die Vollst¨andigkeit der gezeigten Interaktionen an. Der alternative Repr¨asentationsindikator . . .“ fur ¨ Unvollst¨andigkeit gilt per ” Default. Bei einem in diesem Sinn vollst¨andig beobachteten Objekt ergibt sich notwendigerweise, dass zu jedem Aufruf ein passender Return angegeben sein muss. Dabei sind alle Objekte anzugeben, die direkt mit dem beobachteten Objekt interagieren. Dies kann zu erheblich detaillierteren Diagrammen fuhren, ¨ als eigentlich gewunscht ¨ wird. Deshalb werden in Band 1 weitere Stereotypen eingefuhrt, ¨ die zus¨atzliche Varianten der Semantikdefinition erlauben. Der Stereotyp match:visible ist zum Beispiel geeignet fur ¨ die Definition von Sequenzdiagrammen fur ¨ Tests: match:visible verbietet das Auslassen von Interaktionen mit anderen im Sequenzdiagramm angegebenen Objekten, erlaubt jedoch das Fehlen von Interaktionen mit Objekten, die im Diagramm nicht angegeben sind. Die Beobachtung dieses Objekts ist also vollst¨andig in Bezug auf die im Diagramm sichtbaren Objekte.
3 Prinzipien der Codegenerierung
Der Worte sind genug gewechselt, lasst mich auch endlich Taten sehen. Faust, Johann Wolfgang von Goethe
Codegenerierung ist ein wesentlicher Erfolgsfaktor fur ¨ den Einsatz von Modellen im Softwareentwicklungsprozess. Aus vielen Modellen kann Code fur ¨ das Produktionssystem oder fur ¨ Testtreiber effizient generiert und damit die Konsistenz zwischen Modell und Implementierung verbessert sowie Ressourcen eingespart werden. Dieses Kapitel beschreibt grundlegende Konzepte, Techniken und Probleme der Codegenerierung und skizziert eine Darstellungsform fur ¨ Regeln zur Codegenerierung in Form von Transformationsregeln.
3.1 3.2 3.3 3.4
Konzepte der Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . Techniken der Codegenerierung . . . . . . . . . . . . . . . . . . . . . . Semantik der Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . Parametrisierung eines Werkzeugs . . . . . . . . . . . . . . . . . . . .
52 60 68 71
50
3 Prinzipien der Codegenerierung
Die Moglichkeit, ¨ aus einem Modell ablauff¨ahigen Code zu erzeugen, bietet interessante Perspektiven bei der Softwareentwicklung und ist teilweise sogar eine wesentliche Voraussetzung fur ¨ • •
• • •
die Steigerung der Effizienz der Entwickler, die Trennung von Anwendungsmodellierung und technischem Code, die die Wartbarkeit und die Weiterentwicklung der Funktionalit¨at sowie die Portierung auf neue Hardware und Betriebssystemversionen besser unterstutzt, ¨ Rapid Prototyping mit Hilfe von Modellen, die eine kompaktere Beschreibung des Systems erlauben, als es durch eine rein textuelle Programmiersprache wie Java moglich ¨ w¨are, schnelles Feedback durch Demonstrationen und Testl¨aufe und einen wesentlichen Aspekt der Qualit¨atssicherung: der Generierung von automatisierten Tests.
Eine der St¨arken der Generierung ist die Moglichkeit ¨ zur Konzentration redundanter, das heißt sich fur ¨ viele Komponenten wiederholender Codefragmente (oder Aspekte“, [LOO01, KLM+ 97]) an einer Stelle und damit ” die Reduktion der Große ¨ der manuell zu erstellenden Dokumente. Dies wiederum fuhrt ¨ zu weniger Programmierfehlern, großerer ¨ Konformit¨at des generierten Codes zu Codierungsstandards1 sowie zur schnelleren Erstellung und flexibleren Anpassung des Systems auf Basis von Modellen. Probleme heutiger Werkzeuge Die Erzeugung von ablauff¨ahigem Code aus einem Modell ist daher derzeit zurecht eine der wesentlichen Anstrengungen der Hersteller von Modellierungswerkzeugen. Dies gilt nicht nur fur ¨ UML-basierte Werkzeuge, sondern auch fur ¨ Werkzeuge mit anderen Notationen, wie Autofocus [HSSS96], der in der Telekommunikation verwendeten SDL [IT99c, IT99b] oder den in Statemate und Rhapsody umgesetzten Statecharts [HN96]. Aufgrund dieser vielf¨altigen Anstrengungen ist davon auszugehen, dass sich die Situation bei der Codegenerierung in den n¨achsten Jahren weiter verbessern wird. Viele der heute existierenden Werkzeuge bieten bereits die Generierung von Code oder Coderahmen aus Teilen der UML an. Jedoch gibt es hier eine Reihe grunds¨atzlicher Probleme, die auch konzeptioneller Verbesserungen bedurfen. ¨ 1. Die Erzeugung von Coderahmen aus Klassendiagrammen ist mittlerweile Stand der Technik. Dabei werden Hulsen ¨ fur ¨ die Klassen erzeugt, die Attributdefinitionen und Zugriffsfunktionen beinhalten. Die Rumpfe ¨ generierter Methoden sind manuell einzutragen. Da detaillierte Modelle ¨ im Projekt meist einer hohen Anderungsrate unterworfen sind, mussen ¨ 1
Das ist zum Beispiel bei einer Zertifizierung des Systems wichtig.
3 Prinzipien der Codegenerierung
2.
3.
4.
5.
51
die manuell eingesetzten Coderumpfe ¨ nach jeder Generierung neu nachgetragen werden oder gehen verloren. Als Ausweg wird deshalb das Roundtrip-Engineering“ verwendet. ” Roundtrip-Engineering erlaubt die wechselseitige Transformation von Code in Klassendiagramme und umgekehrt. Wesentlich ist dabei, dass ¨ beide Sichten manuell a¨ nderbar sind, ohne dass die Anderungen in der jeweils anderen Sicht verloren gehen. Insbesondere bleiben Methodenrumpfe ¨ in der Code-Sicht erhalten. Wenn aber eine moglichst ¨ kompakte Darstellung des Systems gewunscht ¨ ist, dann ist das eine Sackgasse. Sinnvoller ist vielmehr nur eine Darstellung anzubieten, die graphische Klassendiagramme und Coderumpfe ¨ integriert. Die wesentlichen Hindernisse dafur ¨ sind das derzeit noch zu geringe Zutrauen des Entwicklers in den generierten Code, so dass ein manueller Eingriff in den generierten Code noch gewunscht ¨ wird, und die nicht zufriedenstellend gekl¨arte Frage, wie Coderumpfe ¨ abgelegt werden, so dass sie vom Entwickler effizient bearbeitet werden konnen. ¨ Mit den ersten Compilern war die Situation jedoch a¨ hnlich. Es wurde Assembler-Quellcode erzeugt, der manuell a¨ nderbar sein sollte. Es kann davon ausgegangen werden, dass mit zunehmender Reife der Generierungstechnologie die Ebene des Java-Quellcodes unwichtiger wird und Bytecode direkt erzeugt werden kann. Werden Coderumpfe ¨ wie beim Roundtrip-Engineering direkt in den generierten Code eingesetzt, so ist in diesen Coderumpfen ¨ keine Abstraktion von der konkreten Realisierung von Attributen, Assoziationen, etc. moglich. ¨ Stattdessen muss der Entwickler die Form der Umsetzung und die daraus resultierenden Zugriffsfunktionen kennen. Werden Coderumpfe ¨ stattdessen ebenfalls aus abstrakten“ Coderumpfen ¨ gene” riert, so konnen ¨ zum Beispiel Attributzugriffe durch entsprechende getund set-Methoden ersetzt werden. Auch ist dann die Instrumentierung des Codes fur ¨ Tests besser moglich. ¨ Leider stimmt die dokumentierte oder den Analyse- und RefactoringTechniken zugrunde liegende Semantik mit dem bei der Codegenerierung entstandenen Verhalten gelegentlich nicht uberein. ¨ Dies ist ein generelles Problem, das einer sorgf¨altigen Festlegung von Codegenerierung, Analysen, Refactoring-Techniken und der dokumentierten Semantik bedarf. Denn sonst ist es moglich, ¨ dass ein bezuglich ¨ der offiziellen Semantik korrektes Refactoring doch zu einem ver¨anderten Systemverhalten fuhrt. ¨ Einfache Werkzeuge generieren oft eine starre Form von Code, ohne auf die spezifischen Bedurfnisse ¨ des Projekts einzugehen. Eine Parametrisierung der Codegenerierung ist wunschenswert ¨ und an vielen Stellen auch notwendig, um zum Beispiel plattformspezifische Anpassungen in den Code einzubauen, die Nutzung von Frameworks, Speicher- und Kommunikationstechniken zu erlauben oder die Optimierung der Umsetzung von Modellelementen zu ermoglichen. ¨
52
3 Prinzipien der Codegenerierung
Die moglichen ¨ Formen der Codegenerierung sind vielf¨altig und konnen ¨ kaum direkt antizipiert werden. Deshalb ist einerseits eine flexible Skriptsprache2 notwendig, andererseits dennoch zu sichern, dass die essenti” elle Semantik“ der Diagramme durch die Codegenerierung nicht verloren geht. In diesem Kapitel werden grundlegenden Konzepte zur Codegenerierung diskutiert und ausschnittsweise anhand der UML/P-Notation erl¨autert. Fur ¨ ein weitergehendes Studium von Gererierungstechniken wird [CE00] empfohlen. Der Abschnitt 3.1 erortert ¨ Konzepte von Codegeneratoren, die auch die im Kapitel 6 diskutierte Verwendung der UML zur Modellierung von Testf¨allen behandelt. In Abschnitt 3.2 werden Anforderungen wie Flexibilit¨at, Plattformunabh¨angigkeit und Steuerbarkeit eines Codegenerators diskutiert. Abschnitt 3.3 behandelt die Beziehung zwischen Codegenerator und Semantikdefinition der Sprache. Abschnitt 3.4 beschreibt, wie ein flexibler Codegenerator aussehen kann.
3.1 Konzepte der Codegenerierung In Vorwegnahme der nachfolgend diskutierten konzeptionellen Grundlagen werden in Abbildung 3.1 die wesentlichen Begriffe einfuhrend ¨ definiert. Der Einsatz eines Codegenerators hat einige Vorteile gegenuber ¨ konventioneller Programmierung. Die Verst¨andlichkeit der benutzten Modellierungsbeziehungsweise Programmiersprache wird erhoht, ¨ indem die Sprache kompakter und durch graphische Elemente ubersichtlicher ¨ wird. Die Effizienz der Softwareentwicklung wird erhoht. ¨ Allein dadurch, dass weniger Code manuell zu schreiben, prufen ¨ und testen ist, konnen ¨ Entwickler ihre Effizienz steigern. Zus¨atzliche Aspekte, wie die bessere Wiederverwendbarkeit von abstrakten Modellen aus einer Modellbibliothek, steigern die Entwicklereffizienz weiter. Dies fuhrt ¨ zu einer Reduktion des Gesamtaufwands fur ¨ die Softwareentwicklung. Dadurch wird weniger Projektmanagement notwendig, wodurch weitere Effizienzsteigerungen moglich ¨ werden. Die Wiederverwendbarkeit ist dabei auf mehreren Ebenen moglich. ¨ Ein Modell kann in angepasster Form in einem a¨ hnlichen Projekt wiederverwendet werden. Idealerweise kann durch wiederholte Anpassung ein ModellFramework entstehen, das fur ¨ gleichartige Projekte verwendbar ist und sogar einen geeignet angepassten Codegenerator besitzt. Das im Codegenerator eingebettete technische Wissen beispielsweise zur Erzeugung von Schnitt¨ stellen oder sicherer und effizienter Ubertragungsmechanismen kann unabh¨angig davon wiederverwendet werden. Eine dritte Moglichkeit ¨ zur Wiederverwendung von Modellen ergibt sich innerhalb eines Projekts. Ein Objektdiagramm kann zum Beispiel sowohl als Pr¨adikat als auch konstruk2
Assistenten“ oder Wizards“ bieten zus¨atzlich Werkzeugunterstutzung ¨ bei der ” ” Skripterstellung.
3.1 Konzepte der Codegenerierung
53
Konstruktives Modell ist die Spezifikation eines Systems, die mithilfe eines automatischen Generators zur Codegenerierung eingesetzt wird. Die Ver¨anderung eines konstruktiven Modells hat die direkte Ver¨anderung des Produktionssystems zur Folge. Die Spezifikationssprache wird auch als High-LevelProgrammiersprache angesehen, da sie grunds¨atzlich ausfuhrbar ¨ ist. Deskriptives Modell ist eine Spezifikation, die zur Beschreibung des Systems verwendet wird, ohne konstruktiv bei der Implementierung eingesetzt zu werden. Das sind typischerweise abstrakte und unvollst¨andige Beschreibungen, also insbesondere Modelle, die als Vorlage fur ¨ eine manuelle Implementierung dienen. Testmodell ist eine Spezifikation, die fur ¨ die manuelle oder automatische Ableitung von Tests geeignet ist. Das Testmodell wird in ausfuhrbaren ¨ Code ubersetzt, ¨ der zum Aufbau von Testdatens¨atzen, als Testtreiber oder als Test-Sollergebnis eingesetzt wird. Konstruktives Testmodell ist ein Testmodell, das durch den Codegenerator in ausfuhrbare ¨ Tests ubersetzt ¨ wird. Demgegenuber ¨ werden deskriptive Testmodelle manuell in Tests ubersetzt. ¨ Codegenerierung ist der Vorgang zur Erzeugung von Code aus konstruktiven Modellen. Codegenerator ist ein Programm, das ein konstruktives Modell einer h¨oheren Programmiersprache in eine Implementierung transformiert (nach [CE00]). Der generierte Code kann zum Produktionssystem oder zum Testcode geh¨oren. Skript beinhaltet die konstruktive Steuerung der Codegenerierung. Skripte parametrisieren den Codegenerator und erlauben damit plattform- und aufgabenspezifische Codegenerierung. Template ist eine spezielle Form eines Skripts. Ein Template beschreibt Codemuster, in die bei der Generierung konkrete Elemente des Modells eingesetzt werden. Dabei wird typischerweise ein Makro-Ersetzungsmechanismus verwendet. Abbildung 3.1. Begriffsdefinitionen zur Codegenerierung
tiv zur Erzeugung einer Objektstruktur eingesetzt werden. Beide Formen konnen ¨ außerdem im Produktionssystem oder bei der Testfalldefinition eingesetzt werden. Der dafur ¨ generierte Code ist, wie in Abschnitt 4.2 ersichtlich, sehr unterschiedlich und daher manuell viel aufw¨andiger zu erstellen. In sehr eingeschr¨anktem Maße sind Codegeneratoren heute auch bereits in der Lage, effizienteren Code zu erstellen, als dies in vertretbarem Aufwand durch manuelle Optimierungen moglich ¨ w¨are. Dies gilt vor allem fur ¨ ausgereifte Compiler normaler Programmiersprachen, die eine Reihe von Optimierungstechniken einsetzen. Fur ¨ ausfuhrbare ¨ Modellierungssprachen wie die UML/P ist davon auszugehen, dass die Steigerung der Effizienz der Entwickler derzeit durch eine weniger effiziente Implementierung erkauft werden muss. Entsprechend ist der Einsatz von Generatoren fur ¨ Modellierungssprachen vor allem bei Individualsoftware und erst in zweiter Linie bei eingebetteter, massenhaft in Billigger¨aten vertriebener Systemsoftware sinnvoll. Die flexible Generierung von Code aus fachlichen Modellen erlaubt letztendlich auch die Behandlung von technischen und teilweise fachlichen Va-
54
3 Prinzipien der Codegenerierung
riabilit¨aten im Sinne von [HP02]. Dabei werden offene Aspekte des Modells durch einen jeweils projektspezifisch angepassten Generator geeignet ausgefullt. ¨ 3.1.1 Konstruktive Interpretation von Modellen Wie bereits in Band 1 beschrieben, ist ein Modell seinem Wesen nach eine in Maßstab, Detailliertheit oder Funktionalit¨at verkurzte ¨ beziehungsweise abstrahierte Darstellung des originalen Systems [Sta73]. Modelle werden immer dort eingesetzt, wo das tats¨achliche System so komplex ist, dass es sich zun¨achst lohnt, bestimmte Eigenschaften des Systems am Modell zu analysieren oder dem Kunden zu erkl¨aren. Dazu gehoren ¨ Architekturmodelle von Geb¨auden ebenso wie technische Modelle komplexer Maschinen. Bei manchen Modellen, wie zum Beispiel Baupl¨anen oder Schaltzeichnungen, steht hier der Wunsch nach einer Beschreibung des Aufbaus (Architektur) im Vordergrund, bei anderen die Simulation von Funktionalit¨at und anderer verhaltensorientierter Eigenschaften.3 Generell gilt aber, dass diese Modelle und Bauzeichnungen als Hilfsmittel fur ¨ die sp¨atere Erstellung des Artefakts dienen. Wird das Modell erstellt, um danach das eigentliche Artefakt zu bilden, so hat das Modell eine vorschreibende (pr¨askriptive) Wirkung. Im Gegensatz dazu wird ein Modell beschreibend (deskriptiv) eingesetzt, wenn das Original vor dem Modell existiert. Beispiele hierzu sind etwa eine Modelleisenbahn oder Fotografien [Lud02]. Aufgrund der Immaterialit¨at von Software entfalten Modelle in der Softwareentwicklung zus¨atzlich zur deskriptiven Wirkung auch eine konstruktive Wirkung. Wenn fur ¨ die Generierung lauff¨ahiger Software aus einem immateriellen, im Computer gespeicherten Modell nur ein Knopfdruck notwendig ist, dann wirkt das Modell als konstruktiver Mechanismus. Der Quellcode ¨ einer Programmiersprache kann aufgrund der automatisierten Ubersetzung als zu dem erzeugten Objektcode a¨ quivalent angesehen werden. Streng genommen sind Quellcode und Objectcode ebenfalls Modelle des Systems. Fur ¨ praktische Belange werden sie jedoch – und mit Recht – mit dem System selbst identifiziert. Dasselbe kann auch fur ¨ ausfuhrbare ¨ UML/P-Modelle gefordert werden. Die konstruktive Verwendung der Modelle hat konkrete Auswirkungen, die bei einem nicht-konstruktiven Einsatz nicht auftreten. Zum Beispiel ver¨andert die Hinzunahme oder das Weglassen von Elementen des Modells sofort das modellierte Artefakt. Ein Beispiel ist die Verwendung mehrerer Statecharts zur Modellierung des Verhaltens einer Klasse auf verschiedenen Abstraktionsstufen. Ein Generator, der mit dieser Situation umgehen kann, simuliert diese parallel und realisiert damit ein mehrdimensionales 3
Fur ¨ eine tiefergehende Diskussion des Modellbegriffs eignen sich zum Beispiel [Sta73] oder [Lud02].
3.1 Konzepte der Codegenerierung
55
Zustandskonzept fur ¨ eine Klasse.4 Wird nun ein weiteres Statechart als Modell hinzugenommen, das ausschließlich bereits vorhandene Information in abstrakterer Form darstellt, so wird das Zustandskonzept weiter aufgebl¨aht. Das a¨ ndert zwar nicht das funktionale Gesamtverhalten, wohl aber die interne Struktur und das Zeitverhalten des Systems. Modelle werden also in der Softwareentwicklung in verschiedenen Rollen eingesetzt. Dazu gehoren ¨ die automatisierte Generierung von Produktionscode, aber auch von Tests. Die manuelle Umsetzung eines Modells ist ebenso moglich, ¨ wie die Erstellung von Modellen, nachdem das Artefakt bereits existiert. Abbildung 3.2 charakterisiert die drei Dimensionen zur Unterscheidung des Einsatzes von Modellen.
Abbildung 3.2. Varianten des Einsatzes von Modellen
Streng genommen ist die Erstellung eines konstruktiv verwendeten Modells nach dem Artefakt moglich ¨ und zum Beispiel im Reverse Engineering sinnvoll. Jedoch wird dieses Modell nicht zur Erstellung des bereits vorhandenen Originals, sondern fur ¨ die n¨achste Version verwendet. Der Unterschied zwischen der konstruktiven und der deskriptiven Interpretation von Modellen ist verwandt zu einem a¨ hnlichen Ph¨anomen, das bei algebraischen Spezifikationssprachen detailliert diskutiert wurde. Einem deskriptiv eingesetzten Modell sollte eine lose Semantik [BFG+ 93] zugeordnet sein. Das heißt, dass verschiedene Implementierungen existieren, die 4
Dabei wird davon ausgegangen, dass Werkzeuge nicht automatisch in der Lage sind zu erkennen, dass ein Statechart eine Abstraktion eines anderen ist. Dies kann zum Beispiel aufgrund von verwendeten OCL-Bedingungen der Fall sein.
56
3 Prinzipien der Codegenerierung
das Modell erfullen. ¨ Viele dieser Implementierungen enthalten beispielsweise weitere Zustandskomponenten, Funktionalit¨at oder Schnittstellen, die im Modell nicht explizit erw¨ahnt sind. Ein Klassendiagramm beschreibt dann einen Ausschnitt eines Systems, da noch weitere, ungenannte Klassen besitzen kann. Ein deskriptives Modell kann daher unvollst¨andig sein. In Band 1 wurde eine entsprechende lose Semantik“ fur ¨ Sequenzdiagramme beschrie” ben. Demgegenuber ¨ stellt ein konstruktiv eingesetztes Modell eine vollst¨andige Beschreibung des Softwaresystems dar, da allein aus dem Modell das gesamte lauff¨ahige System generiert wird. Dies entspricht bei algebraischen Spezifikationen einer initialen Semantik, die einem Modell genau eine Implementierung zuordnet.5,6 3.1.2 Tests versus Implementierung Die UML/P erlaubt die Erstellung von Modellen, die sich sowohl zur Testgenerierung als auch zur Generierung fur ¨ das Produktionssystem eignen. Dazu z¨ahlen Objektdiagramme, die, wie in Abschnitt 5.4, Band 1 besprochen, als Vorbedingungen konstruktiv eingesetzt werden, um die Ausgangssituation eines Tests herzustellen, und als Nachbedingungen eingesetzt werden, um zu beschreiben, welche Situation nach Anwendung der Funktion fur ¨ einen Testerfolg erfullt ¨ sein muss. Aus bestimmten Teilen eines Modells l¨asst sich auch kein konstruktiver Code, sondern nur Testcode generieren. Beispielsweise sind OCL-Bedingungen im Allgemeinen ausfuhrbar. ¨ Wie in Abschnitt 4.3.10, Band 1 beschrieben, gilt dies meist auch fur ¨ Quantoren, da mit Ausnahme der Quantoren uber ¨ Grunddatentypen wie int und mengen- beziehungsweise listenwertigen Typen hoheren ¨ Grades alle Quantoren endlich und damit auswertbar sind. Dennoch ist es ein wesentlicher Unterschied, ob eine in OCL formulierte Nachbedingung getestet oder konstruktiv erzwungen werden kann. Nahezu alle praktisch interessanten OCL-Bedingungen fallen in die erste Kategorie. Die Kategorie der konstruktiven OCL-Bedingungen ist allerdings deutlich kleiner. Das demonstrieren die folgenden zwei Beispiele. Sortieren Die Methode sort soll ein Array von Zahlen (int) sortieren. Eine ofter ¨ zu findende Beschreibung in Form einer Vor-/Nachbedingung ist die Folgende: 5
6
In der Theorie algebraischer Spezifikationen werden Modelle als Spezifikationen“ ” und Elemente des semantischen Domains beziehungsweise Implementierungen als Modelle“ bezeichnet. ” Um eine initiale Semantik zu besitzen, mussen ¨ bestimmte Einschr¨ankungen an die Form der Spezifikationen gestellt werden. Siehe dazu auch [EM85].
3.1 Konzepte der Codegenerierung context int[] sort(int a[]) pre: true post: forall int i in {1..result.length-1}: result[i-1] <= result[i]
57 OCL
Diese Spezifikation kann sehr einfach und in linearer Zeit getestet werden. Als konstruktive Beschreibung ist sie allerdings nicht geeignet, weil ein Generator daraus keinen Sortieralgorithmus erzeugen kann. Daruber ¨ hinaus ist sie in wesentlichen Eigenschaften unvollst¨andig, da sie nicht sichert, dass die Ausgangselemente der Reihung a[] in der Ergebnisreihung result[] wieder vorkommen mussen. ¨ Tats¨achlich w¨are daher eine Implementierung der Form result=new int[0] ebenfalls korrekt. Die konstruktive Beschreibung eines Sortieralgorithmus ist zwar im Prinzip moglich, ¨ aber genauso komplex wie eine direkte Implementierung. Gerade bei komplexen Algorithmen zeigt sich der wesentliche Vorteil deskriptiver Beschreibungen, da sie keine Implementierungsform vorwegnehmen. Sie sind daher insbesondere gegenuber ¨ effizienten Implementierungen sehr viel leichter verst¨andlich. Gleichungen als Zuweisungen Zuweisungsmethoden haben im Allgemeinen die einzige Aufgabe, das mog¨ licherweise gekapselte Attribut zu setzen: context void setAttr(Type val) pre: true post: attr==val
OCL
Diese Spezifikation ist sowohl fur ¨ Tests der Methode setAttr als auch fur ¨ eine konstruktive Umsetzung in eine Implementierung geeignet. Wird n¨amlich der Gleichheitsoperator == durch den Java-Zuweisungsoperator = ersetzt, so kann die Nachbedingung als Implementierung verwendet werden. Diese Implementierung ist allerdings nur dann wirklich korrekt, wenn keine weiteren Invarianten existieren, die eine zus¨atzliche Ver¨anderung anderer Attribute erforderlich machen. Leider ist die konstruktive Umsetzung von Nachbedingungen nur unter bestimmten, sehr eng umrissenen Rahmenbedingungen moglich. ¨ Typischerweise darf eine Nachbedingung nur aus einer Konjunktion von Zuweisungen an lokale Variablen bestehen und sp¨atere Zuweisungen durfen ¨ die fruheren ¨ nicht wieder invalidieren. Beispielsweise ist val==attr zur obigen Nachbedingung a¨ quivalent, kann aber in dieser Form nicht in Code umgesetzt werden.7 Auch die nachfolgende Bedingung ist fur ¨ eine Codegenerierung ungeeignet, da sie zyklische Abh¨angigkeiten enth¨alt: 7
Genau genommen ist val=attr in Java erlaubt, hat jedoch einen anderen Effekt als gewunscht. ¨
58
3 Prinzipien der Codegenerierung
context void method(Type val) pre: true post: a==b+1 && b==2*a-val
OCL
Fur ¨ ihre konstruktive Umsetzung ist zun¨achst das lineare Gleichungssystem zu losen ¨ und es kann konstruktiv formuliert werden: context void method(Type val) pre: true post: a==val-1 && b==val-2
OCL
Naturlich ¨ gibt es eine Reihe trickreicher Verfahren zur konstruktiven Interpretation von Bedingungen, die fur ¨ verschiedene Hochsprachen entwickelt wurden. Von denen seien insbesondere die Horn-Klausel-Logik von Prolog [Llo87], die Auswertung von in Gleichungslogik formulierter algebraischer Spezifikationen [EM85] und deren Erweiterung um Konditionale erw¨ahnt. Beispielsweise kann auch die folgende Spezifikation konstruktiv umgesetzt werden: context int abs(int val) pre: true post: if (val>=0) then result==val else result==-val
OCL
Arten der Generierung Da die Notationen der UML/P zur Modellierung von exemplarischen und vollst¨andigen Strukturen und Verhalten eingesetzt werden, eignen sie sich in unterschiedlicher Weise zur Generierung von Code. Abbildung 3.3 zeigt, welche Diagrammart haupts¨achlich (dicker Pfeil) und nebenbei (dunner ¨ Pfeil) fur ¨ welche Form der Code- beziehungsweise Testgenerierung eingesetzt wird. Es ist aber festzuhalten, dass sich nicht alle Konzepte der UML/PDokumente zur Codegenerierung eignen. UML/P erlaubt grunds¨atzlich die Abstraktion von Details, zum Beispiel durch Auslassen von Typinformation bei Attributen oder durch Unterspezifikation bei Methoden und Transitionen, so dass die F¨ahigkeit zur Code- und Testgenerierung aus einem UML/P-Artefakt unter anderem von dessen Vollst¨andigkeit abh¨angt. Intelligente Generierungsalgorithmen konnen ¨ naturlich ¨ auch unvollst¨andige Artefakte zur Generierung nutzen, indem sie die offenen Aspekte durch Defaults ausfullen. ¨ So kann zum Beispiel bei einem unvollst¨andigen Statechart ein standardm¨aßiges Fehlerverhalten hinzugefugt ¨ werden und bei Attributen ohne Typinformation versucht werden, durch Typinferenz an den Stellen der Attributnutzung den benotigten ¨ Typ auszurechnen. Der generierte Produktionscode kann dabei je nach Verwendungszweck mit zus¨atzlichem Testcode instrumentiert sein. So konnen ¨ fur ¨ Testzwecke Inspektionsmethoden, interaktive Haltepunkte, Funktionen zum Zugriff auf private Attribute oder die Prufung ¨ von Invarianten in den Produktionscode integriert sein, die bei der Erzeugung des Produktionscode fur ¨ den Einsatz
3.1 Konzepte der Codegenerierung
59
Abbildung 3.3. Generierung von Code und Tests aus UML/P
als fertiges Produkt weggelassen werden. Diese Form der Instrumentierung birgt Probleme, wenn der optimale Code Seiteneffekte beinhaltet, die das Verhalten des instrumentierten Produktionscodes ver¨andern. Es ist deshalb wichtig, dass eine solche Instrumentierung nicht manuell, sondern von Codegeneratoren durchgefuhrt ¨ wird, so dass verhaltensver¨andernde Seiteneffekte ausgeschlossen werden konnen. ¨ Die durch die Instrumentierung entstandene Ver¨anderung des zeitlichen Verhaltens muss in nebenl¨aufigen Systemen unter gesonderten Gesichtspunkten betrachtet werden. 3.1.3 Tests und Implementierung aus dem gleichen Modell Wie im vorherigen Abschnitt diskutiert, lassen sich aus manchen Modellen einerseits Tests, andererseits aber auch konstruktiver Code generieren. Die Generierung beider Codearten aus demselben Modell kann jedoch kein zus¨atzliches Zutrauen in die Richtigkeit des erstellten Systems erzeugen. Werden aus einem falschen Modell sowohl fehlerhafter Implementierungscode erzeugt als auch die Tests fur ¨ diese Implementierung abgeleitet, so sind die Tests in gleicher Weise falsch. Dies zeigt das folgende einfache Beispiel, das den Absolutwert einer Zahl berechnen soll: context int abs(int val) pre: true post: result==-val
OCL
Die Codegenerierung kann damit folgenden Java-Code erstellen: int abs(int val) { return -val; }
Java
Eine typische Sammlung von Tests benotigt ¨ mehrere Eingabewerte, auf denen getestet wird. Als gute Standardwerte haben sich fur ¨ den Datentyp
60
3 Prinzipien der Codegenerierung
int Sammlungen von Zahlen der Form −n, −2, −1, 0, 1, 2, n fur ¨ einige große n herausgestellt.8 Normalerweise werden diese vom Entwickler vorgegeben. Die erwarteten Ergebnisse mussen ¨ nicht separiert ausgerechnet werden, da mit der Nachbedingung eine Moglichkeit ¨ zur Prufung ¨ der Korrektheit des Ergebnisses existiert. Folgender Testcode wurde ¨ erzeugt werden konnen: ¨ int val[] = new int[] {-1234567,-2,-1,0,1,2,3675675}; for(int i = 0; i
Java/P
Da der Testcode genauso falsch ist wie die Implementierung, wurde ¨ der Fehler damit nicht erkannt werden. In so einer Situation wird eigentlich nicht der implementierte Code getestet, sondern es wird getestet, ob der Codegenerator korrekt funktioniert. Denn wenn in dieser Situation ein Fehler gemeldet werden wurde, ¨ dann wurde ¨ der nur auf eine Inkonsistenz zwischen dem generierten Code und dem ebenfalls generierten Testtreiber hinweisen. Ein solches Vorgehen ist genau dann interessant, wenn die Parametrisierung des Generators getestet werden soll. Als Konsequenz dieser Beobachtung ergibt sich, dass das konstruktive, zur Codegenerierung verwendete Modell und das Testmodell getrennt modelliert werden mussen. ¨ Dabei durfen ¨ Fragmente des Test- und des konstruktiven Modells in denselben Diagrammen dargestellt sein. Es ist jedoch klar zu trennen, welche Konzepte wofur ¨ verwendet werden. Beispielsweise werden Statecharts im Wesentlichen konstruktiv eingesetzt. Die in den Statecharts verwendbaren Zustandsinvarianten werden jedoch bis auf Ausnahmen nur zur Prufung ¨ in Tests eingesetzt.
3.2 Techniken der Codegenerierung 3.2.1 Plattformabh¨angige Codegenerierung Obwohl mit der Festlegung der UML/P auf die Programmiersprache Java bereits eine wesentliche Entwurfsentscheidung getroffen wurde, ist die Form des generierten Codes nicht eindeutig festgelegt. Es gibt mehrere Dimensionen von Variationen, die bei der Codegenerierung zu beachten sind. Dazu z¨ahlt zum einen die hier besprochene Plattformabh¨angigkeit, die besonders bei eingebetteten Systemen eine wesentliche Rolle spielt. Je nach Zielplattform stehen unterschiedliche Mechanismen zur Verfu¨ gung, um zum Beispiel Kommunikation im verteilten System mit den gesteuerten Anlagen, Nachbarsystemen oder Nutzern sowie Speicherung und 8
Der Auswahl der Zahlen liegt eine einfache Klassifikation fur ¨ den Wertebereich int und die Verwendung einzelner Vertreter und Grenzwerte aus den gebildeten Klassen zugrunde.
3.2 Techniken der Codegenerierung
61
Fehlerbehandlung durchzufuhren ¨ oder die Einbruchssicherheit, Datenauthentizit¨at und -integrit¨at sicher zu stellen. Diese Mechanismen konnen ¨ abh¨angig sein von der Hardware, in der die Software eingebettet ist, oder an die zur Verfugung ¨ stehenden Klassenbibliotheken beziehungsweise API’s anzupassen sein. Die dabei in generierten Code einzusetzenden Codestucke ¨ sind vom Codegenerator nicht vorauszusehen, da beispielsweise durch neue Plattformen, neue Steuerger¨ate oder neue Versionen von Klassenbibliotheken ein stetiger und schneller Wandel stattfinden kann. Deshalb ist es wesentlich, dass die Codegenerierung flexibel an die jeweiligen Rahmenbedingungen angepasst werden kann. Dazu gibt es zwei wesentliche Ans¨atze: Generierung fur ¨ abstrakte Schnittstellen, wie in Abbildung 3.4 illustriert, und die Parametrisierung der Codegenerierung, wie in Abbildung 3.5 gezeigt.
Abbildung 3.4. Generierung von Code gegen eine abstrakte Schnittstelle
Fur ¨ die Trennung von plattformspezifischem und hardwareunabh¨angigem Code ist die Bildung einer abstrakten Schnittstelle und damit die Schichtentrennung ein ideales Werkzeug, das die Portabilit¨at von Software verbessert. Viele der Java-API’s sind genau fur ¨ diesen Zweck definiert und zum Standard erhoben worden. In [SD00] wurde diese strikte Trennung von Code in Anwendungscode ( A-Code“) und plattformspezifischen, techni” schen Code ( T-Code“) detaillierter untersucht sowie notwendige Mischfor” men identifiziert. Eines der Ergebnisse dieser durch die Praxis untermauerten Untersuchungen ist dabei, dass eine standardisierte T-Architektur“, also ” der technische Code fur ¨ die Speicherung, Anzeige, Fehlerbearbeitung und a¨ hnliche standardisierbare Funktionalit¨aten, ein hohes Potential zur Wiederverwendung hat. Dieses Potential kann bei der Codegenerierung durch die flexible Kombination von T-Architektur-Anteilen mit den vom Entwickler vorgegebenen Applikations(A)-Modellen ausgeschopft ¨ werden.
62
3 Prinzipien der Codegenerierung
Abbildung 3.5. Parametrisierte Codegenerierung
Die strikte Trennung der beiden Codearten kann aber wie immer bei der Einfuhrung ¨ von Schichten und Adaptern zu Ineffizienzen fuhren. ¨ Beispielsweise basiert das Auktionssystem auf asynchroner Kommunikation von Nachrichten. Wenn die abstrakte Schnittstelle aber nur einen RPC-Mechanismus zur Verfugung ¨ stellt, so muss unter anderem die Pufferung der Nachrichten selbst codiert werden. Auf unterster Ebene wird aber wieder asynchron uber ¨ das Internet kommuniziert, wo Puffermechanismen bereits eingebaut sind. Eine Effizienzsteigerung um einen deutlichen Faktor kann zum Beispiel durch Aufgabe der konzeptuell vorhandenen Schichtenbildung und durch ein Verweben“ hoherer ¨ und niederer Schichten erreicht werden. 9 ” Alternativ kann die angebotene abstrakte Schnittstelle auch breit angelegt sein und im Beispiel sowohl synchronen RPC als auch asynchrone Kommunikation anbieten. Das fuhrt ¨ aber zu erheblichem Mehraufwand bei der Realisierung und Weiterentwicklung und zahlt sich nur aus, wenn ausreichend oft eine Wiederverwendung in anderen Projekten stattfindet. Wird die Generierung des Zielcodes daruber ¨ hinaus als korrekt angenommen und auf eine manuelle Nachbearbeitung oder Inspektion verzichtet, so ist die Schichtenbildung im generierten Code nicht essentiell. Stattdessen kann bei der Generierung mehr auf Effizienz geachtet werden und a¨ hnlich zu Optimierungstechniken der Compiler ein Verweben des plattformunabh¨angigen und -spezifischen Codes erfolgen. Dadurch entsteht nach [SD00] ein sehr schwer wartbarer AT-Code, der sowohl Anwendungs- als auch technisches Wissen beinhaltet. Auch deshalb ist es wesentlich, dass der 9
Tats¨achlich entstehen diese Schichten auch hier, jedoch ist die Schichtenarchitektur nicht horizontal (also Schicht fur ¨ Schicht) entwickelt, sondern vertikal, so dass die Bedurfnisse ¨ h¨oherer Schichten direkt beim Entwurf niederer Schichten berucksich¨ tigt werden konnten. Der Wechsel von RPC zu der selbst realisierten asynchronen Kommunikationsform wurde ubrigens ¨ mit Refactoring-Techniken [Fow99] effizient umgesetzt.
3.2 Techniken der Codegenerierung
63
generierte Code nicht manuell weiterbearbeitet wird, sondern nur die Ausgangsmodelle und die Generatorskripte. In der Praxis ist davon auszugehen, dass eine Mischform aus beiden Generierungsmechanismen zu den besten Ergebnissen fuhren ¨ wird. Daruber ¨ hinaus wird ein System eine weitere Komponente besitzen, die eine Laufzeitumgebung fur ¨ bestimmte Funktionalit¨aten zur Verfugung ¨ stellt, die weder in Java-Klassenbibliotheken noch in Java-Sprachkonzepte abgebildet werden konnen. ¨ Dazu gehoren ¨ zum Beispiel erweiterte Funktionalit¨aten zur Behandlung der in OCL verfugbaren ¨ Mengen und Listen ebenso wie die Bearbeitung von explizit im Code abgelegten Zustandsmodellen. Abbildung 3.6 beschreibt daher die prinzipielle Struktur eines Codegenerators.
Abbildung 3.6. Struktur eines Codegenerators
Der unter anderem in [BBWL01, RFBLO01] gepr¨agte Begriff der UML ” Virtual Machine“ entspricht dabei dem rechten Teil des Bildes 3.6, bestehend aus dem UML-Laufzeitsystem und einer plattformspezifischen Implementierung der festgelegten Schnittstellen. Angelehnt an die “Java Virtual Machine“, dem Interpreter des Java-Bytecodes, entspricht der Codegenerator dem Java-Compiler. Die “UML Virtual Machine“ stellt eine Art operationeller Semantik des ausfuhrbaren ¨ Teils der UML/P dar. 3.2.2 Funktionalit¨at und Flexibilit¨at Die im letzten Abschnitt angesprochene Parametrisierung der Codegenerierung kann nicht nur zur Anpassung an plattformspezifische Merkmale verwendet werden, sondern auch dafur, ¨ den erzeugten Code um zus¨atzliche Funktionalit¨at zu erweitern. Im Prinzip sind der dabei entstehenden Flexibilit¨at kaum Grenzen gesetzt. Nachfolgend wird dies an dem einfachen und
64
3 Prinzipien der Codegenerierung
weitgehend bekannten Beispiel der Codegenerierung fur ¨ Attribute im Klassendiagramm diskutiert. Ein in einer Klasse des Klassendiagramms definiertes Attribut besitzt die in Abbildung 3.7 demonstrierte naturliche“ ¨ Umsetzung als Attribut im ge” nerierten Java-Code. Mit Ausnahme der Merkmale fur ¨ abgeleitete und fur ¨ nur lesbare Attribute (/ und readonly) konnen ¨ alle Merkmale, Typen und initialen Zuweisungen an das Attribut direkt umgesetzt werden. Diese direkte Umsetzung birgt jedoch einige Nachteile, wie zum Beispiel den nicht gekapselten und nicht synchronisierten Zugriff durch andere Objekte.
Abbildung 3.7. Direkte Umsetzung von Attributen
Deshalb ist es heute nicht ublich, ¨ Attribute aus Analyse- und Entwurfsmodellen direkt in Attribute der Implementierung umzusetzen, sondern stattdessen eine Infrastruktur in Form von so genannten get- und setMethoden zur Verfugung ¨ zu stellen. Abbildung 3.8 zeigt die so entstehende Codestruktur. Dabei wird oft jedem Attributnamen ein geeigneter Pr¨afix (hier zum Beispiel der Unterstrich _“) vorangestellt. Die Verwendung von ” Zugriffsfunktionen erhoht ¨ die Flexibilit¨at. Sie erlaubt zum Beispiel die mogli¨ cherweise notwendige Synchronisation von Threads oder die Realisierung des Zugriffsrechts readonly durch zwei get/set-Methoden mit unterschiedlichen Sichtbarkeitsangaben. Die in den beiden Abbildungen 3.7 und 3.8 skizzierten Umsetzungen sind heute relativ verbreitet, aber keineswegs die einzigen. Es gibt weitere Varianten, die zum Beispiel persistente Attribute, eine Ablage der Attribute in Enterprise JavaBeans [MH00], Propagierung von Attribut¨anderungen und dergleichen mehr erlauben. Um die verschiedenen und auch nicht generell vorhersehbaren Varianten der Codegenerierung dennoch flexibel zu ermoglichen, ¨ ist es grunds¨atzlich notwendig, die Umsetzung von Konzepten der UML/P stark zu parametrisieren.
3.2 Techniken der Codegenerierung
65
Abbildung 3.8. Umsetzung von Attributen mittels Zugriffsfunktionen
In gewisser Weise sind fur ¨ die Konzepte der UML/P API’s“ 10 identifi” zierbar, die jeweils umzusetzen sind. Fur ¨ das Konzept Attribut“ der Klas” sendiagramme l¨asst sich beispielsweise folgendes API identifizieren: • • •
Setzen eines Attributs, Auslesen eines Attributs und Initialisierung eines Attributs mit einem Defaultwert. Erweiterungen dieses API’s konnen ¨ zum Beispiel fur ¨
• • •
Serialisierung, Laden aus und Speichern in einer Datenbank, Bildschirmausgabe und Einlesen aus einer Bildschirmmaske
oder fur ¨ typspezifische Funktionalit¨aten definiert werden. Dazu gehoren ¨ zum Beispiel die Inkrementierung von Zahlenwerten, das Anh¨angen von Strings (analog dem Java-Operator +=) oder die Behandlung einzelner Elemente in Containerstrukturen. Die fur ¨ eine Codegenerierung wunschenswerte ¨ Flexibilit¨at besteht also nicht nur in der Form der Umsetzung von UML/P-Konzepten, sondern auch in der damit angebotenen Funktionalit¨at. Die angebotene Funktionalit¨at muss nicht nur generiert werden, sondern auch in einer Form zur Verfugung ¨ stehen, die es dem Entwickler erlaubt, an anderer Stelle darauf zuzugreifen. Dabei gibt es zwei generelle Verfahren: 10
API im Sinne eines abstract programming interface.
66
3 Prinzipien der Codegenerierung
1. Die Umsetzung des API’s wird offen gelegt, indem zum Beispiel aus dem Namen und dem Typ eines Attributs eindeutig die Namen und Signaturen der jeweils verwendbaren Funktionen abgeleitet werden konnen. ¨ Ist also beispielsweise das Attribut title im Klassendiagramm definiert, so kann in Java mit getTitle() und setTitle(...) darauf zugegriffen werden. 2. Es wird das API selbst offengelegt, die Umsetzung aber bleibt verborgen. Der manuell geschriebene Java-Code nutzt daher direkt das API und muss bei der Codegenerierung ebenfalls transformiert werden. Im Beispiel wird dann auch im Java-Code das Attribut title benutzt. Dies wird je nach Anwendungsform bei der Codegenerierung durch eine get- oder set-Methode ersetzt. W¨ahrend der erste Ansatz zu einfacheren Codegeneratoren fuhrt ¨ und keine Behandlung des Java-Codes erfordert, ist beim zweiten Ansatz mehr Flexibilit¨at und Codierungssicherheit gegeben. Durch das Verbergen der tats¨achlichen Implementierung kann diese relativ einfach ersetzt oder erg¨anzt werden. Außerdem ist die Verwendung der API abstrakter und fuhrt ¨ zu kompakterem Code. Jedoch wird es in diesem Ansatz notwendig, bei der Codegenerierung auch direkt in Java formulierte Codeteile zu transformieren. Wie das relativ einfache Beispiel zur Realisierung von Attributen zeigt, lassen sich bereits daran viele der auftretenden Effekte studieren. Deshalb wird im folgenden Abschnitt 3.4 zun¨achst eine lesbare Form der Darstellung von Codegenerierungen beschrieben und deren Einsatzf¨ahigkeit anhand der Transformation von Attributen demonstriert. Die bei der Umsetzung von UML/P-Konzepten in die Implementierung zur Verfugung ¨ stehenden Formen der Codegenerierung haben unter Umst¨anden Auswirkungen auf die Semantik der Konzepte. Dies ist nicht unkritisch, aber auch eine Chance fur ¨ Anwender der UML, die semantischen Freiheitsgrade, oft auch als variation points“ bezeichnet, zu nutzen, um pro” jektspezifische oder zus¨atzliche Funktionalit¨aten und F¨ahigkeiten zu integrieren. Diese Freiheitsgrade pr¨azise zu beschreiben ist innerhalb der UML nicht moglich, ¨ einerseits weil die UML selbst keine Mechanismen fur ¨ ihre Semantikdefinition zur Verfugung ¨ stellt, andererseits weil diese Freiheitsgrade keine allgemeine Gultigkeit ¨ besitzen, sondern abh¨angig von potentiellen Zielplattformen und gewunschten ¨ Funktionalit¨aten sind.11 Es bleibt daher in der Praxis oft nur die Moglichkeit, ¨ jeweils einzelne Formen der Codegenerierung und die damit intendierte semantische Interpretation in konstruktiver 11
Es ist allenfalls moglich, ¨ durch die Verwendung von Stereotypen auf eine spezielle Bedeutung eines Konstrukts hinzuweisen. Die pr¨azise Definition des Stereotyps und der intendierten Semantik ist in der UML nicht moglich. ¨ Stattdessen kann aber eine informelle Beschreibung, wie die in Abschnitt 3.17, Band 1 dargestellte, verwendet werden.
3.2 Techniken der Codegenerierung
67
Form anzugeben. Eine umfassende Beschreibung der Menge mo¨ glicher Varianten in ihrer gesamten Bandbreite erscheint nicht moglich. ¨ Die bei der Codegenerierung auftretende Transformation von UML/PKonzepten in die Konzepte der Programmiersprachen besitzen einige Charakteristiken, die aus anderen Bereichen der Informatik bekannt sind. So kann eine in der Modellierung eingesetzte Datenstruktur in der Implementierung durch eine andere, vielleicht effektivere oder um zus¨atzliche Funktionalit¨at erweiterte Datenstruktur ersetzt werden und damit ein Datenstrukturwechsel stattfinden. Die Trennung der Funktionalit¨at und der plattformabh¨angigen Codeteile wurden im Bereich des Aspect-Oriented-Programming (AOP) [KLM+ 97, LOO01] beziehungsweise der damit eng verwandten generativen Programmierung [CE00] bereits eingehend diskutiert. Dabei werden Techniken vorgestellt, die eine noch weitergehende Trennung einzelner Programmaspekte erlauben. Spezielle Verfahren (so genanntes Weaving“) erlauben die Kom” bination zun¨achst unabh¨angig voneinander formulierter und meist nur uber ¨ eine abstrakte Nahtstelle (Programmierschnittstelle) verbundener Codeteile. Diese Vorgehensweise wird in eingeschr¨ankter Form auch bei der hier diskutierten Codegenerierung verwendet. Auch die in [Pre97, Pre00, KPR97] diskutierte Komposition von Klassen aus Features und deren Interaktionen kann durch einen generativen Ansatz realisiert werden. Welche Klasse bei der Generierung welche (zus¨atzlichen) Features erh¨alt, kann durch Stereotypen und Merkmale in geeigneter Form gesteuert werden. 3.2.3 Steuerung der Codegenerierung Um die bereits mehrfach erw¨ahnte, notwendige Flexibilit¨at in der Codegene¨ rierung in der vollen Bandbreite zu nutzen, muss die Ubersetzung sinnvoll gesteuert werden konnen. ¨ So ist es normalerweise sinnvoll, dasselbe Konzept innerhalb eines Projekts, ja sogar innerhalb eines Modells unterschiedlich zu realisieren. Die bereits mehrfach diskutierten Moglichkeiten ¨ zur Umsetzung von Attributen konnen ¨ zum Beispiel abh¨angig sein von • • •
der Klasse, die das Attribut beinhaltet, weil diese Klasse Aufgaben wie Datenhaltung oder Applikationssteuerung haben kann oder als Schnittstelle zu anderen Systemteilen wirkt und daher zu synchronisieren ist, der Aufgabe des Attributs innerhalb der Klasse, weil beispielsweise die Klasse persistent ist, das Attribut aber berechnet werden kann oder nur tempor¨are Daten beinhaltet oder dem Typ des Attributs, weil dieser beispielsweise in UML/P, nicht aber in Java existiert.
68
3 Prinzipien der Codegenerierung
Diese statisch, also zur Zeit der Codegenerierung festgelegten Abh¨angigkeiten konnen ¨ durch dynamische Abh¨angigkeiten erg¨anzt werden, wenn zum Beispiel ein Flag benutzt wird, um festzulegen, ob ein Objekt persistent sein soll. Projektspezifische F¨alle wie diese sollten typischerweise nicht mehr durch eine vorgegebene Semantikdefinition, sondern durch selbstdefinierten Code realisiert werden, der durch den parametrisierten Codegenerator systematisch hinzugefugt ¨ wird. Die Steuerung der Implementierungsform jedes UML/P-Konzepts kann grunds¨atzlich durch Stereotypen und Merkmale erfolgen. Jedoch ist die ausschließliche Verwendung von Stereotypen und Merkmalen in der Praxis nicht ausreichend. Stattdessen reduziert sich die Markierung der UMLDiagramme im Wesentlichen auf den Stereotyp-Namen, optional erg¨anzt um zus¨atzliche Parameterwerte. Die Umsetzung eines mit einem Stereotyp markierten UML/P-Elements in eine Implementierung wird durch zus¨atzliche Skripte vorgenommen, die durch den Codegenerator ausgefuhrt ¨ werden und diesen, wie in Abbildung 3.6 gezeigt, sehr flexibel parametrisieren.
3.3 Semantik der Codegenerierung Eine Codegenerierung ist vor allem eine Transformation einer Sprache in eine andere Sprache. Auch eine Semantikdefinition ist im Wesentlichen eine Abbildung einer als unbekannt betrachteten Sprache (hier also UML/P) in eine als bekannt und als verstanden angesehene Zielsprache. Ist die Zielsprache daruber ¨ hinaus formal und die Abbildung pr¨azise formuliert, so wird auch von einer formalen Semantik gesprochen. In diesem Sinn kann eine durch ein Programm implementierte Abbildung der UML/P in die Programmiersprache Java selbst als eine formale Semantik verstanden werden. Dabei gibt es allerdings mehrere Punkte, die bei dieser Argumentation zu beachten sind: 1. Es ist fur ¨ das Verst¨andnis einer Sprache wie UML/P hilfreich, mehr als nur eine Bedeutungserkl¨arung (Semantik) zur Verfugung ¨ zu haben. Durch Verwendung mehrerer Herangehensweisen zur Definition einer Semantik einer Sprache werden unterschiedliche Probleme erkannt und konnen ¨ so in die Sprachdefinition und deren Benutzung (Analyse, Tests, Refactoring) zuruckfließen. ¨ 2. Der generierte Code ist typischerweise nicht unbedingt gut lesbar, denn er enth¨alt im Allgemeinen eine Vielzahl von technischen Details. Es ist daher nicht allgemein zumutbar, zum Verst¨andnis der Bedeutung einer Modellierungssprache den generierten Code inspizieren zu mussen. ¨ Allerdings gibt es eine Reihe von Sprachbeschreibungen, die darauf beruhen, das Prinzip der Codegenerierung allgemein zu diskutieren. Sie sprechen damit ein breites Publikum an, da heute Programmiersprachen wie Java die am weitesten verbreiteten formalen Sprachen“ sind. ”
3.3 Semantik der Codegenerierung
69
3. Bestimmte Aspekte einer Sprache konnen ¨ bei der Umsetzung in ablauff¨ahigen Code nicht oder nur mit großem Aufwand umgesetzt werden. Dazu gehoren ¨ zum Beispiel Konzepte, die Unterspezifikation erlauben und die in der UML/P an mehreren Stellen eingebaut sind. So konnen ¨ initialisierende Werte fur ¨ Attribute fehlen oder im Statechart mehrere alternative Transitionen gleichzeitig schaltbereit sein. Der dabei entstehende Nichtdeterminismus wird bei einer Codegenerierung im Normalfall durch die Auswahl einer hoher ¨ priorisierten Transition aufgelost ¨ (siehe Abschnitt 6.4.4, Band 1). Das durch den generierten Code beschriebene System ist daher im Allgemeinen nicht identisch zum Ausgangsmodell, sondern stellt eine von mehreren mo¨ glichen Spezialisierungen dar. 4. Die UML/P ist teilweise auf Ausfuhrbarkeit ¨ ausgelegt, erlaubt jedoch an vielen Stellen die Verwendung von nicht ausfuhrbaren ¨ Konzepten. Dazu gehoren ¨ neben den bereits erw¨ahnten Moglichkeiten, ¨ Aspekte wegzulassen, unter anderem die Spezifikation von Bedingungen mit unendlichen Quantoren. Auch die nachfolgend noch genauer diskutierte Frage der Umsetzung von OCL-Nachbedingungen gehort ¨ zu diesem Problemkreis. Daher ist eine vollst¨andige Abbildung von UML/P nach Java nicht moglich. ¨ Als Alternative zu diesen sehr impliziten Semantikdefinitionen lassen sich Techniken der formalen Methoden einsetzen, um eine formale Semantik fur ¨ die Quellsprache, unabh¨angig von der Codegenerierung, zu definieren. Typischerweise sind solche Semantikdefinitionen ebenfalls Abbildungen mit einer UML-Variante als Quelle. Als Zielsprachen werden jedoch mathematisch formale Kalkule ¨ verwendet und die Abbildungen in kompakter Form dargestellt, so dass sie einer Analyse leichter zug¨anglich werden.12 Wie in [HR00] und [Rum98] argumentiert, kann die Existenz zweier Abbildungen fur ¨ eine Quellsprache verwendet werden, um das Zutrauen in die Korrektheit beider Abbildungen und damit insbesondere in die Codegenerierung zu erhohen. ¨ Ist die Codegenerierung in der hier vorgeschlagenen Form parametrisiert und haben die benutzten Skripte Einfluss auf Verhalten und Struktur des generierten Codes, so kann dies auf zwei Arten in eine formale Semantikdefinition einbezogen werden. Abbildung 3.9 formalisiert eine Variante zur Semantikdefinition, in der die Semantikabbildung unabh¨angig vom benutzten Skript ist. Die in Abbildung 3.9 dargestellte Formalisierung nutzt die mengenwertige Semantikabbildung, um damit die Variabilit¨at des parametrisierten Codegenerators darzustellen. Die Formalisierung h¨angt sehr stark von den da12
Eine sich davon dezidiert unterschiedene Form, zum Beispiel eine axiomatische Semantikdefinition fur ¨ die UML oder einzelnen Teilen, ist bisher nur in [EHHS00] und [EH00] zu finden und basiert auf einem transformationellen Ansatz dem Graphgrammatiken zugrunde liegen.
70
3 Prinzipien der Codegenerierung
Zur Formalisierung einer Sprache und der Codegenerierung werden folgende Definitionen benotigt: ¨ •
die Quellsprache (UML/P) als eine Menge UML von syntaktisch wohlgeformten Ausdrucken, ¨
•
eine geeignete formale Zielsprache mit dem Sprachschatz Z,
•
die Skriptsprache des Codegenerators mit dem Sprachschatz S und
•
die Menge J aller Java-Programme.
Ein Codegenerator ist eine unter Umst¨anden partielle Abbildung Gen : UML → J. Eine formale Semantik ist demgegenuber ¨ eine Abbildung Sem : UML → P(Z). Damit wird einem einzelnen typischerweise unterspezifizierten und abstrakten Modell aus der Quellsprache eine Menge von mo¨ glichen Implementierungen zugewiesen, die mit eben diesem Modell gemeint sind. Dies stellt eine Form der losen Semantik dar. Fur ¨ einen Vergleich beider Abbildungen Sem und Gen ist eine Semantik fur ¨ JavaProgramme in der Form SemJ ava : J → Z notwendig. Dann muss fur ¨ jedes UMLDokument u ∈ UML, fur ¨ das Code generiert werden kann, gelten: ∀u ∈ UML : SemJ ava (Gen(u)) ∈ Sem(u) Das heißt, im Allgemeinen w¨ahlt der Codegenerator eine von mehreren mo¨ glichen Implementierungen aus, indem er etwa offene Aspekte durch Defaults ausfullt. ¨ Nur wenn Sem(u) ein einziges Element darstellt, war die Spezifikation offensichtlich vollst¨andig und eindeutig. Ein parametrisierter Codegenerator wird um die Parameter, also die Skriptsprache S, erweitert: Genp : UML × S → J. Es muss nun gelten: ∀u ∈ UML, s ∈ S : SemJ ava (Genp (u, s)) ∈ Sem(u) Das heißt, im Rahmen der Vorgabe durch Sem(u) darf das Skript s eine mogliche ¨ Implementierung fur ¨ u ausw¨ahlen. Abbildung 3.9. Semantik des parametrisierten Codegenerators
durch beobachteten Aspekten einer Sprache ab. Wird zum Beispiel nur das extern sichtbare Verhalten formalisiert, so sind in Bezug auf Umsetzung von Attributen, Assoziationen und anderen Strukturelementen Freiheiten gegeben. Tats¨achlich ist es fur ¨ eine so umfangreiche Sprache wie die UML kaum praktikabel, eine vollst¨andige Formalisierung vorzunehmen, obwohl dies in ¨ [Ove00] bemerkenswert vollst¨andig, aber nicht sehr elegant gelungen ist. Stattdessen ist es sinnvoll, einzelne, kritische Aspekte genauer zu beleuchten und damit Ruckkopplung ¨ in den Standardisierungsprozess zu geben. In einer Reihe von Publikationen wurden auch die prinzipiellen Vorteile und Probleme einer Standardisierung diskutiert [BHH+ 97, FELR98b, FELR98a], die unter anderem in den Proceedings der UML-Konferenzen [BM98, FR99, EKS00, GK01] zu finden sind.
3.4 Parametrisierung eines Werkzeugs
71
Eine alternative Sichtweise zu der in Abbildung 3.9 dargestellten Form ist die Einbeziehung der Skriptsprache S in die Semantikdefinition. Quellsprache und Skriptsprache stellen dann in gewisser Weise die gemeinsame Pro” grammiersprache“ dar. Eine Semantikdefinition kann dies in Form einer Funktion Semp : UML × S → Z widerspiegeln, die die Auswahl genau eines Elements der Zielsprache Z vornimmt.
3.4 Parametrisierung eines Werkzeugs In diesem Abschnitt wird zun¨achst die Frage nach einer geeigneten Skriptsprache diskutiert und dann eine kompakte Form der Darstellung der Effekte solcher Skripte eingefuhrt. ¨ Im Kapitel 4 werden die Eigenschaften dieser Skripte anhand einer exemplarischen Umsetzung der UML/P-Konstrukte demonstriert. Die hier diskutierten Konzepte stellen for allem Bezug zu einem Codegenerator her, sind aber auf andere Formen von Analysewerkzeugen und Transformatoren ebenfalls anwendbar. Zum Beispiel konnen ¨ damit auch Datenstrukturwechsel oder Refactoring-Techniken beschrieben werden. 3.4.1 Implementierung von Werkzeugen In Abschnitt 3.2.3 wird die Verwendung von Skripten zur flexiblen Parametrisierung eines Codegenerators, aber auch fur ¨ Analyse- und Testwerkzeuge diskutiert. Tats¨achlich erfordert eine plattformspezifische und eine auf verschiedene Implementierungsmoglichkeiten ¨ ausgerichtete Codegenerierung einen flexiblen Mechanismus zur Steuerung der Codegenerierung. Die Generierung kann im Prinzip durch Stereotypen und Merkmale gesteuert werden. Die Details des zu erzeugenden Codes konnen ¨ mit Stereotypen aber nicht oder zumindest nicht komfortabel festgehalten werden. Im Allgemeinen konnen ¨ die zu erzeugenden Codestrukturen sehr komplex sein und unterschiedlichste Formen haben. Meist sind Symboltabellen notwendig und Nebenbedingungen zu prufen, ¨ die die Anwendbarkeit einer Codegenerierung oder mogliche ¨ Optimierungen beschreiben. Aufgrund der erforderlichen Flexibilit¨at kommt nur eine in ihrer Beschreibungsm¨achtigkeit (weitgehend) vollst¨andige Programmiersprache in Betracht, die eine kompakte Formulierung von Bedingungen und Transformationen erlaubt. Pro” gramme“ dieser Sprache werden vom Codegenerator zur Ausfuhrung ¨ gebracht, um den Implementierungscode zu erzeugen. Sie sind selbst zur Laufzeit nicht vorhanden. Abbildung 3.10 beschreibt die daraus resultierende innere Struktur eines Generators. Fur ¨ Skriptsprachen wurden in der Werkzeugentwicklung unterschiedliche Vorschl¨age gemacht. So sind interpretierte Derivate der Sprache C ebenso in Verwendung wie Visual Basic, Skriptsprachen wie Pearl, Tcl/Tk oder sogar Eigenentwicklungen. Funktionale Programmiersprachen wie ML
72
3 Prinzipien der Codegenerierung
Abbildung 3.10. Innere Struktur eines Codegenerators
[Pau94, MTHM97] bieten daruber ¨ hinaus eine sehr kompakte Form, solche Werkzeuge zu parametrisieren. Zum Beispiel ist das Verifikationswerkzeug Isabelle [NPW02] in ML geschrieben und bietet damit gute, ebenfalls in ML zu formulierende Erweiterungsmoglichkeiten. ¨ Eine weitere Alternative ist die zur Zeit immer popul¨arer werdende XML-Technologie [McL01, W3C00] und die Verwendung von XML/XSLTbasierten Werkzeugen zur Transformation in den Zielcode. Allerdings besitzt XML durch die explizite Einbettung der Tags (Nichtterminale) einerseits ein sehr schlechtes Verh¨altnis zwischen Struktur- und Nutzinformation und andererseits sind die heutigen Parse- und Transformationswerkzeuge fur ¨ die XML noch nicht so leistungsf¨ahig, wie die im Bereich des Compilerbau l¨angst bekannten Yacc/Lex und deren Derivate. Mit ihrer Vielzahl an Bibliotheken, Frameworks und Werkzeugen sowie der Moglichkeit ¨ des dynamischen Ladens von Klassenbibliotheken ist auch Java ein guter Kandidat, einerseits, um damit einen Codegenerator zu realisieren und andererseits, um damit die Parametrisierung uber ¨ einen Plugin-Mechanismus zu ermoglichen. ¨ Beispielsweise nutzt das Werkzeug Poseidon [BS01a, BBWL01] diesen Mechanismus. Eine aktive Skriptsprache besitzt jedoch Defizite bei der Darstellung der Form der Zielsprache. Deshalb bietet sich zus¨atzlich die Verwendung eines Makro-Ersetzungsmechanismus an, der Templates13 verarbeitet und daraus Code erzeugt. Ein Template ist als passive Skriptsprache zu sehen, die Makros beinhaltet, die durch den Ersetzungsalgorithmus zum Beispiel durch echte Namen oder Ausdrucke ¨ ersetzt werden. Ein Template kann aktive Ele13
Der englische Begriff Template“ hat sich in diesem Kontext eingeburgert, ¨ so dass ” er auch in diesem Buch gegenuber ¨ der deutschen Version Codeschablone“ bevor” zugt wird.
3.4 Parametrisierung eines Werkzeugs
73
mente beinhalten, um damit Kontrollstrukturen, wie Alternative, Wiederholung oder Einbindung anderer Templates zu ermoglichen, ¨ aber auch um Berechnungen in beschr¨anktem Maß durchzufuhren. ¨ Verwendbar sind hierbei XML auf der Transformationssprache XSLT basierende Werkzeuge oder ein mit Java-Code kombinierter Template-Mechanismus a¨ hnlich der JSP-Seiten [FK00], der zum Beispiel von [SvVB02] vorgestellt wird. Aus der notwendigen Programmierbarkeit des Generators folgt, dass Entwickler nicht nur in der Entwicklungsprogrammiersprache, sondern in eingeschr¨ankter Form auch in der Skriptprogrammiersprache entwickeln mussen. ¨ Aufgrund der o¨ fter notwendigen Anpassungen muss dies parallel zur eigentlichen Entwicklung geschehen. Es ist daher fur ¨ das Erlernen von Vorteil, wenn sich Skript- und Programmiersprache a¨ hnlich sind, oder sogar ubereinstimmen. ¨ Generell kann davon ausgegangen werden, dass ein Framework allgemein verwendbarer Skripte und Templates zur Verfugung ¨ stehen wird, das fur ¨ Projekte individuell anzupassen ist. Eine Wiederverwendung der Templates vollig ¨ ohne Anpassung ist zum Beispiel im Hinblick auf die Generierung von graphischen Oberfl¨achen unwahrscheinlich. Ist eine Entscheidung zugunsten einer Skriptsprache und einer TemplateSprache gefallen, so stellt sich die Frage, ob sich die Effekte der Skripte fur ¨ den Anwender des Generators in kompakter, verst¨andlicher, aber gegebenenfalls informeller Form darstellen lassen, die nicht auf der doch mit vielen Implementierungsdetails behafteten Skriptsprache beruhen. Dieser Wunsch wird noch verst¨andlicher, wenn die XML-basierte und damit sehr verbose Transformationssprache XSLT verwendet werden soll. 3.4.2 Darstellung von Skripttransformationen Der Effekt eines fur ¨ die Codegenerierung verwendeten Skripts beruht darauf, UML/P-Konzepte in die Zielprogrammiersprache Java zu transformieren. Da ein solches Skript auch Rand- und Sonderf¨alle behandelt, Rahmenbedingungen pruft ¨ und dazu eine Reihe von Hilfsfunktionen nutzt, ist es zweckm¨aßig den Effekt eines solchen Skripts in kompakter Form darzustellen, dabei Sonderf¨alle nur informell zu diskutieren und so fur ¨ den Anwender verst¨andlich zu machen. Dazu wird die Schablone in Tabelle 3.11 vorgeschlagen, in der neben der eigentlichen Transformation Kontextbedingungen eine allgemeine Beschreibung angegeben und potentielle Alternativen diskutiert werden konnen. ¨ Diese Beschreibung ist weder als vollst¨andig noch als formal anzusehen, obwohl sie einigen nachfolgend beschriebenen Einschr¨ankungen unterliegt. Diese Schablone stellt eher eine Form von Pseudocode fur ¨ die Beschreibung von Transformationen dar.
74
3 Prinzipien der Codegenerierung
Name der Transformation Erkl¨arung Transformationsregel
Motivation und Zweck der Transformation. Meist gibt es eine prim¨are Transformationsregel, die in folgender Form dargestellt wird: Ursprung ⇓ Ziel • Ursprung und Ziel konnen ¨ dabei jeweils textuell oder durch ein Diagramm dargestellt werden. • Der Ursprung fuhrt ¨ die Elemente der Syntaxklassendiagramme und EBNF-Produktionen ein, die transformiert werden. Der Kontext wird ebenfalls aufgelistet. Dafur ¨ werden schablonenartige Diagramme und Textstucke ¨ verwendet. • Die kursiven Namen stellen Schemavariablen dar, die bei der Anwendung der Transformation mit echten Sprachelementen belegt werden. • Erkl¨arende Texte beschreiben die Arten der Schemavariablen, welche Teile optional sind oder mehrfach auftreten konnen, ¨ etc. • Die Inhalte der Schemavariablen konnen ¨ selbst gewissen Transformationen unterliegen. So kann die Schemavariable attr dazu genutzt werden, einen Methodennamen setAttr zu konstruieren, der aus dem konstanten Teil set und der kapitalisierten Form des Attributnamens zusammengesetzt ist.
weitere Aus der Haupttransformation ergeben sich meist zus¨atzlich Transforma- notwendige Transformationen, die in analoger Form dargetionen stellt werden. Diese Transformationen beziehen sich zum Beispiel auf Elemente der in Abschnitt 3.2.2 diskutierten API, die ebenfalls zu transformieren sind. Beachtens- Dieser Abschnitt rundet durch zus¨atzliche Betrachtungen, wert Hinweise und die Diskussion potentieller Problemstellungen die Beschreibung ab. Tabelle 3.11.: Name der Transformation Der verwendete Regelmechanismus ist angelehnt an formale Regelkalkule ¨ der Form
3.4 Parametrisierung eines Werkzeugs
75
Ursprung Rahmen⇓ bedingungen, Ziel die neben Ursprung und Ziel eine pr¨azise Angabe der Rahmenbedingungen in einer formalen Notation enthalten. Der Ursprung enth¨alt Schemavariablen (Platzhalter, [BBB+ 85]), die bei der Anwendung der Transformation mit echten Sprachelementen belegt werden. Jede Schemavariable ist einem bestimmten Nichtterminal zugeordnet, ist also damit typisiert. Nachfolgend ein Anwendungsbeispiel fur ¨ eine Standardtransformation, die die in Abbildung 3.8 exemplarisch gezeigte Codegenerierung vornimmt.14 Wie bereits in Abschnitt 3.2.2 besprochen, stellt die hier dargestellte Umsetzung nur eine von mehreren Moglichkeiten ¨ dar, die zum Beispiel durch die Verwendung geeigneter Stereotypen und Merkmale am Attribut, der Klasse oder dem Klassendiagramm, aber auch durch Angabe bestimmter Skripte ausgew¨ahlt werden konnen. ¨ Attribut1: Standardtransformation von Attributen Erkl¨arung
¨ Die Standardform zur Ubersetzung von Attributen mit Kapselung und Zugriff durch explizite Zugriffsfunktionen. Typ- oder projektspezifische Funktionalit¨aten sind nicht enthalten.
Attributdefinition
⇓
class Class { ... Java private Type attr = value; tags’ synchronized Type getAttr() { return attr; } tags” synchronized Type setAttr(Type a) { return attr=a; } } (Fortsetzung auf n¨achster Seite)
14
Allerdings unter Verzicht auf die in manchen Codierungsstandards propagierte Verwendung von fuhrenden ¨ Unterstrichen fur ¨ Attribute.
76
3 Prinzipien der Codegenerierung (Fortsetzung von Tabelle 3.12.: Attribut1: Standardtransformation von Attributen)
• Die optionale Besetzung mit =value wird nur verwendet, wenn sie im Diagramm angegeben ist. • Die in tags angegebene Sichtbarkeit wird mit Ausnahme von readonly ubernommen. ¨ readonly wird bei getAttr (also in tags’) in public umgesetzt und bei tags” in protected. • return ist bei setAttr sinnvoll, denn die Zuweisung mit = hat denselben Wert. • Die Kardinalit¨at des ubersetzten ¨ Attributs ist entweder nicht angegeben und damit 1“ oder 0..1“. ” ” Attributzugriff
attr ⇓ getAttr()
quali.attr ⇓ quali.getAttr()
• Typ von Ausdruck quali ist konform zur Klasse Class. Attributbesetzung
attr=expr ⇓ setAttr(expr)
quali.attr=expr ⇓ quali.setAttr(expr)
• Typ von Ausdruck quali ist konform zur Klasse Class. • Typ von Ausdruck expr ist konform zum Attributtyp Type. Beachtenswert
Typspezifische Konstrukte wie attr++ konnen ¨ entweder durch zus¨atzliche Funktionalit¨at effizient umgesetzt oder in setAttr(getAttr()+1) transformiert werden. Merkmale und Stereotypen werden in dieser Standardumsetzung nicht berucksichtigt. ¨ In UML ist es moglich, ¨ Attributen eine Kardinalit¨at zuzuordnen. Im Fall *“ ist eine Umsetzung a¨ hnlich der Assoziation ” vorzunehmen.
Tabelle 3.12.: Attribut1: Standardtransformation von Attributen
4 Transformationen fur ¨ die Codegenerierung
Wer klare Begriffe hat, kann befehlen. Johann Wolfgang von Goethe
¨ Dieses Kapitel erg¨anzt die prinzipiellen Uberlegungen zur Codegenerierung aus Kapitel 3 um konkrete Techniken. Dabei wird die Vorgehensweise zur Umsetzung von Klassendiagrammen, Objektdiagrammen, der Codegenerierung aus der OCL, der Ausfuhrung ¨ von Statecharts und der Testgenerierung aus Sequenzdiagrammen in jeweils einem der Abschnitte 4.1 bis 4.5 erkl¨art. Bei den Klassendiagrammen werden dabei eher bereits bekannte Konzepte in kompakter Form als Transformationen aufbereitet und Alternativen diskutiert. Insbesondere der Abschnitt 4.1 uber ¨ Klassendiagramme dient dabei zur Demonstration der systematisierten Darstellung von Transformationsregeln fur ¨ die Codegenerierung. Fur ¨ Statecharts werden Generierungsalternativen intensiv diskutiert. Fur ¨ alle anderen Notationen werden vor allem grundlegende Prinzipien der ¨ Ubersetzung behandelt, weil so Nutzern unter anderem die Moglichkeit ¨ ge¨ geben wird, auf die Zielsprache bzw. Zielumgebung zugeschnittene Ubersetzungsformen selbst zu entwickeln bzw. in Abwesenheit eines geeigneten Werkzeugs diese manuell durchzufuhren. ¨
4.1 4.2 4.3 4.4 4.5 4.6
¨ Ubersetzung von Klassendiagrammen . . . . . . . . . . . . . . . . ¨ Ubersetzung von Objektdiagrammen . . . . . . . . . . . . . . . . . Codegenerierung aus OCL . . . . . . . . . . . . . . . . . . . . . . . . . . . Ausfuhrung ¨ von Statecharts . . . . . . . . . . . . . . . . . . . . . . . . . . ¨ Ubersetzung von Sequenzdiagrammen . . . . . . . . . . . . . . . Zusammenfassung zur Codegenerierung . . . . . . . . . . . . . .
78 102 112 125 136 140
78
4 Transformationen fur ¨ die Codegenerierung
¨ 4.1 Ubersetzung von Klassendiagrammen In diesem Abschnitt wird die Transformation von Konzepten des Klassendiagramms und einiger damit zusammenh¨angender Elemente in Java als komplexeres Beispiel durch eine Sammlung von Transformationsregeln beschrieben, die auch die Moglichkeiten ¨ zur Beschreibung von Alternativen ¨ und von Komposition der Regeln zeigen. Bei dieser Ubersetzung werden weder Java-Frameworks oder Infrastrukturkonzepte wie JavaBeans oder Middleware-Komponenten noch Datenbank-Anbindungen berucksichtigt. ¨ Dafur ¨ sind jeweils spezielle Generatoren notwendig, die in der hier angestrebten allgemeinen Form nicht diskutiert werden konnen. ¨ 4.1.1 Attribute Fur ¨ normale und statische Attribute von Klassen wurde mit der Transformationsregel Attribut1 von Seite 75 bereits eine Regel zur Umsetzung angegeben. Diese kann im Prinzip auch fur ¨ abgeleitete Attribute verwendet werden, ignoriert jedoch ein wesentliches Merkmal dieser Art von Attributen. Im Normalfall existiert fur ¨ ein abgeleitetes Attribut eine als Invariante formulierte Berechnungsvorschrift. Alternativ dazu kann auch eine bereits in der Zielsprache Java formulierte Methode existieren, die die Berechnung des Attributs vornimmt. Nach unserer Konvention heißt eine solche Methode calcAttr. Attribut2eager : Abgeleitete Attribute - Eager Version Erkl¨arung
Fur ¨ ein abgeleitetes Attribut /attr existiert eine Berechnungsvorschrift als OCL-Invariante der Form attr=expr oder eine Methode calcAttr. ¨ Anderungen der zur Berechnung verwendeten Attribute treten gegenuber ¨ der Abfrage des abgeleiteten Attributs selten auf. Deshalb wird das abgeleitete Attribut sofort neu berechnet und gespeichert. (Fortsetzung auf n¨achster Seite)
¨ 4.1 Ubersetzung von Klassendiagrammen
79
(Fortsetzung von Tabelle 4.1.: Attribut2 eager : Abgeleitete Attribute - Eager Version)
Attributdefinition
⇓
class Class { ... Java private Type attr; tags’ synchronized Type getAttr() { return attr; } private synchronized void calcAttr() { attr = expr’; } }
• Attributdefinition und getAttr werden wie bei der Standardregel Attribut1 transformiert. Eine setAttr Methode existiert jedoch nicht. • Ist die Berechnungsvorschrift als nicht-rekursive OCLBedingung in der Form attr=expr angegeben, so wird diese in Java-Code expr’ transformiert und in die Methode calcAttr eingebettet. Alternativ kann diese Methode bereits existieren oder durch eine Nachbedingung in der angegebenen Form spezifiziert sein. Attributzugriff
attr ⇓ getAttr()
quali.attr ⇓ quali.getAttr()
• Wie in Transformationsregel Attribut1. Attributbesetzung Besetzung eines Ausgangsattributs
ist nicht moglich. ¨ durch Analyse des OCL-Ausdrucks beziehungsweise der vorhandenen calcAttr-Implementierung konnen ¨ die Ausgangsattribute ermittelt werden, von denen attr abgeleitet ist. Fur ¨ jedes Ausgangsattribut source wird die set-Methode erweitert: (Fortsetzung auf n¨achster Seite)
80
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.1.: Attribut2 eager : Abgeleitete Attribute - Eager Version)
⇓ Java
class Class { ... tags’ synchronized Type’ setSource(Type’ a) { source=a; calcAttr(); return a; } }
• Dies zeigt nur den (einfachen) Fall, dass Ausgangs- und abgeleitetes Attribut in demselben Objekt lokalisiert sind. Ist das nicht der Fall, muss eine bidirektionale Verbindung zwischen beiden Objekten bestehen, die durch die aktuellen Ver¨anderungen nicht beeintr¨achtigt sein sollte.1 Beachtenswert
Die Ver¨anderung eines Attributs hat die automatische Ver¨anderung aller davon abgeleiteten Attribute zur Folge. Dies kann zu kaskadenartigen Neuberechnungen abgeleiteter ¨ Attribute fuhren ¨ und ineffizient sein, wenn mehr Anderungen als Abfragen auftreten. Zirkul¨are Abh¨angigkeiten fuhren ¨ daruber ¨ hinaus zu nichtterminierenden Neuberechnungen und sind daher verboten.
Tabelle 4.1.: Attribut2eager : Abgeleitete Attribute - Eager Version Der oben formulierten eager“ Version der Umsetzung kann eine lazy“ ” ” Version entgegengesetzt werden, die den Attributwert nur bei Bedarf berech¨ net. Aufgrund der Ahnlichkeiten zur vorherigen Transformationsregel wird diese verkurzt ¨ wiedergegeben:
1
Die Bidirektionalit¨at ist notwendig, weil die Berechnung nicht dem Kontrollfluss folgt, sondern eine Form der Change-Propagation (Publisher-Subscriber-Pattern) und damit eine Umkehrung der Berechnungsabh¨angigkeiten realisiert wird. Eine Datenflussanalyse kann prufen, ¨ ob dieses Pattern mit all seiner Infrastruktur eingebaut werden muss oder eine bidirektionale Assoziation vorhanden ist. Bei einem geeigneten Generator kann auch durch den Anwender eingegriffen werden, um eine optimale Umsetzung zu sichern.
¨ 4.1 Ubersetzung von Klassendiagrammen
81
Attribut2lazy : Abgeleitete Attribute - Lazy Version Erkl¨arung
Fur ¨ ein abgeleitetes Attribut /attr existiert eine Berechnungsvorschrift als OCL-Invariante der Form attr=expr oder eine Methode calcAttr. ¨ Die H¨aufigkeit der Anderungen der zur Berechnung verwendeten Attribute liegt in einer a¨ hnlichen Großenordnung ¨ wie die Abfrage des abgeleiteten Attributs. Deshalb wird das abgeleitete Attribut erst bei Bedarf berechnet und nicht gespeichert.
Attributdefinition
⇓
class Class { ... tags’ synchronized Type getAttr() { return calcAttr(); } private synchronized Type calcAttr() { return expr’; } }
Java
• Siehe Anmerkungen zu Attribut2eager . Attribute
Beachtenswert
• Attributzugriff erfolgt wie bei Attribut2eager . • Die direkte Attributbesetzung ist wie bei Attribut2eager nicht moglich. ¨ • Die Besetzung eines Ausgangsattributs (von dem dieses abh¨angt) muss nicht angepasst werden. Vorteil gegenuber ¨ der Attribut2eager Version ist, dass der Kontrollfluss nicht invertiert wurde und damit keine bidirektionale Assoziationen oder eine andere Infrastruktur notwendig sind. Ineffizienz kann aber durch wiederholt durchgefuhrte ¨ Berechnung des Attributs entstehen. Zirkul¨are Abh¨angigkeiten fuhren ¨ auch hier zu nichtterminierenden Neuberechnungen und sind daher verboten.
Tabelle 4.2.: Attribut2lazy : Abgeleitete Attribute - Lazy Version Eine im Bereich der graphischen Oberfl¨achen gelegentlich verwendete Form des Model-View-Controller-Pattern nutzt Vorteile beider Ans¨atze, in-
82
4 Transformationen fur ¨ die Codegenerierung
dem die change propagation nur in einer booleschen Statusvariable vermerkt wird, aber eine Neuberechnung erst bei Bedarf erfolgt. 4.1.2 Methoden Fur ¨ die Implementierung von Methoden stehen mehrere Strategien zur Verfugung, ¨ die von der Ausgangsituation abh¨angig sind: 1. Der Methodenrumpf ist bereits formuliert und muss nur in die Methode eingesetzt werden. Dabei werden auch die notwendigen Transformationen beispielsweise von Attributzugriffen vorgenommen. 2. Die Methode ist durch ein Vor-/Nachbedingungspaar beschrieben, wobei die Nachbedingung, wie in Abschnitt 3.1 diskutiert, algorithmisch formuliert ist und direkt in Code umgesetzt werden kann. 3. Die Methode ist durch ein Vor-/Nachbedingungspaar beschrieben, das aber nicht algorithmisch umsetzbar und deshalb nur fur ¨ Tests geeignet ist. 4. Ein Methoden-Statechart (siehe Abschnitt 6.4.3, Band 1) beschreibt den Ablauf der Methode. 5. Fur ¨ diese Methode gibt es noch keine Implementierung oder Spezifikation. Fur ¨ jeden dieser F¨alle ist eine eigenst¨andige Vorgehensweise sinnvoll. Der erste Fall benotigt ¨ nur die Integration des Methodenrumpfs mit der Signatur sowie die Umsetzung zum Beispiel der Attributzugriffe im Methodenrumpf. Methode1impl : Methoden mit gegebener Implementierung Erkl¨arung
Eine Methode meth mit gegebenem Methodenrumpf code wird in Java umgesetzt.
Methodendefinition
(Fortsetzung auf n¨achster Seite)
¨ 4.1 Ubersetzung von Klassendiagrammen
83
(Fortsetzung von Tabelle 4.3.: Methode1impl : Methoden mit gegebener Implementierung)
• Der Methodenrumpf code besteht aus einer Sequenz von Anweisungen. Diese wird entsprechend der gultigen ¨ Transformation fur ¨ Anweisungen in code’ transformiert, um zum Beispiel Attributzugriff und -besetzung oder die Umsetzung von Zusicherungen (assertions) zu behandeln. • Sind Sichtbarkeitsangaben, Parameternamen, -typen und Ergebnistyp teilweise im Text und im Diagramm gegeben, so durfen ¨ sie sich erg¨anzen, aber nicht widersprechen. Tabelle 4.3.: Methode1impl : Methoden mit gegebener Implementierung Fur ¨ die Beschaffung des Methodenrumpfs gibt es in den heute verfugba¨ ren Werkzeugen mehrere Ans¨atze. Eine Moglichkeit ¨ ist, den Rumpf als Textstuck, ¨ zum Beispiel als Kommentar, der Methodensignatur im Diagramm zu hinterlegen und durch Anw¨ahlen zug¨anglich zu machen. Dies ist allerdings fur ¨ große Systeme mit vielen Methoden nicht praktikabel. Die Technik des Round Trip Engineering“ liest die Methodenrumpfe ¨ direkt aus dem Quell” code, um sie dorthin zuruck ¨ zu schreiben.2 Hier wird eine weitere Alternative vorgeschlagen, die einige Vorteile des Aspect Oriented Programming mit einer kompakten Aufschreibung vereint. Grundidee ist es, Methodenimplementierungen nicht notwendigerweise nur nach der Klassenzugeho¨ rigkeit, sondern auch nach funktionalen Kriterien zusammenzufassen. So konnen ¨ beispielsweise die protocol-Methoden aller Klassen, die Methoden zum Durchlauf einer Teilehierarchie oder die Serialisierungsmethoden mehrerer Klassen jeweils in eine Datei zusammengefasst werden, die dann diesen Aspekt des Programms beinhaltet. Neben oder statt Java-Implementierungen konnen ¨ auch OCL-Spezifikationen von Methoden in der Form von Vor- und Nachbedingungspaaren verwendet werden. In Abschnitt 4.4.3, Band 1 ist die Integration mehrerer solcher Methodenspezifikationen behandelt worden. Deshalb kann hier von einem einzelnen Paar ausgegangen werden. Ist die Spezifikation algorithmisch in der in Abschnitt 3.1.2 diskutierten Form, so kann daraus direkt Code erzeugt werden.3 2
3
Round Trip Engineering“ erlaubt es, sowohl in der abstrakten Diagrammsicht ” als auch in der Implementierung Ver¨anderungen vorzunehmen, die dann in der jeweils anderen Sicht nachgezogen werden. Diese Vorgehensweise ist jedoch fragil, da nach heutigem Stand der Technik nur Kommentare verwendet werden, um die Verbindung zwischen beiden Sichten aufrecht zu erhalten. Die Ausfuhrbarkeit ¨ besteht im Wesentlichen darin, dass die Nachbedingungen aus einer Konjunktion von Gleichungen besteht, deren linke Seiten ver¨anderbare Attribute beziehungsweise das Ergebnis darstellen und die rechten Seiten diese Attribute in nur eingeschr¨ankter Form benutzen. Zum Beispiel durfen ¨ keine zirkul¨aren
84
4 Transformationen fur ¨ die Codegenerierung
Weil die Umsetzung einer derartig spezifizierten Methode im Wesentlichen auf der in Abschnitt 4.3 diskutierten Umsetzung von OCL in Java-Code beruht, soll hier auf eine explizite Formulierung der Transformationsregel verzichtet werden. Im dritten oben genannten Fall existiert sowohl eine Implementierung als auch eine Spezifikation. Damit ist es sinnvoll, die Spezifikation zur Prufung ¨ w¨ahrend der Laufzeit einzusetzen. Der Generator weiß, ob er effizienten Produktionscode oder mit diesen Prufungen ¨ instrumentierten Code erzeugen ¨ soll. Zum Beispiel bieten Eiffel- und Java 1.4-Ubersetzer die Moglichkeit, ¨ Zusicherungen optional zu ubersetzen. ¨ Im Prinzip ist nur die Vorbedingung vor Start der Methode und die Nachbedingung nach deren Ende zu testen. Dabei sind jedoch unter Umst¨anden mit dem let-Konstrukt lokal definierte Variable und eventuell in der Nachbedingung genutzte Anfangszust¨ande von Attributen zu sichern. Diese Sicherung kann komplex sein, wenn die benutzten Attribute in anderen Objekten liegen und die Zugangspfade ihrerseits ver¨andert worden sein konnen. ¨ Eine uber ¨ den Abschnitt 4.4.3, Band 1 hinausgehende ausfuhrliche ¨ Diskussion dieser Problematik ist zum Beispiel in [RG02] zu finden. Auch die in Abschnitt 6.4.3, Band 1 diskutierten Methoden-Statecharts konnen ¨ zur Implementierung einer Methode verwendet und dabei wie oben beschrieben mit einer Vor-/Nachbedingung kombiniert werden. Die wesentlichen Strategien zur Umsetzung von Statecharts werden in Abschnitt 4.4 behandelt und basieren auf der in Abschnitt 6.6.2, Band 1 beschriebenen vereinfachenden Transformation fur ¨ Statecharts. Dabei entsteht ein Coderumpf, der dann, wie in der Transformation Methode1impl (Seite 82) beschrieben, eingesetzt werden kann. Als letzte Variante soll hier noch der Fall kurz diskutiert werden, in dem es weder eine Implementierung noch eine algorithmisch ausfuhrbare ¨ Spezifikation fur ¨ eine Methode gibt. Dann kann die Methode nicht automatisiert implementiert werden. Fur ¨ Simulationen und Tests, die diese Methode vielleicht nur marginal beruhren, ¨ sind jedoch Strategien moglich ¨ und sinnvoll, gute Implementierungen zu generieren. • • •
Spielt die Methode bei den durchzufuhrenden ¨ Tests keine Rolle, so kann ein Fehleraufruf oder die Ruckgabe ¨ eines Default-Werts in die Methode generiert werden. Ist die Methode noch nicht realisiert, so kann ein interaktives Eingabefeld w¨ahrend Simulationsl¨aufen dazu benutzt werden, dass der Nutzer auf Basis der aktuellen Parameter jeweils selbst das Ergebnis bestimmt. Fur ¨ eine, gezwungenermaßen endliche Menge von Eingaben konnen ¨ in einer Tabelle Ergebnisse abgelegt sein. Diese Ergebnisse konnen ¨ sogar aus fruheren ¨ interaktiven Simulationsl¨aufen mitprotokolliert worden sein. Abh¨angigkeiten zwischen Attributen bestehen, um eine sequentielle Berechnung zu ermoglichen. ¨ Jede Gleichung darf zus¨atzlich mit einer Bedingung versehen sein.
¨ 4.1 Ubersetzung von Klassendiagrammen
85
Einerseits ist eine interaktive Eingabe von Ergebnissen einzelner Methoden fur ¨ automatisierte Testl¨aufe nicht sinnvoll, andererseits konnen ¨ damit w¨ahrend der Vorfuhrung ¨ eines Prototypen sofort Anwenderentscheidungen in das System zuruckgef ¨ uhrt ¨ werden. Diese konnen ¨ protokolliert und sp¨ater zum Beispiel als Testdaten genutzt werden. Diese interaktive Form des Erkenntnisgewinns ist sicherlich beschr¨ankt, kann aber unter Umst¨anden zu effektiverer Kommunikation mit Anwendern fuhren. ¨ Es ist generell nicht ublich, ¨ Hilfsmethoden wie getAttr in Klassendiagrammen explizit zu vermerken. Dadurch bleibt das Modell kompakter und ubersichtlicher. ¨ Auch mussen ¨ diese Funktionen in Coderumpfen, ¨ die bei der Generierung ubersetzt ¨ werden, nicht explizit verwendet werden. Es reicht aus, den Attributzugriff und die Attributbesetzung in Form von Zuweisungen einzusetzen. Ein Codegenerator ubersetzt ¨ diese wie in den Transformationsregeln beschrieben in Methodenaufrufe. Es sollte jedoch erlaubt sein, diese Methoden direkt zu verwenden. Außerdem ist unter Umst¨anden sinnvoll, die Generierung einer solchen Methode vorwegzunehmen, indem eine manuelle Implementierung angegeben wird. Dadurch lassen sich eventuell Optimierungen vornehmen oder zus¨atzliche Funktionalit¨aten realisieren. 4.1.3 Assoziationen Eine unidirektionale Assoziation wird standardm¨aßig durch ein Attribut umgesetzt. Der Rollenname wird dabei als Attributname verwendet. Fehlt der notwendige Rollenname, so wird wie bei den in Abschnitt 4.3.8, Band 1 angegebenen Navigationsregeln ein Attributname aus dem Assoziationsnamen oder dem Namen der gegenuberliegenden ¨ Klasse gebildet. Kardinalit¨aten werden entsprechend berucksichtigt: ¨ 0..1“ fuhrt ¨ zu ei” nem einfachen Attribut, das den Wert null annehmen darf, 1“ fuhrt ¨ zu ” einem einfachen Attribut, das immer besetzt ist, und eine Assoziation mit Kardinalit¨at *“ wird mengenwertig. Abh¨angig von zus¨atzlichen Merkma” len wie {ordered} stehen Mengen- oder Listen-Implementierungen zur Auswahl. Fur ¨ qualifizierte Assoziationen wird entsprechend eine Abbildung (Map) zur Verfugung ¨ gestellt. Bidirektionale Assoziationen werden durch Attribute auf beiden Seiten realisiert, die durch ein geeignetes Methodenprotokoll konsistent gehalten werden. Ist keine Navigationsrichtung angegeben, so wird eine geeignete Navigationsrichtung aus dem Kontext ermittelt und gegebenenfalls werden beide Richtungen realisiert. Um die oben genannte Konsistenz bidirektionaler Assoziationen zu sichern, werden alle Zugriffe auf die Assoziation uber ¨ generierte Methoden gefuhrt. ¨ Die Form dieser generierten Methoden, also das fur ¨ eine Assoziation verwendbare API, h¨angt von den Eigenschaften und Merkmalen der Assoziation ab. So werden bei den Merkmalen {addOnly} und {frozen} entsprechende Funktionen zur Modifikation eingeschr¨ankt. Abgeleitete Assoziationen wer-
86
4 Transformationen fur ¨ die Codegenerierung
den mit denselben Prinzipien behandelt, wie abgeleitete Attribute. Das heißt, es werden nur Abfragemethoden zur Verfugung ¨ gestellt und diese durch Berechnungen implementiert. Nachfolgende Transformation ist exemplarisch fur ¨ bidirektionale, in beiden Richtungen mit Kardinalit¨at *“ versehene Assoziationen. ” Assoziation∗,∗,bidir : Bidirektionale Assoziation Erkl¨arung
Assoziationen werden in den Zustandsraum zumindest einer der beteiligten Klassen transformiert, indem entsprechende Attribute und Zugriffsfunktionen generiert werden. Diese Transformationsregel ist fur ¨ bidirektionale Assoziationen mit Kardinalit¨at *“ in beiden Richtungen geeignet. Die ” Assoziation ist nicht abgeleitet und keine Komposition.
Definition der Assoziation
• Nachfolgende Ausfuhrungen ¨ gelten fur ¨ ClassB entsprechend, da die Situation symmetrisch ist. • Zugriffe auf die Assoziation werden durch Zugriffe auf das Attribut roleB modelliert, das die in Abschnitt 4.3.5, Band 1 eingefuhrte ¨ Signatur von Collection(ClassB) besitzt. • Der Attributname roleB extrahiert sich aus dem Rollennamen, dem Namen der Assoziation (assocname) oder wenn beide fehlen, dem Namen der gegenuberliegenden ¨ Klasse (classB). Allerdings muss die Eindeutigkeit des Namens gew¨ahrleistet sein (siehe Abschnitt 4.3.8, Band 1). • Die Umsetzung der zur Modellierung verwendeten Konstrukte in den Implementierungscode erfolgt relativ schematisch, jedoch werden ver¨andernde Operationen wie addRoleB oder removeRoleB entsprechend angepasst, um damit die Konsistenz der bidirektionalen Assoziation sicherzustellen. (Fortsetzung auf n¨achster Seite)
¨ 4.1 Ubersetzung von Klassendiagrammen
87
(Fortsetzung von Tabelle 4.4.: Assoziation∗,∗,bidir : Bidirektionale Assoziation)
Zugriffsfunktionen
roleB.isEmpty() ⇓ roleB.isEmpty() roleB.size ⇓ roleB.size()
roleB.contains(obj) ⇓ roleB.contains(obj) etc.
• Lesende Zugriffe bleiben weitgehend erhalten. Die Umsetzung entspricht der Standardumsetzung des OCLCollection-Interface nach Java. Modifikation
roleB.add(obj) ⇓ addRoleB(obj)
quali.roleB.add(obj) ⇓ quali.addRoleB(obj)
roleB.remove(obj) ⇓ removeRoleB(obj)
quali.roleB.remove(obj) ⇓ quali.removeRoleB(obj)
etc. • Modifizierende Zugriffe werden auf speziell generierte Methoden abgebildet. • Weitere modifizierende Zugriffe, wie zum Beispiel roleB.clear(), werden ebenfalls entsprechend abgebildet. OCLNavigation
roleB ⇓ getRoleB()
quali.roleB ⇓ quali.getRoleB()
• getRoleB liefert als Ergebnis eine unver¨anderbare Menge.4 (Fortsetzung auf n¨achster Seite)
4
Die Methode unmodifiableSet der Klasse java.util.Collections produziert aus einer beliebigen eine unver¨anderbare Menge, ohne allerdings die Signatur zu ver¨andern.
88
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.4.: Assoziation∗,∗,bidir : Bidirektionale Assoziation)
Zus¨atzliche Methoden
⇓ Java
class ClassA { ... public synchronized Set(ClassB) getRoleB() { return Collections.unmodifiableSet(roleB); } public synchronized void addRoleB(ClassB b) { roleB.add(b); b.addLocalRoleA(this); } public synchronized void addLocalRoleB(ClassB b) { roleB.add(b); } }
• Hilfsfunktionen wie addLocalRoleB oder removeLocalRoleB durfen ¨ außerhalb dieses Protokolls nicht benutzt werden, obwohl sie als public generiert werden. Sie stehen deshalb dem Entwickler nicht zur 5 Verfugung. ¨ • Weitere Modifikatoren wie removeRoleB oder clearRoleB werden in a¨ hnlicher Form generiert. Allerdings erfordert zum Beispiel clearRoleB in bidirektionalen Assoziationen die Abmeldung jedes Links auf der gegenuberliegenden ¨ Seite, hat also lineare Komplexit¨at. • Ist das Merkmal {addOnly} angegeben, so stehen remove-Operationen nicht zur Verfugung. ¨ • Ist das Merkmal {ordered} angegeben, so wird eine Listen-Implementierung gew¨ahlt und die entsprechende Funktionalit¨at zus¨atzlich angeboten. Beachtenswert
Die durch ein Protokoll gesicherte Konsistenz zwischen beiden Enden einer bidirektionalen Assoziation besitzt im Normalfall nur konstanten Zusatzaufwand, ist also vertretbar. Ist eine Assoziation nur unidirektional, so kann dieser Aufwand dennoch wegfallen.
Tabelle 4.4.: Assoziation∗,∗,bidir : Bidirektionale Assoziation
5
Dies kann einerseits durch geeignete Kontextprufungen ¨ bei den Coderumpfen ¨ gesichert, andererseits aber auch durch Verwendung außerhalb des Generators nicht bekannter Methodennamen erreicht werden.
¨ 4.1 Ubersetzung von Klassendiagrammen
89
Die Umsetzung von Assoziationen in Java-Code zeigt, wie groß die Variationsmoglichkeiten ¨ bei der Codegenerierung sind. Variabel abh¨angig von den Eigenschaften der Assoziation ist nicht nur das API einer Assoziation (also welche Funktionen in UML/P zum Zugriff und zur Manipulation zur Verfugung ¨ stehen), sondern auch die intern genutzte Datenstruktur. Da die Wahl der Datenstruktur zumindest Auswirkungen auf das Laufzeitverhalten der Implementierung hat, wird sinnvollerweise durch geeignete Steuerungsmechanismen wie etwa dem Merkmal {Vector} oder durch geeignete Anpassung der Skripte die Auswahl der Implementierung ermoglicht. ¨ Fur ¨ Assoziationen mit beschr¨ankten Kardinalit¨aten ist außerdem zu kl¨aren, wie der Versuch einer Verletzung der Kardinalit¨at behandelt wird. Dafur ¨ gibt es zum Beispiel die Varianten, dies robust zuzulassen, aber gegebenenfalls eine Warnung zu protokollieren, bis hin zur Erzeugung einer Exception, die dann vom aufrufenden Objekt zu behandeln ist. Neben der oben vorgeschlagenen Form der Implementierung einer Assoziation gibt es Vorschl¨age, die Links durch eigenst¨andige Objekte zu realisieren oder durch eine global verwaltete Datenstruktur zu ersetzen. All diese Erweiterungen haben als Ziel, zus¨atzliche Funktionalit¨at anzubieten, die durch das API der Modellierung zug¨anglich werden, oder Verhaltens- beziehungsweise Sicherheitseigenschaften zu optimieren. Eine globale Datenstruktur in Form einer Abbildung von Quell- zu Zielobjekt ist zum Beispiel von Interesse, wenn die Assoziation dunn ¨ besetzt ist und der Speicherplatz dadurch effizienter genutzt wird. Dies sollte dem Nutzer der API verborgen bleiben, da es sich um Realisierungsdetails handelt. Die notwendige Umsetzung von Java-Code zur Sicherung der Konsistenz der Assoziation zeigt, dass es wichtig ist, dass der Codegenerator die vollst¨andige Kontrolle uber ¨ alle Teile des generierten Codes, also auch uber ¨ Methodenrumpfe ¨ hat. Dadurch wird beispielsweise die fur ¨ bidirektionale Assoziationen gultige ¨ Konsistenzbedingung gesichert: context ClassA a, ClassB b inv: a.roleB.contains(b) <=> b.roleA.contains(a)
OCL
Das bereits diskutierte Verfahren des Roundtrip-Engineering kann dies nicht leisten, da es dem Entwickler die Moglichkeit ¨ gibt, beliebig in generierte Datenstrukturen einzugreifen. Dort musste ¨ also diese Konsistenzbedingung zur Laufzeit gepruft ¨ werden. Bei einer Transformation der Methodenrumpfe ¨ durch den Codegenerator konnen ¨ die Zugriffe und Modifikationen fur ¨ die Assoziation uberpr ¨ uft ¨ beziehungsweise transformiert und damit verhindert werden, dass dem Entwickler die Methode addLocalRoleB zur Programmierung zur Verfugung ¨ steht.6 6
Meistens wird den generierten Methoden ein anderer, nur intern bekannter Name gegeben und damit auch eine zuf¨allige Namensubereinstimmung ¨ verhindert. Dadurch kann der Entwickler eine beliebige Methode addLocalRoleB definieren, die mit der generierten Methode nicht in Zusammenhang steht.
90
4 Transformationen fur ¨ die Codegenerierung
4.1.4 Qualifizierte Assoziation Die qualifizierte Assoziation bietet gegenuber ¨ der normalen Assoziation ein angepasstes API, das die qualifizierte Selektion und Manipulation erlaubt, aber auch einige Operationen zur Modifikation unqualifizierter Assoziationen verbietet. Deshalb wird fur ¨ die qualifizierte Assoziation eine eigene Transformationsliste angegeben, die auch das API beschreibt. Assoziationquali : Qualifizierte Assoziation Erkl¨arung
Eine qualifizierte Assoziation wird a¨ hnlich der normalen Assoziation umgesetzt, bietet aber angepasste Funktionalit¨at fur ¨ qualifizierten Zugriff. Diese Transformationsregel ist geeignet fur ¨ unidirektionale qualifizierte Assoziationen mit Kardinalit¨at 1“.7 Die Assozia” tion ist weder abgeleitet noch eine Komposition. Der angegebene Qualifikator qualifier ist ein Attribut der gegenuberliegenden ¨ Klasse. Der Qualifikatorwert ist deshalb identisch zu dem Attributwert.
Definiten der Assoziation
• Zugriffe auf die Assoziation werden durch Zugriffe auf das Attribut roleB modelliert, das eine Signatur der Form Map(QualiType,ClassB) besitzt. • Zus¨atzliche Methoden der unqualifizierten Assoziationen, wie das nachfolgend definierte addRoleB, sind moglich, ¨ weil der Qualifikator im Zielobjekt enthalten ist. (Fortsetzung auf n¨achster Seite)
7
Wie in Abschnitt 3.3.7, Band 1 beschrieben, bedeutet die Kardinalit¨at 1“, dass der ” qualifizierte Zugriff genau ein Objekt liefert.
¨ 4.1 Ubersetzung von Klassendiagrammen
91
(Fortsetzung von Tabelle 4.5.: Assoziationquali : Qualifizierte Assoziation)
Zugriffsfunktionen
roleB.get(key) ⇓ roleB.get(key)
roleB.isEmpty ⇓ roleB.isEmpty()
roleB.containsValue(obj) ⇓ roleB.containsValue(obj)
roleB.keySet() ⇓ roleB.keySet()
roleB.containsKey(obj) ⇓ roleB.containsKey(obj)
roleB.values() ⇓ roleB.values()
roleB.size ⇓ roleB.size() • Lesende Zugriffe bleiben weitgehend erhalten. Modifikation
roleB.clear() ⇓ roleB.clear() roleB.removeValue(obj) ⇓ roleB.remove(obj.qualifier)
roleB.put(key,obj) ⇓ putRoleB(key,obj) roleB.removeKey(obj) ⇓ roleB.remove(obj)
roleB.add(obj) ⇓ roleB.put(obj.qualifier,obj)
etc.
• Weitere modifizierende Zugriffe, wie zum Beispiel roleB.putAll, werden entsprechend abgebildet. • Die Methode remove(obj) fur ¨ unqualifizierte Assoziationen wird fur ¨ diese Form der qualifizierten Assoziationen nicht angeboten, weil eine gleichnamige Methode fur ¨ Maps eine andere Funktionalit¨at erfullt ¨ (sie entfernt Schlussel¨ werte). Stattdessen werden zwei Operationen mit jeweils eigenem Namen angeboten. • Bei gesetztem Merkmal {addOnly} stehen die removeOperationen nicht zur Verfugung. ¨ OCLNavigation
roleB ⇓ roleB.values()
roleB[key] ⇓ roleB.get(key)
• Qualifizierte und unqualifizierte Navigation sind moglich. ¨ (Fortsetzung auf n¨achster Seite)
92
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.5.: Assoziationquali : Qualifizierte Assoziation)
Zus¨atzliche Methoden
⇓ Java
class ClassA { ... public synchronized Collection(ClassB) getRoleB() { return Collections.unmodifiableCollection( roleB.values()); } public synchronized void putRoleB (QualiType q, ClassB b) { if(q==b.qualifier) { // Objekttypen nutzen equals() roleB.put(q,b); } else { // Exception, Warnung oder // robuste Implementierung } } }
• Die Methode putRoleB wird verwendet, um sicherzustellen, dass der Qualifikatorwert (Schlussel) ¨ und der Wert des Attributs qualifier identisch sind. Beachtenswert
Abh¨angig vom Zweck des Codes (Test, Simulation, Produktion) werden verschiedene Strategien fur ¨ die Behandlung des Fehlerfalls von einer Fehlermeldung uber ¨ eine Mitteilung in einem Protokoll bis hin zur robusten Implementierung eingesetzt. Der Zugriff auf das hier verwendete Attribut roleB ist entsprechend der fur ¨ dieses Attribut gultigen ¨ Transformation ebenfalls umzusetzen. Tabelle 4.5.: Assoziationquali : Qualifizierte Assoziation
Die Transformation der qualifizierten Assoziation nutzt die Komponierbarkeit von Transformationsregeln, da hier zun¨achst eine Assoziation in ein Attribut transformiert wird, das durch eine weitere Transformation durch Zugriffsmethoden gekapselt wird. Bei dieser Kapselung durch Zugriffsmethoden ist allerdings zu beachten, dass die Methode getroleB zwei unterschiedliche Aufgaben zu erfullen ¨ hat. Bei qualifizierten Assoziationen ist zwischen (1) der Menge aller durch die Links erreichbaren Objekte und dem (2) Attributinhalt zu unterscheiden. Nur bei normalen Assoziationen sind beide Bedeutungsvarianten identisch. Die Methode getroleB realisiert Vari-
¨ 4.1 Ubersetzung von Klassendiagrammen
93
ante (1). Fur ¨ die Variante (2) wird bei Bedarf eine Methode mit dem Namen getroleBAttribute eingefuhrt, ¨ die hier ein Map-Objekt zuruckgibt. ¨ Durch die zahlreichen qualifizierten Zugriffsmoglichkeiten ¨ sollte jedoch der Zugriff auf die realisierende Map-Datenstruktur durch den Modellierer nicht notwendig sein. 4.1.5 Komposition Wie bereits in Abschnitt 3.3.4, Band 1 diskutiert, besteht zwischen den Lebenszyklen des Kompositums und den davon abh¨angigen Objekten eine zeitliche Beziehung. Diese ist jedoch durch erhebliche Interpretationsunterschiede gekennzeichnet. Die Komposition wird strukturell wie eine normale Assoziation behandelt, das Anlegen beziehungsweise Entfernen von Links aus einer Komposition unterliegt aber der jeweiligen Interpretation. Entsprechend werden einige Operationen des Assoziations-API nicht angeboten oder unterliegen Restriktionen. Eine Interpretation des Kompositums, die relativ verbreitet ist und im Auktionsprojekt als einzige verwendet wurde, wird nachfolgend dargestellt. Kompositionf rozen : Fixierte Komposition Erkl¨arung
Kompositionsdefinition
Die fixierte Form der Komposition wird genutzt, wenn das abh¨angige Objekt dieselbe Lebensspanne wie das Kompositum hat, w¨ahrend der Initialisierungsphase des Kompositums erzeugt wird und der Link zwischen beiden Objekten unver¨anderbar ist. Diese Transformationsregel ist geeignet fur ¨ die unidirektionale Kompositionen mit Kardinalit¨at 1“. ”
• Die Struktur entspricht einer Assoziation mit derselben Kardinalit¨at. • Zugriffe auf die Assoziation werden durch Zugriffe auf das Attribut roleB modelliert, das einen einfachen Objekttyp hat. (Fortsetzung auf n¨achster Seite)
94
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.6.: Kompositionf rozen : Fixierte Komposition)
• Der Attributname roleB extrahiert sich aus dem Rollennamen, dem Namen der Assoziation (assocname) oder wenn beide fehlen (was bei Kompositionen h¨aufig der Fall ist), dem Namen der gegenuberliegenden ¨ Klasse (classB). Allerdings muss die Eindeutigkeit des Namens gew¨ahrleistet sein (siehe Abschnitt 4.3.8, Band 1). Zugriffsfunktion
roleB ⇓ roleB • Lesende Zugriffe auf das Attribut werden durch eine nachgeschaltete Transformationsregel (normalerweise in getRoleB()) umgesetzt.
Modifikation
Die Besetzung des Attributs roleB darf ausschließlich im Konstruktor, also der Initialisierungsphase erfolgen.8 Dafur ¨ wird entweder eine Factory oder ein new-Kommando eingesetzt: roleB=factory.newClassB(arguments) roleB=new ClassB(arguments). Eine statische Analyse sichert, dass die einmalige Besetzung des Attributs in jedem Fall stattfindet. • Im Fall einer bidirektionalen Komposition wird in dem abh¨angigen Objekt durch einem in der Transformation Assoziation∗,∗,bidir beschriebenen Verfahren der entsprechende Link ebenfalls gesetzt. Dazu wird die oben gezeigte Besetzung mit roleB= durch einen Methodenaufruf setRoleB ersetzt.
OCLNavigation Beachtenswert
wie in vorangegangenen Transformationsregeln Die Restriktion, dass das abh¨angige Objekt erst im Konstruktor des Kompositums erzeugt wird, stellt sicher, dass abh¨angige Objekte nicht mehrfach verwendet werden.9 Eine weniger strikte Umsetzung wurde ¨ zum Beispiel erlauben, das abh¨angige Objekt bereits als Parameter an den Konstruktor zu uberge¨ ben. Dann kann jedoch nicht mehr sicher festgestellt werden, ob das Objekt neu erzeugt wurde und damit der Kompositionsbeziehung genugt. ¨ Tabelle 4.6.: Kompositionf rozen : Fixierte Komposition
8 9
Bei bestimmten Klassen, zum Beispiel Applets, ist die Initialisierung in eine Methode init() ausgelagert, die dann zur Initialisierungsphase z¨ahlt. Dabei wird angenommen, dass eine gegebenenfalls verwendete Factory tats¨achlich neue Objekte erzeugt.
¨ 4.1 Ubersetzung von Klassendiagrammen
95
4.1.6 Klassen ¨ Die Ubersetzung einer Klasse mit ihren Attributen, Methoden, Assoziationen, Kompositionen und den bislang noch nicht besprochenen Vererbungsbeziehungen ist relativ schematisch, da die kanonische Vorgehensweise die direkte Abbildung der UML-Klasse in die Java-Klasse ist. Die Umsetzung von Klassen ist jedoch stark getrieben durch Stereotypen und Merkmale, die steuern, welche zus¨atzliche Funktionalit¨at und welche Varianten der Transformation von Attributen vorgenommen werden. In dieser Grundtransformation werden keine Stereotypen berucksichtigt. ¨ Klassen: Umsetzung einer Klasse Erkl¨arung
Eine Klasse wird direkt ubernommen. ¨ In Abh¨angigkeit der ihr beigefugten ¨ Stereotypen und Merkmale sowie genereller ¨ Ubersetzungsvorgaben wird fur ¨ die Klasse zus¨atzliche Funktionalit¨at generiert, die dem Entwickler bei der Benutzung der Klasse zur Verfugung ¨ steht.
Klassendefinition
• Vererbung und Interface-Implementierung werden uber¨ nommen. • Attribute, Assoziationen werden entsprechend der jeweils gultigen ¨ Regeln zu Code transformiert. • Stereotypen und Merkmale steuern sowohl die Umsetzung der genannten Modellierungselemente als auch die Generierung zus¨atzlicher Funktionalit¨at. Vergleichsfunktion
⇓ class Class { ... public boolean equals(Object obj) { // Vergleich der Attribute } }
Java
(Fortsetzung auf n¨achster Seite)
96
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.7.: Klassen: Umsetzung einer Klasse)
• Die Methode equals vergleicht die einzelnen, neu definierten Attribute und verwendet die gleichnamige Methode der Oberklasse. • Assoziationen und abgeleitete Attribute werden im Normalfall zum Vergleich nicht berucksichtigt, ¨ jedoch aber Kompositionen, bei denen die gerade bearbeitete Klasse das Kompositum darstellt. • Das Merkmal {Equals=Liste} erlaubt die explizite Auflistung, welche Attribute und Assoziationen in den Vergleich einbezogen werden. Abkurzend ¨ kann mit dem Merkmal Equals+ eine Liste zus¨atzlicher Assoziationen oder mit Equals- eine Negativliste auszunehmender Attribute spezifiziert werden. • Ist fur ¨ die Klasse eine equals-Methode bereits explizit angegeben, so wird diese ubernommen ¨ anstatt sie zu generieren. Hashfunktion
⇓
class Class { ... Java public int hashCode() { // geeignete Berechnung aus den Attributen } }
• Die Hash-Funktion wird geeignet implementiert. • Mit den Merkmalen {Hash=Liste}, {Hash+} und {Hash-} kann analog zur Vergleichsfunktion gesteuert werden, welche Attribute dafur ¨ herangezogen werden. • Ist fur ¨ die Klasse eine hash-Methode bereits explizit angegeben, so wird diese ubernommen. ¨ Stringumwandlung
⇓
class Class { ... public String toString() { // Umsetzung der Attribute, Assoziationen } }
Java
(Fortsetzung auf n¨achster Seite)
¨ 4.1 Ubersetzung von Klassendiagrammen
97
(Fortsetzung von Tabelle 4.7.: Klassen: Umsetzung einer Klasse)
• Die Methode toString liefert eine einfache Umsetzung in einen String, der die Inhalte der beteiligten Attribute wiedergibt. Diese Form der Ausgabe dient vor allem fur ¨ Tests und Simulationen und sollte im Produktionssystem normalerweise nicht eingesetzt werden. • Assoziationen, die im Zustandsraum der Klasse abgelegt sind, abgeleitete Attribute und Kompositionen werden miteinbezogen. • Die Merkmale {ToString=Liste}, {ToString+} und {ToString-} erlauben die Kontrolle daruber, ¨ welche Klassenelemente ausgegeben werden. • Das Merkmal {ToStringVerbosity=Nummer} erlaubt die Steuerung der Verbosit¨at. 0: Keine Ausgabe, 1: Klassenname, 2: Attributinhalte sehr kompakt (ohne erreichbare und abh¨angige Objekte) und 6: verbose Ausgabe jedes Attributs und jeder Assoziation in der Form Attributname=Attributwert, die alle erreichbaren Objekte einschließt. • Ist fur ¨ die Klasse eine toString-Methode bereits explizit angegeben, so wird diese ubernommen. ¨ Konstruktoren
⇓
class Class { ... Java public Class() { // geeignete Besetzung der Attribute mit Defaults } public Class(Attributlist) { setAttribute(attribute); ... } }
• Konstruktoren werden gem¨aß der Generierungsstrategie erzeugt. • Wenn nicht explizit ausgeschlossen, dann ist standardm¨aßig der leere Konstruktor und ein Konstruktor zur Besetzung aller Attribute dabei. • Weil das Merkmal {new(Attributlist)} mehfrach anwendbar ist, konnen ¨ beliebig viele Konstruktoren erzeugt werden. Alternativ ist es auch moglich, ¨ Konstruktoren direkt anzugeben, weil so zus¨atzliche Funktionalit¨at im Konstruktor realisiert werden kann. (Fortsetzung auf n¨achster Seite)
98
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.7.: Klassen: Umsetzung einer Klasse)
Protokollausgabe
⇓ Java
class Class { ... public String stringForProtocol() { // Umsetzung der Attribute, Teile der Assoziationen } }
• Diese Methode arbeitet a¨ hnlich wie toString, wird aber fur ¨ die Ausgabe in Protokollen verwendet. Sie kann analog parametrisiert beziehungsweise manuell implementiert werden. Beachtenswert
Neben stringForProtocol gibt es eine Reihe weiterer Funktionen, die in entsprechender Form realisiert werden, aber hier nicht erw¨ahnt wurden. Einige sind aus der von allen Objekten abgeleiteten Klasse Object (beispielsweise clone), andere folgen aus Interfaces, die zu implementieren sind (beispielsweise compareTo aus dem Interface Comparable) und wieder andere sind bedingt durch Implementierungsvorgaben fur ¨ den Codegenerator. Dazu gehoren ¨ Funktionalit¨aten fur ¨ die Protokollausgabe wie oben beschrieben, Speicherung, Fehlerbehandlung und zus¨atzliche Funktionen, die zur Bearbeitung von Tests hilfreich sind. Tabelle 4.7.: Klassen: Umsetzung einer Klasse
Gerade fur ¨ den Einsatz in Testumgebungen sind unter Umst¨anden eine Reihe weiterer Methoden und Datenstrukturen fur ¨ eine Klasse zu generieren. Bei der Generierung solcher uniformen Methoden fur ¨ Implementierung und Tests kann ein Codegenerator wertvolle Dienste leisten. Eine der wenigen und eher selten gew¨ahlten Alternativen zu der hier beschriebenen Abbildung sei dennoch erw¨ahnt. Sie verzichtet darauf, das Typsystem der Zielsprache Java zu nutzen und legt stattdessen Attribute als Abbildung des Attributnamens auf den Wert mit dem Hashtable (String, Object) ab. Es ist dann im Prinzip ausreichend, eine einzige Java-Klasse in der in Abbildung 4.8 dargestellten Form zu realisieren, die zwar einiges an zus¨atzlicher Flexibilit¨at mit sich bringt, aber ineffizienter ist. Eine a¨ hnliche Form wird zum Beispiel zur Ressourcen-Verwaltung von Parametern verwendet. 4.1.7 Objekterzeugung Ein letzter interessanter Punkt im Kontext der Codeerzeugung fur ¨ Klassen ist das Management ihrer Objekte. Dazu gehort ¨ beispielsweise die Erzeugung
¨ 4.1 Ubersetzung von Klassendiagrammen class Chameleon { ... // Tr¨ager aller Attribute Hashtable(String,Object) attributes;
99 Java
public Object get(String attributeName) { return attributes.get(attributeName); }
}
// Typprufung: ¨ feststellen, ob bestimmte Attribute vorhanden sind public boolean isInstanceOf(Set(String) attributeNames) { return attributes.keySet().containsAll(attributeNames); }
Abbildung 4.8. Dynamische Verwaltung von Attributen
von Objekten, die Verwaltung und der effiziente Zugriff auf einzelne Objekte oder das Speichern und Laden von Datenbanken. Verwaltungst¨atigkeiten werden oft so genannten Management-Objekten“ auferlegt, die neben einer ” Sammlung der im Speicher befindlichen Objekte die transaktionsgesteuerte Abbildung auf die Datenbank und den effizienten Zugriff geladener Objekte erlauben. Von all diesen T¨atigkeiten soll nachfolgend nur die Objekterzeugung in Java diskutiert werden, da sie unter anderem fur ¨ Tests instrumentierbar sein muss. Die in den Coderumpfen ¨ verwendete Form des new Class(...) kann bei der Codeerzeugung durch den Aufruf geeigneter Factory-Methoden umgesetzt werden. Dies erhoht ¨ die Flexibilit¨at bei der Codeerzeugung betr¨achtlich, da so Unterklassen verwendet oder in automatisierten Tests Dummies 10 eingesetzt werden konnen. ¨ Dieses Verfahren basiert auf dem Entwurfsmuster Abstract Factory aus [GHJV94]. Objekterzeugung: Objekte mit einer Factory erzeugen Erkl¨arung
Im Quellcode wird die Objekterzeugung mit dem newKonstrukt vorgenommen. Der generierte Code enth¨alt stattdessen Factory-Aufrufe. Eine Standard-Factory wird generiert und kann durch Bildung von Unterklassen auf spezifische Situationen angepasst werden. (Fortsetzung auf n¨achster Seite)
10
Dummies simulieren ein Objekt, ohne die Funktionalit¨at tats¨achlich zu implementieren. Dies ist fur ¨ die Simulation einer Interaktion mit der Systemumgebung genauso geeignet wie fur ¨ Komponentengrenzen.
100
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.9.: Objekterzeugung: Objekte mit einer Factory erzeugen)
Objekterzeugung
new Class(Arguments) ⇓ Factory.f.newClass(Arguments) • Die generierte Klasse Factory besitzt ein statisches Attribut f vom Typ Factory, auf das die Methode newClass angewandt wird. Diese Methode erzeugt das neue Objekt. • Das Attribut f wird bei der Systeminitialisierung standardm¨aßig belegt, darf aber uberschrieben ¨ werden.
Klasse Factory
⇓
public class Factory { ... public static Factory f;
Java
public static initFactory() { f = new Factory(); }
}
// fur ¨ jede Klasse Class public Class newClass(Arguments) { return new Class(Arguments); }
• Entsprechende Factory-Methoden werden fur ¨ jede Klasse des Systems generiert. • Mehrere Factory-Methoden fur ¨ dieselbe Klasse mit unterschiedlichen Parameters¨atzen werden erzeugt, wenn es entsprechende Konstruktoren gibt. • Das Attribut f kann durch eine entsprechende Transformation durch Zugriffsmethoden geschutzt ¨ werden. • Eine Aufteilung der Factory in mehrere Klassen, zum Beispiel entsprechend einer Subsystem-Struktur, kann vorgenommen werden, muss dann aber vom Generator-Skript gesteuert werden. Alternative
Es ist moglich, ¨ statt einem einzelnen Attribut f fur ¨ mehrere Gruppen von zu erzeugenden Klassen beziehungsweise sogar fur ¨ jede Klasse ein eigenes Attribut einzusetzen, so dass die Generierung von Objekten individuell angepasst werden kann: (Fortsetzung auf n¨achster Seite)
¨ 4.1 Ubersetzung von Klassendiagrammen
101
(Fortsetzung von Tabelle 4.9.: Objekterzeugung: Objekte mit einer Factory erzeugen) Java
public class Factory { ... public static Factory fClass; ... // fur ¨ jede Klasse public static initFactory() { fClass = new Factory(); ... // fur ¨ jede Klasse }
}
// fur ¨ jede Klasse Class public Class newClass(Arguments) { return new Class(Arguments); }
wobei Aufrufe transformiert werden mittels: new Class(Arguments) ⇓ Factory.fClass.newClass(Arguments) Tabelle 4.9.: Objekterzeugung: Objekte mit einer Factory erzeugen
¨ Mehrstufige Ubersetzung Die exemplarisch diskutierten Varianten zur Umsetzung von Klassendiagrammen zeigen die hohe Bandbreite an moglichen ¨ Generierungsformen. Wie bereits diskutiert folgt daraus, dass die Codegenerierung eine grosse Flexibilit¨at benotigt, ¨ um die jeweils notwendigen Aufgaben zu erfullen. ¨ Ein Weg, die Flexibilit¨at zu steigern, ist die Moglichkeit, ¨ aus mehreren Templates oder Skripten auszuw¨ahlen. Daruber ¨ hinaus nutzen sich die Templates gegenseitig, indem zum Beispiel Assoziationen zun¨achst in Attribute transformiert und diese dann durch Zugriffsmethoden gekapselt werden. Die in diesem Abschnitt gezeigten Regeln zur Transformation von Konzepten der Klassendiagramme in Java-Code sind daher nicht unabh¨angig voneinander. Abbildung 4.10 zeigt die Abh¨angigkeiten der Transformationsregeln. Dabei sind nur die explizit definierten Regeln beschrieben, aber es sollte fur ¨ ein geeignetes Framework weitere Transformationsregeln geben, die durch weitere Templates festgelegt werden. Die Auswahl der Alternativen ist manchmal durch den Kontext oder Eigenschaften des ubersetzen ¨ Konzepts vorgegeben (wie hier zum Beispiel bei den Assoziationen) oder kann durch Einstellungen des Generators gesteuert werden (wie zum Beispiel bei den abgeleiteten Attributen).
102
4 Transformationen fur ¨ die Codegenerierung
Abbildung 4.10. Abh¨angigkeiten der behandelten Transformationsregeln zur Codegenerierung aus Klassendiagrammen
¨ 4.2 Ubersetzung von Objektdiagrammen Die vollst¨andige Beschreibung zur Generierung von Code aus der UML/P wurde ¨ den Rahmen dieses Buchs sprengen. Deshalb werden in den folgenden Abschnitten einige der interessantesten Aspekte der Transformation weiterer Diagramm- und Textarten in Java-Code erl¨autert, ohne alle Details zu diskutieren. Objektdiagramme konnen ¨ auf zwei Arten verwendet werden. Zum einen konnen ¨ Objektdiagramme konstruktiv eingesetzt werden, um damit Objektstrukturen zu erzeugen. Diese Funktionalit¨at kann sowohl im Produktionssystem als auch zur Darstellung von Objektstrukturen, auf denen automatisierte Tests stattfinden sollen, verwendet werden. Zum anderen werden Objektdiagramme als Pr¨adikate eingesetzt, um zu prufen, ¨ ob eine bestimmte Objektstruktur vorhanden ist. In Abschnitt 5.4, Band 1 wurden diese Verwendungsarten bereits vom methodischen Standpunkt aus beleuchtet. Dieser Abschnitt wird deshalb Aspekte der Codegenerierung aus Objektdiagrammen diskutieren. Dabei sei zun¨achst die in Kapitel 5, Band 1 vorgenommene Integration von Objektdiagrammen und OCL vernachl¨assigt. 4.2.1 Konstruktiv eingesetzte Objektdiagramme Die Transformation eines Objektdiagramms in Funktionalit¨at zum konstruktiven Aufbau von Objektstrukturen erfolgt gesteuert durch ein Skript beziehungsweise durch Merkmale, die dem Objektdiagramm angefugt ¨ werden.
¨ 4.2 Ubersetzung von Objektdiagrammen
103
Dabei sind einige Parameter festzulegen, die bei der Codegenerierung wichtig sind: 1. Die Klasse, der die Methode zur Erzeugung der Objektstruktur zugeordnet wird. Ist im Diagramm ein Objekt eindeutig ausgezeichnet, so kann dies entfallen. 2. Der Name der zu erzeugenden Methode. Als Default wird setupDiagramName verwendet, wenn dieser Name eindeutig ist. 3. Die Objekte des Diagramms, die bereits existieren und als Parameter ubergeben ¨ werden. In der Regel ist dies keines oder eines, das als uber¨ geordnetes Objekt bereits erzeugt wurde. 4. Treten im Objektdiagramm freie Variablen auf, so werden sie ebenfalls als Parameter fur ¨ die generierte Methode interpretiert. Da die Ausgangssituation und die damit jeweils bereits existenten Objekte unterschiedlich sein konnen, ¨ kann es sinnvoll sein, mehrere Methoden aus einem Objektdiagramm zu generieren. Diese konnen ¨ sich durch die Signatur oder, falls dies nicht eindeutig ist, auch durch die Methodennamen unterscheiden. Die Verwendung freier Variablen und unbesetzter Attribute als Parameter der generierten Funktion erlaubt es, Objektdiagramme wie in Abschnitt 5.2.2, Band 1 diskutiert als Muster mit prototypischen Objekten zu interpretieren, die eine mehrfache Instanziierung mit unterschiedlichen Inhalten erlauben. Bei der Generierung der setup-Methoden gibt es mehrere Aspekte, die zu beachten sind. Fur ¨ die Erzeugung eines Objekts ist die Verwendung eines Konstruktors notwendig. Idealerweise sollte ein Konstruktor ohne Parameter zur Verfugung ¨ stehen, der nur das leere Objekt erzeugt. Steht ein solcher Konstruktor nicht zur Verfugung, ¨ so kann im Testsystem ein solcher generiert werden. Im Produktionssystem muss allerdings auf einen existenten Konstruktor zuruckgegriffen ¨ werden, der entsprechend ausgezeichnet wurde. Ein weiteres Problem ist die Besetzung der Attribute entsprechend der im Objektdiagramm vorgegebenen Werte. Dafur ¨ sollten geeignete Hilfsfunktionen zur Verfugung ¨ stehen oder direkter Zugriff auf die Attribute erfolgen. Die in Abschnitt 4.1.1 diskutierten set-Methoden sind dafur ¨ nur partiell geeignet, da sie unter Umst¨anden zus¨atzliche Funktionalit¨at beinhalten. Im Prinzip konnen ¨ dafur ¨ auch Konstruktoren mit Parametern weiterhelfen, wenn die Zuordnung zwischen dem Parameter und dem zu besetzenden Attribut aus der Konstruktordefinition eindeutig hervorgeht.11 Ein Objektdiagramm kann grunds¨atzlich unvollst¨andig sein, indem etwa die Klasse eines Objekts nicht angegeben ist oder manchen Attributen kein Wert zugewiesen wurde. Zum einen konnen ¨ unbesetzte Attribute als freie 11
Das ist zum Beispiel dann der Fall, wenn der Konstruktor wie in Abschnitt 4.1 beschrieben ebenfalls generiert wurde.
104
4 Transformationen fur ¨ die Codegenerierung
Variable verstanden werden und als Parameter in die generierte Methode aufgenommen werden. Ist dies nicht gewunscht, ¨ so sind abh¨angig von der Art des Einsatzes im Testsystem, zur Simulation oder im Produktionssystem verschiedene Strategien zur Behandlung unbesetzter Attribute mo¨ glich. Im Testsystem wird eine Failure-Strategie genutzt: Unbesetzte Attributwerte sollten fur ¨ den getesteten Systemablauf keine Rolle spielen und der Zugriff darauf mit einem sofortigen Scheitern des Tests reagieren. Entsprechendes Verhalten kann in die get-Funktionen integriert werden. Bei der Simulation ist die bereits in Abschnitt 4.1.2 diskutierte Vorgehensweise sinnvoll, fehlende Attributwerte w¨ahrend des Simulationslaufs interaktiv zu erfragen oder mit Default-Werten zu arbeiten. Bei der Codegenerierung fur ¨ das Produktionssystem ist schließlich eine vollst¨andige Definition der Objekte im Objektdiagramm Voraussetzung. Dies verhindert Unachtsamkeiten bei der Definition von Objektdiagrammen und gibt so dem Entwickler Zutrauen in die Zuverl¨assigkeit des modellierten Systems. Nicht alle im Objektdiagramm formulierbaren Angaben werden bei konstruktiver oder auch der sp¨ater diskutierten pr¨adikativen Codegenerierung verwendet. Sichtbarkeiten, die Information uber ¨ Kompositionalit¨at eines Links, Merkmale wie {frozen} und a¨ hnliches mehr bedurfen ¨ keiner Umsetzung in den hier diskutierten Code, sondern werden mit den in Klassendiagrammen vorhandenen Informationen abgeglichen oder in Tests eingesetzt. Ein alternativer, mit Methodenspezifikationen verbundener Ansatz zum konstruktiven Einsatz von Objektdiagrammen ist bereits in Abschnitt 5.4.7, Band 1 diskutiert. Er nutzt ein Objektdiagramm in der Nachbedingung eines Konstruktors beziehungsweise einer Initialisierungsmethode, das nach denselben Prinzipien wie den hier gezeigten in konstruktiven Code umgesetzt werden kann. 4.2.2 Beispiel einer konstruktiven Codegenerierung Statt nun die Transformationsregeln fur ¨ jedes Modellelement des Objektdiagramms zu diskutieren sollen diese anhand des in Abbildung 4.11 gezeigten Objektdiagramms beispielhaft erl¨autert werden. Dieses Diagramm beschreibt einen Ausschnitt der initialen Objektstruktur des Applets im Auktionssystem und ist eingebettet in eine OCL-Methodenspezifikation fur ¨ die Initialisierungsfunktion init(). Der generierte Code ist in Abbildung 4.12 dargestellt, wobei hier und in den folgenden Beispielen vereinfachend angenommen wird, dass der direkte Zugriff auf die Attribute erst noch transformiert wird: Aus dem zugehorigen ¨ (hier nicht wiedergegebenen) Klassendiagramm kann das System ableiten, dass die Links durch die Attribute loginPanel und httpServerProxy in der Klasse WebBidding realisiert werden. Fur ¨ die Klassen HttpServerProxy und LoginPanel wird ein geeignet parametrisierter Konstruktor verwendet, der die Besetzung der angegebenen
¨ 4.2 Ubersetzung von Objektdiagrammen
context WebBidding.init() let String language = getParameter("language"); String login = getParameter("login") post: OD.WBinit
105
OCL
Abbildung 4.11. Objektdiagramm zur Initialisierung einer Struktur class WebBidding { ... Java public void init() { // aus dem let-Konstrukt String language = getParameter("language"); String login = getParameter("login"); // aus Objekt this status = AppStatus.INITIAL; person = null; auction = null; auctionChooserPanel = null; multibiddingPanel = null; appletLanguage = language==null ? "German" : language; // aus Objekt :LoginPanel setLoginPanel(new LoginPanel(login==null ? "":login,"")); // aus Objekt :HttpServerProxy setHttpServerProxy( new HttpServerProxy( "https://"+getCodeBase().getHost()+":443/")); }
}
Abbildung 4.12. Aus dem Objektdiagramm generierte init()-Funktion
Attribute vornimmt.12 Die Links werden durch set-Methoden besetzt, die auch die korrekte Besetzung der Ruckrichtung ¨ sichern. 12
Wenn kein geeigneter Konstruktor existiert, dann kann ein Codegenerator einen solchen Konstruktor generieren.
106
4 Transformationen fur ¨ die Codegenerierung
4.2.3 Als Pr¨adikate eingesetzte Objektdiagramme Der Einsatz eines Objektdiagramms als Pr¨adikat, das pruft, ¨ ob eine bestimmte Objektstruktur vorliegt und die im Objektdiagramm angegebenen Werte ¨ ubereinstimmen, ¨ wird in eine boolesche Methode transformiert. Ahnlich wie bei der konstruktiven Variante steuern mehrere Parameter den zu erzeugenden Code: 1. Die Klasse, der die boolesche Methode zugeordnet wird. Ist im Diagramm ein Objekt eindeutig ausgezeichnet, zum Beispiel durch den Namen this:Classname, so kann dies entfallen. Alternativ kann die Methode als statisch definiert und/oder einer Testklasse zugeordnet werden. 2. Der Name der zu erzeugenden Methode. Ist der Name nicht gegeben, so wird als Default isStructuredAsDiagramName verwendet. 3. Die Objekte des Diagramms, die als Ausgangsobjekte bereits identifiziert sind und deshalb als Parameter ubergeben ¨ werden. In der Regel ist dies ein einzelnes Objekt, das als eine Art Master fur ¨ die Objektstruktur gilt. 4. Treten im Objektdiagramm freie Variablen auf, so werden sie im Normalfall nicht weiter beachtet. Sollen diese Variablen aber bestimmte Werte annehmen, so werden die Variablen ebenfalls als Parameter fur ¨ die generierte Methode interpretiert. Im Gegensatz zur konstruktiven Variante eines Objektdiagramms kann ein pr¨adikativ eingesetztes Diagramm in mehrerer Hinsicht unvollst¨andig sein. Attribute und Attributwerte durfen ¨ ebenso weggelassen werden wie die Klassen der dargestellen Objekte. Auch Eigenschaften mit einer zeitlichen Implikation, wie etwa das Merkmal {frozen} fur ¨ Links, konnen ¨ nicht in einem Pr¨adikat uber ¨ einen Zustand gepruft ¨ werden. Dazu ist zus¨atzliche Infrastruktur notig, ¨ die dies entweder konstruktiv sichert, indem keine Methoden zur Modifikation eines Links angeboten werden, oder zur Laufzeit pruft, ¨ indem der ursprungliche ¨ Zustand des Links in einer Kopie aufgehoben wird. In Abschnitt 5.3, Band 1 wurde die Bedeutung eines Objektdiagramms als Pr¨adikat im Kontext der Integration mit OCL-Bedingungen bereits ausfuhr¨ lich diskutiert. Dabei wurde festgestellt, dass ein Objektdiagramm grunds¨atzlich als OCL-Bedingung dargestellt werden kann. In genau dieser Bedeutung werden pr¨adikative Objektdiagramme in entsprechende boolesche Methoden, die mit dem in Abschnitt 4.4.1, Band 1 eingefuhrten ¨ Stereotyp query markiert sind, ubersetzt. ¨ Die so generierten Methoden konnen ¨ genau wie die Referenz auf das Objektdiagramm bei Invarianten, Vor- und Nachbedingungen von Methoden und von Transitionen in Statecharts, aber auch in Java-Rumpfen ¨ des Produktionscodes eingesetzt werden. Fur ¨ die Verwendung im Produktionscode ist jedoch auf die Effizienz der Umsetzung zu achten. Wie in Abschnitt 5.3, Band 1 diskutiert, wirken anonyme Objekte des Objektdiagramms als existenzquantifiziert. In derselben
¨ 4.2 Ubersetzung von Objektdiagrammen
107
Weise werden benannte Objekte behandelt, die jedoch nicht bereits als Parameter an das boolesche Pr¨adikat ubergeben ¨ werden. Diese Objekte werden vom Pr¨adikat selbst gesucht, indem die entsprechenden Assoziationen gepruft ¨ werden. Die Belegung der freien Objekte erfolgt in einer dem StrukturMatching der Graph Grammatiken [Roz99, EEKR99] analogen Form. Bei mengenwertigen Assoziationen kann eine derartige Suche von linearer Komplexit¨at sein und sollte deshalb vermieden werden. Moglichkeiten ¨ zur Verbesserung der Situation bieten der Einsatz eines Qualifikators bei der ¨ Assoziation oder die explizite Ubergabe gesuchter Objekte als Parameter, wenn diese aus dem Kontext effizient ermittelt werden konnen. ¨
Abbildung 4.13. Fur ¨ ein Pr¨adikat bestimmtes Objektdiagramm
Anhand des aus dem Auktionssystem stammenden und in Abbildung 4.13 dargestellten Objektdiagramms wird die Transformation in ein Pr¨adikat illustriert. Der fur ¨ den Einsatz im Testsystem generierte Code ist in Abbildung 4.14 dargestellt. Nach einer Phase der Belegung von Objektnamen werden alle Attribute gepruft. ¨ Dabei durfen ¨ Attributwerte aufeinander Bezug nehmen. Werden statt der im (hier nicht dargestellten) Klassendiagramm angegebenen Typen echte Unterklassen angegeben, so wird gepruft, ¨ ob das entsprechende Objekt tats¨achlich zu dieser Unterklasse gehort. ¨ Anhand der L¨ange des in Abbildung 4.14 dargestellten Codes ist ersichtlich, dass eine Darstellung im Objektdiagramm kompakter und ubersichtli¨ cher ist, also dem Modellierer insbesondere bei der schnellen Erfassung eines ¨ Uberblicks und der Suche einzelner Werte Vorteile bringt.
108
4 Transformationen fur ¨ die Codegenerierung Java
class Auction { ... public static boolean isStructedAsKupfer(Auction kupfer912, int status, boolean isInExtension) { // Namen festlegen (optimierbar) BiddingPolicy bidPol = kupfer912.bidPol; TimingPolicy timePol = kupfer912.timePol; Money min = bidPol.min; Money max = bidPol.max; Time start = timePol.start; Time finish = timePol.finish; return // Hauptobjekt kupfer912.auctionIdent == 912 && kupfer912.title.equals("420t Kupfer") && kupfer912.numberOfBids == 0 && // BiddingPolicy bidPol instanceof DownwardBiddingPolicy && bidPol.kind == BiddingPolicy.DOWNWARD && bidPol.bidCountMax == BiddingPolicy.UNLIMITED && // Money Objekte min.amount == 52290000 && min.decimalplaces == 2 && min.currency.equals("$US") && min.full.equals("522.900,00 $US") && max.full.equals("720.000,00 $US") && // TimingPolicy timePol instanceof ConstantTimingPolicy && timePol.status == status && timePol.isInExtension == isInExtension && timePol.extensionTimeSecs == 180 && // Times start.timeSec == 953640000 && start.time.equals("13:00:00") && start.date.equals("21. Februar 2000") && finish.timeSec == start.timeSec + 2*60*60 && finish.time.equals("15:00:00") && finish.date.equals("21. Februar 2000") ; }
}
Abbildung 4.14. Aus Objektdiagramm generiertes Pr¨adikat
¨ 4.2 Ubersetzung von Objektdiagrammen
109
Als Erweiterung beziehungsweise Alternative bei der Codegenerierung kann eine weitere Methode mit dem Namen isExactlyStructuredAsDiagramName generiert werden. Diese Methode kann zus¨atzlich sichern, dass die Objektstruktur nur die im Diagramm angegebenen Objekte enth¨alt. Das ist besonders bei mehrwertigen und optionalen Assoziationen von Interesse und kann zum Beispiel durch einen geeigneten Stereotyp complete fur ¨ Objektdiagramme gesteuert werden. Tabelle 4.15 gibt eine knappe Einfuhrung ¨ zu diesem Stereotyp. Stereotyp complete Modellelement Motivation
Rahmenbedingung Wirkung
Objektdiagramm. Die Bedeutung eines Objektdiagramms als Pr¨adikat ist normalerweise so festgelegt, dass die explizit angegebenen Eigenschaften erfullt ¨ sein mussen. ¨ Weitere, im Diagramm nicht angegebene Objekte konnen ¨ existieren. In einem mit complete markierten Objektdiagramm mussen ¨ alle Attribute und Links angegeben sein. Geordnete Assoziationen sind vollst¨andig darzustellen. Der Stereotyp complete fordert, dass keine weiteren Objekte in der angegebenen Objektstruktur existieren. Das angegebene Objektdiagramm ist also eine vollst¨andige Darstellung der Objektstruktur. Damit kann die Methode isExactlyStructuredAsDiagramName generiert werden, die diese Vollst¨andigkeit zus¨atzlich zur Erfullung ¨ der angegebenen Eigenschaften des Objektdiagramms pruft. ¨ Tabelle 4.15.: Stereotyp complete
4.2.4 Objektdiagramm beschreibt Strukturmodifikation Eine weitere interessante Form des Einsatzes von Objektdiagrammen ergibt sich aus der Kombination beider Einsatzformen. Dabei wird eine existente Objektstruktur auf das Vorhandensein der im Objektdiagramm beschriebenen Objekte gepruft, ¨ die fehlenden Objekte generiert und die falsch besetzten Attribute modifiziert. Derartige Methoden erhalten als Namen adaptToDiagramName. Mit diesen Methoden kann eine bereits vorhandene Objektstruktur in Abh¨angigkeit des aktuell gewunschten ¨ Zustands umgebaut werden. Damit lassen sich Objektdiagramme zum Beispiel als Zustandsinvarianten im Statechart oder zur Adaption der jeweiligen Objektstruktur in der Entry-Aktion von Zust¨anden einsetzen. Wird beispielsweise das in Abbildung 4.11 gegebene Objektdiagramm (ohne Einbettung in die
110
4 Transformationen fur ¨ die Codegenerierung
dort stehende OCL-Bedingung) in dieser Form eingesetzt, so wird die in Abbildung 4.16 dargestellte Methode erzeugt. class WebBidding {
Java
public void adaptToWBinit(String language, String login) { // aus Objekt this status = AppStatus.INITIAL; person = null; auction = null; auctionChooserPanel = null; multibiddingPanel = null; appletLanguage = language==null ? "German" : language; // aus Objekt :LoginPanel if(loginPanel != null && loginPanel instanceof LoginPanel) { loginPanel.loginField = (login==null) ? "" : login; loginPanel.passwordField = ""; } else { setLoginPanel(new LoginPanel( login==null ? "" : login, "")); }
}}
// aus Objekt :HttpServerProxy if(httpServerProxy != null && httpServerProxy instanceof HttpServerProxy) { httpServerProxy.secureURL = "https://"+getCodeBase().getHost()+":443/"; httpServerProxy.connectStatus = HttpServerProxy.NOT CONNECTED; httpServerProxy.lastConnectionTime = Time.now(); } else { setHttpServerProxy( new HttpServerProxy( "https://"+getCodeBase().getHost()+":443/")); }
Abbildung 4.16. Aus Objektdiagramm generierte Adaptionsmethode
Fehlt ein Objekt oder hat es den falschen Typ, so wird es neu erzeugt. Ist das Objekt bereits vorhanden, so werden seine Attribute in der gewunschten ¨ Form modifiziert. Deshalb werden sowohl Konstruktoren, die in diesem Beispiel bereits Attributwerte als Parameter enthalten, als auch set-Methoden zur Attributbesetzung verwendet.
¨ 4.2 Ubersetzung von Objektdiagrammen
111
Die Eindeutigkeit des entlang eines Links zu identifizierenden Objekts wie zum Beispiel dem anonymen Objekt :LoginPanel ist nur bei Assoziationen der Kardinalit¨at 1“ oder 0..1“ gegeben. Bei mengenwertigen As” ” soziationen ist ein Vergleich mit allen vorhandenen Objekten durchzufuhren, ¨ der auch dessen Attribute einbezieht. Findet sich kein Objekt in der Objektstruktur, das dem im Diagramm angegebenen prototypischen Objekt entspricht, so wird in diesem Fall keines der vorhandenen Objekte angepasst, sondern ein neues Objekt erzeugt. Dadurch vergroßert ¨ sich die Menge der Links entsprechend. Der Nachteil dieser Methode ist allerdings, dass die Loschung ¨ unerwunschter ¨ Objekte nicht dargestellt werden kann. Außerdem kann diese Methode ineffizient werden, wenn zum Beispiel mit dem in Abbildung 2.28 gegebenen Objektdiagramm (ohne die OCL-Bedingung) und der daraus generierten und in Abbildung 4.17 dargestellten Methode hundert Personen einzeln angelegt werden. class Auction { ...
Java/P
public void adaptToNPersons(Auction test32, int x) { // setze Objekt test32 test32.auctionIdent = 32; test32.title = "Testauktion";
}
}
// gibt es p:Person? Person p = null; for(Iterator(Person) ip = participants.iterator(); ip.hasNext() && p==null; ) { Person pit = ip.next(); if(pit.personIdent == 1000+x && pit.login == "log" +x && pit.name == "Tester " +x && pit.isActive == (x%2 == 0)) { p = pit; } } // p:Person anlegen if(p == null) { p = new Person(); // Default-Konstruktor p.personIdent = 1000+x; p.login = "log" +x; p.name = "Tester " +x; p.isActive = (x }
Abbildung 4.17. Adaptionsmethode mit Suche in *-Assoziation
112
4 Transformationen fur ¨ die Codegenerierung
4.2.5 Objektdiagramme und OCL Ein wesentliches Mittel zur Steigerung der Ausdrucksm¨achtigkeit von Objektdiagrammen ist die ab Abschnitt 5.3, Band 1 durchgefuhrte ¨ Integration mit der OCL. Die Transformation eines um OCL-Bedingungen erweiterten Objektdiagramms in konstruktiven Code beziehungsweise in ein Pr¨adikat h¨angt daher von der Umsetzbarkeit der OCL-Bedingungen ab. Die Umsetzung und die Ausfuhrbarkeit ¨ von OCL-Bedingungen wurde bereits in Abschnitt 3.1.2 diskutiert. Zu beachten ist aber auch, dass die in der vorangegangenen Diskussion erw¨ahnte lineare Suchkomplexit¨at fur ¨ existenzquantifizierte Objekte polynomial ansteigen kann, wenn uber ¨ mehrere mengenwertige Assoziationen navigiert wird und die so erreichten Objekte uber ¨ eine OCL-Bedingung verknupft ¨ sind.
4.3 Codegenerierung aus OCL Auf Basis der bisher beschriebenen Moglichkeiten, ¨ die OCL als Spezifikationssprache fur ¨ UML/P-Programme zu nutzen, gibt es zum Beispiel die Moglichkeit, ¨ die OCL zur Modellierung von Invarianten in Datenbanksystemen einzusetzen [DH99] oder mit der OCL die Gesch¨aftslogik zu beschreiben [DHL01]. Die dabei zugrunde liegende Semantik der OCL ist in ihrer Essenz mit der bisher diskutierten Bedeutung der OCL identisch, jedoch ist die Einsatzform und damit die Abbildung der OCL in ausfuhrbaren ¨ Code wesentlich anders. Statt Klassen und Objekten stehen in relationalen Datenbanken Entit¨aten und Zeilen zur Verfugung, ¨ uber ¨ denen OCL-Ausdrucke ¨ interpretiert werden. Mehrere, teils prototypische Werkzeuge bieten bereits Realisierungen fur ¨ OCL-Codegeneratoren an. In [HDF00] wird eine modulare Architektur fur ¨ die OCL vorgestellt, die als Grundlage fur ¨ eine Integration mit anderen UML-Werkzeugen gut geeignet ist [BS01a, BBWL01]. Eine der OCL verwandte Sprache, genannt Java Interface Specification Language“ (JISL), ” wird in [MMPH99] zur Methodenspezifikation vorgestellt und diskutiert, wie die Ausfuhrbarkeit ¨ der Spezifikation durch eine Transformation nach Java vorgenommen werden kann. Weil zwischen OCL/P und Java aufgrund der syntaktischen und semantischen N¨ahe relativ viele Konzepte eindeutig nach Java umgesetzt werden, sollen nachfolgend vor allem die interessanten OCL-Konstrukte diskutiert werden. Dazu gehoren ¨ unter anderem die Umsetzung der Kontextdefinition, der OCL-Logik, der Komprehension, der Navigation, der Quantoren und der Spezialoperatoren. Viele, jedoch nicht alle der nachfolgend beschriebenen Codestucke ¨ lassen sich in wiederverwendbare Methoden kapseln. Es wird hier auf die Darstellung der Kapselung verzichtet, da dies nur den dargestellten Code ver-
4.3 Codegenerierung aus OCL
113
großert. ¨ Bei einer manuellen Verwendung dieser Codestucke ¨ (als eine Art von Entwurfsmuster) ist allerdings eine Kapselung zu empfehlen. 4.3.1 OCL-Aussage als Pr¨adikat Obwohl OCL-Bedingungen, wie in Abschnitt 3.1.2 beschrieben, in sehr eingeschr¨ankter Form in Implementierungscode umgesetzt werden konnen, ¨ hat eine OCL-Aussage eine naturliche ¨ Bedeutung als Pr¨adikat. Deshalb werden OCL-Aussagen, wie etwa context Auction a inv Bidders1: a.activeParticipants <= a.bidder.size
OCL
in boolesche Methoden ubersetzt. ¨ Dabei gibt es zwei Varianten. Die Interpretation als Invariante produziert: public static boolean invariantBidders1() { boolean res = true; Set(Auction) auctions = Auction.getAllInstances(); for(Iterator(Auction) ia = auctions.iterator(); ia.hasNext() && res; ) { Auction a = ia.next(); res &= a.activeParticipants <= a.bidder.size; } return res; }
Java/P
Die generierte Methode pruft ¨ die Invariante Bidders1 fur ¨ alle Objekte der Klasse Auction. Um dies zu ermoglichen, ¨ ist eine Infrastruktur zur Verwaltung der Menge aller Auktionsobjekte erforderlich, die zum Beispiel durch die Methode getAllInstances zur Verfugung ¨ gestellt wird. Tats¨achlich ist fur ¨ praktische Anwendungen ein Einsatz der OCL-Bedingung in der oben beschriebenen Form ungunstig. ¨ Im laufenden System werden seit der letzten Prufung ¨ der Invariante normalerweise nur relativ wenige Auktionsobjekte modifiziert worden sein. Deshalb ist es unter Umst¨anden gunstig, ¨ zus¨atzliche Infrastruktur zu investieren, um die Invariantenprufung ¨ effizienter zu gestalten. Dies kann erreicht werden, indem die Prufung ¨ der Invariante explizit an bestimmten Stellen gefordert wird. Dann sind aber nicht alle, sondern nur bestimmte Auktionsobjekte zu testen. Die dafur ¨ geeignete Methode ist public static boolean checkBidders1(Auction a) { return a.activeParticipants <= a.bidder.size(); }
und ihre der Klasse Auction zugeordnete Variante
Java
114
4 Transformationen fur ¨ die Codegenerierung
class Auction ... { public boolean checkBidders1() { return a.activeParticipants <= a.bidder.size(); }
Java
Alle diese Formen eignen sich zum Einsatz in Tests, in denen die Prufung ¨ von Invarianten explizit gefordert werden kann. Zu beachten ist, dass nach Konvention die vollst¨andige Invariante das Pr¨afix invariant besitzt, w¨ah¨ rend check fur ¨ die Einzelfall-Prufung ¨ verwendet wird. Die explizite Ubergabe des Kontexts einer OCL-Aussage in Form der zu prufenden ¨ Objekte wird normalerweise durch das Schlusselwort ¨ import vorgenommen. Deshalb werden die letzten beiden Methoden auch aus folgender Bedingung erzeugt: import Auction a inv Bidders1: a.activeParticipants <= a.bidder.size
OCL
Da in der Praxis ein mit dem Schlusselwort ¨ context geschlossener Kontext oft auch auf einzelne Objekte angewandt werden soll, werden daraus sowohl eine geschlossene als auch zus¨atzlich parametrisierte Methoden erzeugt. Besteht die Kontextangabe aus mehreren Objekten, so werden alle als Parameter verwendet. Folgende Tabelle 4.18 beschreibt die Transformation: OCL-Kontext: Umsetzung des Kontexts einer Bedingung Erkl¨arung
Kontext
Der Kontext wird in OCL explizit in Form von Objekten angegeben. Diese wirken als Parameter bei den daraus generierten booleschen Methoden. context Classcontext inv Name: Body
OCL
⇓
Java/P
public static boolean invariantName() { boolean res = true; // Iteration nur einmal dargestellt Set(Class) s = Class.getAllInstances(); for(Iterator(Class) it = s.iterator(); it.hasNext() && res; ) { Class ob = it.next(); res &= Body’; } return res; } public static boolean checkName(Classcontext) { Body’ } (Fortsetzung auf n¨achster Seite)
4.3 Codegenerierung aus OCL
115
(Fortsetzung von Tabelle 4.18.: OCL-Kontext: Umsetzung des Kontexts einer Bedingung)
• Die Iteration wird fur ¨ jedes Element Class ob des Kontexts geschachtelt wiederholt. Entsprechend ergeben sich polynomiale Komplexit¨aten bei der Prufung ¨ der vollst¨andigen Invariante. • Der generierte Code ist in einer statischen Methode abgelegt und wird einer geeigneten Klasse zugeordnet. Besteht der Kontext aus nur einem Objekt, so kann zus¨atzlich eine nicht-statische Methode in der Klasse des Objekts generiert werden. • Die Methode getAllInstances wird nachfolgend beschrieben. • Das alternative Schlusselwort ¨ import generiert nur die parametrisierten Formen. • Der Rumpf der Bedingung Body wird entsprechend der nachfolgenden Regeln in Body’ umgesetzt. Tabelle 4.18.: OCL-Kontext: Umsetzung des Kontexts einer Bedingung
4.3.2 OCL-Logik Wie in Abschnitt 4.2.2, Band 1 besprochen ist die OCL-Logik zweiwertig und nutzt einen impliziten Liftingoperator, um undefinierte Ergebnisse als false zu interpretieren. Der mit ↑ bezeichnete Liftingoperator ist wegen seiner Eigenschaft ↑undef==false nicht (vollst¨andig) implementierbar. Jedoch existiert eine bereits in Abschnitt 4.2.2, Band 1 diskutierte Umsetzung dieses Operators in Java, die Exceptions abf¨angt und so nur nichtterminierende Berechnungen nicht erkennen kann. Der Liftingoperator ist implizit bei allen booleschen Operationen der OCL zu finden, so dass die Umsetzung der booleschen Operationen &&, ||, !, implies und <=> jeweils der Verwendung des Liftings bedarf. OCL-Logik: Logikoperatoren Erkl¨arung
Die zweiwertige Logik wird mittels Lifting des undefinierten Pseudowerts undef auf false umgesetzt. (Fortsetzung auf n¨achster Seite)
116
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.19.: OCL-Logik: Logikoperatoren)
Negation
... !a ... ⇓ boolean res; try { res = a; } catch(Exception e) { res = false; } ... !res ...
Java
• Die Einbettung der Auswertung des booleschen Ausdrucks a in eine catch-Anweisung macht eine Zerschlagung des Kontexts von a notwendig. Der Teilausdruck a wird vorab berechnet und in der Ergebnisvariable res zwischengespeichert. Die Umordnung der Berechnung ist erlaubt, da Seiteneffekte in OCL-Ausdrucken ¨ nicht auftreten. • Eine Nichtterminierung der Auswertung von a wird nicht erkannt. ¨ Aquivalenz
... a <=> b ... ⇓ boolean resa, resb; try { resa = a; } catch(Exception e) { resa = false; } try { resb = b; } catch(Exception e) { resb = false; } ... (resa==resb) ...
Java
Weitere werden in analoger Form umgesetzt. Implikation a implies Operatoren b wird auf !a || b, Konjunktion und Disjunktion werden auf die jeweiligen Java-Operatoren abgebildet. Tabelle 4.19.: OCL-Logik: Logikoperatoren Zur Umsetzung der OCL-Kontrollstrukturen konnen ¨ die entsprechenden Java-Kontrollanweisungen eingesetzt werden. Das let-Konstrukt fuhrt ¨ lokale Variablen ein und f¨angt bei der Berechnung der Variablenwerte auftretende Exceptions ab.
4.3 Codegenerierung aus OCL
117
4.3.3 OCL-Typen Die OCL/P-Grunddatentypen stimmen mit denen aus Java uberein, ¨ so dass eine Umsetzung nicht erforderlich ist. Auch der Vergleich der Grunddatentypen == sowie die arithmetischen Operationen werden unver¨andert uber¨ nommen. Die Container Set(X), List(X) und Collection(X), die die OCL anbietet, stellen eine Teilmenge der Container aus Java dar, wobei eine explizite Typisierung der Argumente im Sinne der Java-Generics vorgenommen wurde. Deshalb konnen ¨ die OCL-Container nahezu unver¨andert nach Java ubernommen ¨ werden. Die explizite Aufz¨ahlung wird im Wesentlichen auf einen Konstruktor und elementweises Hinzufugen ¨ abgebildet. Dabei wird vom Generator festgelegt, welche konkrete Mengen- oder Listenimplementierung verwendet wird. Die Verwendung von Containern uber ¨ Grunddatentypen bedarf einer besonderen Behandlung. Java ist im Gegensatz zur OCL nicht in der Lage, zum Beispiel int-Werte direkt in Containerstrukturen abzulegen. Stattdessen ist die objektifizierte Form Integer“ zu verwenden. Der Typ Set(int) wird ” also nach Set(Integer) uberf ¨ uhrt ¨ und alle Anwendungsstellen werden entsprechend transformiert. Da fur ¨ Container nicht die Objektidentit¨at, sondern der inhaltliche Vergleich von Interesse ist, wird der Vergleich == in eine eigens generierte Methode ubersetzt, ¨ die Gleichheit auf Containern wie in Abschnitt 4.3.3, Band 1 beschrieben interpretiert. Die Umsetzung der in der OCL/P eingefuhrten ¨ Komprehensionskonstrukte wird in der folgenden Tabelle 4.20 erkl¨art. OCL-Komprehension: Umformung der Komprehension Erkl¨arung Aufz¨ahlung
Die fur ¨ Mengen und Listen verwendeten Komprehensionsformen werden in Java durch zus¨atzliche Infrastruktur erg¨anzt. Set{ a..b }
OCL
⇓
Set(Integer) res = ... for(int i = a; i <= b; i++) res.add(new Integer(i)); } // Weiterverwendung von res
Java/P
(Fortsetzung auf n¨achster Seite)
118
4 Transformationen fur ¨ die Codegenerierung (Fortsetzung von Tabelle 4.20.: OCL-Komprehension: Umformung der Komprehension)
• Die Aufz¨ahlung wird durch eine Schleife realisiert, da Java keine Kompaktform anbietet. • Die Variable res erlaubt die Weiterverwendung fur ¨ den Aufbau einer Menge aus mehreren Aufz¨ahlungen, zum Beispiel der Form Set{a,b..c,d..e}. • res ist zum Beispiel mit new HashSet() zu besetzen. Komprehension mit Generator
Set{ expr | var in expr2 }
OCL
⇓
Java/P
Set(Class) res = new HashSet(Class); for(Iterator(Class2) it = expr2’.iterator(); it.hasNext(); ) { Class2 var = it.next(); res.add(expr’); } // Weiterverwendung von res
• Die Berechnung des OCL-Ausdrucks wird in mehrere Anweisungen mit Zwischenergebnis res aufgebrochen. Die Umordnung der Berechnung ist erlaubt, da OCL und auch seine Umsetzung seiteneffektfrei ist. • Die Ausdrucke ¨ expr und expr2 werden ebenfalls transformiert. • expr hat den Typ Class. • expr2 hat den Typ Set(Class2). Komprehension mit Filter
Set{ expr | var in expr2, boolexpr }
OCL
⇓
Java/P
Set(Class) res = new HashSet(Class); for(Iterator(Class2) it = expr2’.iterator(); it.hasNext(); ) { Class2 var = it.next(); if(boolexpr) res.add(expr’); } // Weiterverwendung von res (Fortsetzung auf n¨achster Seite)
4.3 Codegenerierung aus OCL
119
(Fortsetzung von Tabelle 4.20.: OCL-Komprehension: Umformung der Komprehension)
• Wie in Abschnitt 4.3.2, Band 1 beschrieben, entfernt ein Filter boolexpr Elemente aus der Menge. • Der Filter gewinnt seine M¨achtigkeit in Kombination mit dem bereits formulierten Generator. Deshalb wird die Transformation mit angefugtem ¨ Generator dargestellt.
Lokale Variablen
Set{ expr | var in expr2, Type x = expr3 }
OCL
⇓
Java/P
Set(Class) res = new HashSet(Class); for(Iterator(Class2) it = expr2’.iterator(); it.hasNext(); ) { Class2 var = it.next(); Type x = expr3; res.add(expr’); } // Weiterverwendung von res
• Eine lokale Variablendefinition wirkt wie ein letKonstrukt. Kombination
von Generatoren, lokalen Variablendefinitionen und Filtern innerhalb von Komprehensionen ist beliebig mo¨ glich. Bei mehreren Generatoren steigt jedoch die Komplexit¨at schnell an.
Tabelle 4.20.: OCL-Komprehension: Umformung der Komprehension Die Komprehension ist grunds¨atzlich verwandt mit SQL-Statements, ¨ wenn auch ausdrucksst¨arker. Eine Ubersetzung von OCL in eine Datenbankanfrage kann zumindest teilweise die Effizienz der Datenbankanfragen nutzen. 4.3.4 Typen als Extension Die OCL erlaubt die Verwendung von Typausdrucken ¨ wie Auction als Extension, die damit gleichzeitig die Menge der aktuell existierenden Objekte dieses Typs beschreibt. So kann zum Beispiel formuliert werden: forall a in Auction: a.person.size < 500
OCL
¨ Um eine Uberpr ufung ¨ dieser Bedingung zur Laufzeit zu erlauben, ist der Zugriff auf alle zu einem Zeitpunkt existenten Objekte des Typs Auction erforderlich. Deshalb ist eine entsprechende Infrastruktur zur Verwaltung der
120
4 Transformationen fur ¨ die Codegenerierung
Extensionen der Objekte zur Verfugung ¨ zu stellen. Diese kann auf Basis von WeakHashMaps realisiert sein, die mit der Garbage Collection zusammenarbeiten. Eine boolesche Variable OCL.oclmode beschreibt, ob das System gerade eine OCL-Bedingung auswertet und daher eventuell neu angelegte Objekte nicht zur Extension hinzuzurechnen sind13 . In der Verwaltung sind zus¨atzliche Maßnahmen zu treffen, um die in den nachfolgend besprochenen Methodenspezifikationen moglichen ¨ Konstrukte Class@pre und new(.) zur Charakterisierung neuer Objekte zu evaluieren. Da Methodenaufrufe geschachtelt sein konnen, ¨ wird der Aufrufkeller bei der Speicherung der Instanzmengen nachgebildet, um so jeder Nachbedingung den Zugriff auf den jeweiligen Zustand zur Vorbedingung zu ermoglichen. ¨ Wesentlich ist hier die effiziente Verwaltung und Optimierung in Abh¨angigkeit tats¨achlich benotigter ¨ Extensionen. 4.3.5 Navigation und Flattening Der Flatten-Operator flatten wird fur ¨ die verschiedenen Varianten der Collections in der in 4.3.6, Band 1 beschriebenen Form realisiert und bei dem Flachdrucken ¨ von Navigationsergebnissen angewandt. Die Navigation der OCL ist mengenwertig. Da Java eine Navigation ausgehend von mengen- und listenwertigen Strukturen nicht kennt, sind diese entsprechend zu transformieren. Tabelle 4.21 zeigt eine effiziente Umsetzung der Navigation. Navigation: Mengen- und listenwertige Navigation Erkl¨arung einfache Navigation
Navigation ausgehend von Containerstrukturen ist in Java durch Iteratoren zu realisieren. a.role ⇓ a.role • Ausdruck a beschreibt ein einzelnes Objekt. Die Navigation entlang der gewunschten ¨ Assoziation ist durch role moglich. ¨ • Eine weitere Umsetzung durch Regeln fur ¨ Assoziationen ist zu beachten. Zum Beispiel kann eine Kapselung von a durch Zugriffsmethoden vorgenommen werden. • Die Navigation kann ein mengenwertiges Ergebnis haben oder qualifiziert sein. Dann ist gegebenenfalls eine Anpassung der Container-Form notwendig. (Fortsetzung auf n¨achster Seite)
13
Siehe Abschnitt 4.4.1, Band 1 uber ¨ die Objekterzeugung in Queries.
4.3 Codegenerierung aus OCL
121
(Fortsetzung von Tabelle 4.21.: Navigation: Mengen- und listenwertige Navigation)
Navigation aus einer Menge
sa.role ⇓ Java/P
Set(Class) res = new HashSet(Class); for(Iterator(Class2) it = sa’.iterator(); it.hasNext(); ) { Class2 a = it.next(); if(a.role != null) res.add(a.role); } // Weiterverwendung von res
• Ausdruck sa beschreibt eine Menge von Objekten. Die Navigation entlang der gewunschten ¨ Assoziation ist durch role moglich. ¨ Die Kardinalit¨at ist 1“ oder 0..1“. ” ” • Siehe auch Aussagen zur einfachen Navigation. • Class ist der Typ der durch die Assoziation erreichten Klasse. • Class2 ist der Typ der Ausgangsklasse. Mengenwertige Navigation aus einer Menge
sa.role ⇓ Java/P
Set(Class) res = new HashSet(Class); for(Iterator(Class2) it = sa’.iterator(); it.hasNext(); ) { Class2 a = it.next(); res.addAll(a.role); } // Weiterverwendung von res
• Im Unterschied zum obigen Fall ist die Kardinalit¨at nun *“, also a.role mengenwertig. ” • Ansonsten gelten Aussagen der vorherigen Transformation. Tabelle 4.21.: Navigation: Mengen- und listenwertige Navigation
4.3.6 Quantoren und Spezialoperatoren Unendliche Quantoren, also Quantoren uber ¨ den Grunddatentypen wie int und uber ¨ Containerstrukturen wie List(Auction) werden nicht uber¨ setzt. Alle objektwertigen Quantoren jedoch sind endlich und damit in Java ubersetzbar. ¨ Eine entsprechende Realisierung in Form eines Iterators ist
122
4 Transformationen fur ¨ die Codegenerierung
bereits im Eingangsbeispiel dieses Abschnitts gezeigt worden. Operatoren wie any oder iterate konnen ¨ in a¨ hnlicher Form umgesetzt werden. Auch die Umsetzung von Referenzen auf Objektdiagramme in der OCL sind einfach. Ein Objektdiagramm wirkt als Pr¨adikat, kann daher selbst in eine boolesche Methode transformiert und der Aufruf in den generierten Code eingesetzt werden. Das von der OCL/P zur Verfugung ¨ gestellte typeifKonstrukt zur typsicheren Konversion von Objekten wird durch eine Abfrage mit instanceof und eine Typkonversion realisiert. 4.3.7 Methodenspezifikation Die folgende Methodenspezifikation beschreibt fur ¨ einen eingeschr¨ankten Bereich, wie nach Eingang eines neuen Gebots eine neue Zeit fur ¨ das Auktionsende festgelegt wird. Dabei sind einige zeitliche Abh¨angigkeiten zu sichern: context Time ConstantTimingPolicy.newCurrentClosingTime( OCL Auction a, Bid b) let long old = a.closingTime.timeSec; long now = b.time.timeSec pre: status==RUNNING && isInExtension && now <= old post: result.timeSec == min(now + extensionTimeSecs,a.finishTime.timeSec)
Die Vorbedingung wirkt wie ein zu Beginn der Methode formuliertes ocl-Statement und die mit dem in der OCL zur Verfugung ¨ stehenden letKonstrukt definierten Variablen werden als lokale Variable verstanden. Die ¨ Ubersetzung dieser Spezifikation in erweitertes Java erfolgt in Abbildung 4.22 unter der Annahme, dass der eigentliche Methodenrumpf gegeben ist. Diese Methode aus Abbildung 4.22 kann, wie in in Anhang B, Band 1 beschrieben, in normales Java ubersetzt ¨ werden. Gem¨aß der in Abschnitt 4.4.3, Band 1 beschriebenen Bedeutung von Methodenspezifikationen muss die Nachbedingung nur erfullt ¨ sein, wenn die Vorbedingung gilt. Deshalb wird die Vorbedingung evaluiert und ihr Ergebnis in der Variable precond gespeichert, um in der Nachbedingung uberpr ¨ uft ¨ zu werden. Mit dieser Form der Transformation ist es moglich, ¨ mehrere Methodenspezifikationen, die unabh¨angig voneinander definiert oder geerbt wurden, gleichzeitig zu testen. Eine wie in Abschnitt 4.4.3, Band 1 beschriebene Integration ist daher fur ¨ diesen Zweck nicht notwendig. Je nach Generatoreinstellung werden ocl- und let-Anweisungen nicht ubersetzt, ¨ im Fehlerfall eine Exception erzeugt, eine Warnung im Protokoll vermerkt und nach Bedarf ein Auszug des aktuellen Objekts ausgegeben. Das let-Konstrukt zur Definition von Hilfsvariablen in Java, die nicht in den Produktionscode gehoren, ¨ wird wie erwartet durch lokale Variablendefinitionen realisiert. Es entsteht der in Abbildung 4.23 dargestellte Code,
4.3 Codegenerierung aus OCL
123
Java/P
class ConstantTimingPolicy { public Time newCurrentClosingTime(Auction a, Bid b) { let long old = a.closingTime.timeSec; let long now = b.time.timeSec; let boolean precond = (status==RUNNING && isInExtension && now <= old); // Rumpf der Java Funktion (ohne return-Anweisung) Time result = // Ausdruck der Return-Anweisung ocl !precond || (result.timeSec == OCL.min(now + extensionTimeSecs, a.finishTime.timeSec)); return result; }
}
Abbildung 4.22. OCL transformiert in erweitertes Java class ConstantTimingPolicy { Java public Time newCurrentClosingTime(Auction a, Bid b) { long old = a.closingTime.timeSec; long now = b.time.timeSec; boolean precond = (status==RUNNING && isInExtension && now <= old); // Rumpf der Java Funktion (ohne return-Anweisung) Time result = // Ausdruck der Return-Anweisung if(precond && !(result.timeSec == OCL.min(now + extensionTimeSecs, a.finishTime.timeSec)) alert(...); return result; } } Abbildung 4.23. OCL transformiert in Java
bei dem allerdings vereinfachend das Abfangen von Exceptions weggelassen wurde. Dieser relativ einfachen Umsetzung steht eine substantielle Komplexit¨at der Umsetzung von Methodenspezifikationen gegenuber, ¨ wenn die Nachbedingung auf die Ursprungswerte der Variablen zu Beginn des Methoden¨ aufrufs zugreift. Fur ¨ die Ubersetzung solcher Zugriffe ist eine Infrastruktur notwendig, die effizient feststellt, welche fruheren ¨ Werte gegebenenfalls benotigt ¨ werden und diese geeignet zwischenspeichert. Dabei konnen ¨ wie nachfolgend beschrieben deutliche Aufw¨ande entstehen. Dazu wird das folgende aus Abschnitt 4.4.3, Band 1 adaptierte Beispiel betrachtet, das den Ef-
124
4 Transformationen fur ¨ die Codegenerierung
fekt eines Unternehmenswechsels einer Person unter der Annahme, dass das Unternehmen bereits erfasst ist, beschreibt: context Person.changeCompany(String name) OCL pre: exists Company co: co.name == name == name && post: company.name company.employees == company.employees@pre +1 &&
[email protected] ==
[email protected]@pre -1
In der Nachbedingung wird unter anderem mit company@pre auf das vorherige Unternehmen der wechselnden Person und mit company.employees@pre auf die Anzahl der vorherigen Mitarbeiter des neuen Unternehmens zugegriffen. Der Ausdruck company@pre ist fur ¨ den Codegenerator leicht zu identifizieren und sein Inhalt zu speichern. Dies wirkt, als ob dabei eine interne Hilfsvariable angelegt wird. Gleiches gilt fur ¨ den Ausdruck
[email protected]@pre: context Person.changeCompany(String name) OCL let Company companyPre = company; int employeesPre = company.employees pre: exists Company co: co.name == name post: company.name == name && company.employees == company.employees@pre +1 && companyPre.employees == employeesPre -1
Schwierigkeiten bereitet jedoch company.employees@pre, weil hier auf den fruheren ¨ Zustand des neuen Unternehmens zugegriffen wird. Fur ¨ einen Codegenerator ist es faktisch unmoglich ¨ Code zu generieren, der zu Beginn einer Methodenausfuhrung ¨ err¨at, welches das neue company-Objekt sein wird und dann dessen alten Zustand speichert. Dieses Problem wird noch deutlicher am Ausdruck ad.auction@pre[id] sichtbar, der in der Klasse AllData zur Selektion einer Auktion mit dem Identifikator id verwendet werden kann. Da id erst nach Methodenausfuhrung ¨ evaluiert wird, ist unklar, welche Auktion des Ursprungszustands von ad.auction selektiert werden wird. Deshalb gibt es drei Strategien damit umzugehen: 1. Es werden die alten Zust¨ande aller company-Objekte gespeichert. Dies erfordert allerdings bereits fur ¨ kleine Testdatenstrukturen einen deutlichen Effizienzverlust und ist im Testeinsatz des Produktionssystems mit großen Datenbest¨anden nicht umzusetzen. 2. Fur ¨ Tests wird eine Infrastruktur generiert, die eine interne Protokollierung aller Attribut¨anderungen einschließlich der ursprunglichen ¨ Werte durchfuhrt. ¨ Dies erfordert ebenfalls eine geeignete Infrastruktur, hat aber ¨ unter Umst¨anden den Vorteil, dass die Anderungshistorie eines gescheiterten Tests analysiert werden kann. 3. Der Codegenerator warnt vor der Ineffizienz der Spezifikation oder weist sie sogar zuruck ¨ mit dem Hinweis, eine effizientere Formulierung
4.4 Ausfuhrung ¨ von Statecharts
125
zu finden. Der Entwickler hat meist eine gute Vorstellung, welche Objektzust¨ande tats¨achlich zu speichern sind und legt diese explizit in letAnweisungen ab. Wird eine Effizienzsteigerung durch manuelle Umsetzung gewunscht, ¨ so kann im Beispiel etwa aus der Vorbedingung erraten“ werden, welches ” company-Objekt relevant ist und damit die Vorbedingung vereinfacht werden kann: context Person.changeCompany(String name) OCL let Company newCo = AllData.ad.company[name] pre: newCo != null == name && post: company.name company.employees == newCo.employees@pre +1 &&
[email protected] ==
[email protected]@pre -1
Um sicherzugehen, dass das neue Unternehmen tats¨achlich mit dem in der let-Anweisung definierten Unternehmen ubereinstimmt, ¨ kann zus¨atzlich company==newCo in die Nachbedingung aufgenommen werden. Diese Form benotigt ¨ nun nur minimalen zus¨atzlichen Speicherplatz, wird allerdings bereits so detailliert und implementierungsnah, dass dann eine direkte Implementierung unter Umst¨anden vorzuziehen ist. 4.3.8 Vererbung von Methodenspezifikationen Ob eine Methodenspezifikation fur ¨ die Implementierungen der Unterklassen gilt, wird gem¨aß Abschnitt 4.4.3, Band 1 durch den Stereotyp notinherited bestimmt. Im Allgemeinen sind deshalb die geerbten Vor- oder Nachbedingungen zus¨atzlich zu testen. Fur ¨ eine redundanzfreie Implementierung werden die zu prufenden ¨ Bedingungen aber nicht direkt als Zusicherungen formuliert, sondern in eigenst¨andige Methoden ausgelagert, die in Unterklassen in geeigneter Form zur Verfugung ¨ stehen. Dieses Verfahren wird Percolation“ genannt [Bin99] und fuhrt ¨ zu der in Abbildung 4.24 dar” gestellten Implementierung. Ein Vorteil dieses Verfahrens ist, dass ein Testtreiber zus¨atzlich prufen ¨ kann, ob die Vorbedingung der Methodenspezifikation auch erfullt ¨ ist, indem er diese vorab auf den gegebenen Testdaten pruft. ¨ Dadurch wird verhindert, dass ein Test als Erfolg gewertet wird, weil die Testdaten f¨alschlicherweise so aufgebaut wurden, dass sie die Vorbedingung nicht erfullen. ¨ Das in Abbildung 4.24 dargestellte Verfahren kann analog fur ¨ Invarianten verwendet werden, so dass auch diese in den Unterklassen fur ¨ Tests zur Verfugung ¨ stehen.
4.4 Ausfuhrung ¨ von Statecharts Wie David Harel, dem die Erfindung der Statecharts zugeschrieben wird, gerne bemerkt, Buildings are there to be, but Software is there to do“. Da ”
126
4 Transformationen fur ¨ die Codegenerierung
class ConstantTimingPolicy { Java // Vorbedingung ohne/mit vorbelegten Parametern boolean preNewCurrentClosingTime(Auction a, Bid b) { long old = a.closingTime.timeSec; long now = b.time.timeSec; return preNewCurrentClosingTime(a,b,old,now); } boolean preNewCurrentClosingTime(Auction a, Bid b, long old, long now){ return status==RUNNING && isInExtension && now <= old; } // Nachbedingung boolean postNewCurrentClosingTime(Time result, Auction a, Bid b, long old, long now) { return result.timeSec == OCL.min(now + extensionTimeSecs,a.finishTime.timeSec); }
}
// Eigentliche Funktion public Time newCurrentClosingTime(Auction a, Bid b) { long old = a.closingTime.timeSec; long now = b.time.timeSec; boolean precond = preNewCurrentClosingTime(a,b,old,now); // Rumpf der Java Funktion (ohne return-Anweisung) Time result = // Ausdruck der Return-Anweisung if(precond && !postNewCurrentClosingTime(result,a,b,old,now)) alert(...); return result; }
Abbildung 4.24. OCL-Bedingungen transformiert in Java-Pr¨adikate
Statecharts in naturlicher ¨ Weise zur vollst¨andigen Beschreibung von Verhalten genutzt werden konnen, ¨ ist der Aspekt der Codegenerierung, also der Ausfuhrung ¨ von Statecharts, von besonderem Interesse. Deshalb wird in diesem Abschnitt auf Realisierungsstrategien fur ¨ Statecharts eingegangen, ohne ¨ jedoch vollst¨andige Ubersetzungsalgorithmen zu beschreiben. Das Ziel dieses Abschnitts ist es auch, dem Leser durch die Beschreibung der Beziehung zwischen syntaktischen Konzepten der Statecharts und Java-Codeelementen zum einen die Moglichkeit ¨ zu geben, manuell ein Statechart in Code zu ubersetzen. ¨ Genauso wichtig ist die dadurch entstehende Hilfestellung zum Verst¨andnis von Statecharts und ihrer Verwendung bei der Codegenerie¨ rung. Die Ubersetzung der Statecharts in Java dient sowohl als Semantikde-
4.4 Ausfuhrung ¨ von Statecharts
127
finition, als auch zur Verbesserung des intuitiven Zugangs den Statecharts. Die nachfolgend diskutierten Realisierungsstrategien zeigen alternative Umsetzungsmoglichkeiten ¨ von Statecharts in Java, die jedoch semantisch a¨ quivalent sind. Die Auswahl der fur ¨ ein Projekt geeigneten Umsetzungsstrategie h¨angt daher von der gewunschten ¨ Flexibilit¨at und Effizienzuberlegungen ¨ ab. Die Codegenerierung aus Statecharts ist noch keineswegs so verbreitet wie die auf Basis von Klassendiagrammen, jedoch nimmt die Verwendung von Statecharts fur ¨ die Implementierung stetig zu. Die eingebetteten Systeme sind hier der Wegbereiter: ... automatically generated code can and ” is being used today in a variety of hard real-time and embedded systems.“ [Dou99, S. 156]. Die nachfolgend diskutierten Varianten zur Umsetzung sind keineswegs vollst¨andig, sondern stellen nur einen Ausschnitt der Umsetzungsmoglich¨ keiten dar. Die bereits eingefuhrten ¨ Stereotypen statedefining, completion:ignore und weitere konnen ¨ zur Auswahl zwischen diesen Varianten verwendet werden. Nicht alles l¨asst sich jedoch bereits mit Stereotypen beschreiben, weshalb die Verwendung von Templates und Skripten fur ¨ die Codegenerierung von Statecharts sehr hilfreich ist. 4.4.1 Methoden-Statecharts Die Zust¨ande eines Statecharts konnen ¨ auf verschiedene Arten interpretiert werden. In einem Methoden-Statechart, wie dem in Abbildung 2.38, repr¨asentieren die Diagrammzust¨ande Zwischenzust¨ande innerhalb des Ablaufs einer Methode. Die Diagrammzust¨ande werden deshalb durch den Programmz¨ahler unterschieden. Diese Diagrammzust¨ande konnen ¨ noch einmal in zwei Klassen unterschieden werden. Zum einen gibt es Diagrammzust¨ande, die Stellen zwischen Anweisungen entsprechen und deren Fortfuhrung ¨ durch spontane ε-Transitionen erfolgt. Zum anderen gibt es Zust¨ande, in denen auf das Ergebnis eines Methodenaufrufs gewartet wird, der in einer ankommenden Transition gestartet wurde. W¨ahrend die Quellzust¨ande spontaner Transitionen vor allem dazu genutzt werden, den Kontrollfluss, wie zum Beispiel Verzweigungen, zu modellieren, stellen Quellzust¨ande von Transitionen, die mit dem Stimulus return markiert sind, echte Unterbrechungen der Ausfuhrungen ¨ einer Methode dar. Die Umsetzung eines Methoden-Statecharts erfolgt kanonisch durch die Generierung der beschriebenen Methode und ihres Rumpfs. Von besonderem Interesse ist die Behandlung von ε-Schleifen innerhalb eines Statecharts. Die Existenz einer ε-Schleife bedeutet, dass der Kontrollfluss innerhalb eines Methoden-Statecharts eine Schleife besitzt. Das Statechart selbst ist daher nicht mehr vollst¨andig in der Lage, das Verhalten der Methode zu beschreiben. Die Initialisierung, der Rumpf und die Abbruchbedingung der Schleife sind jeweils durch Aktionen zu beschreiben. Dabei ist nicht gesichert, dass die Schleife definitiv abbricht. Dennoch kann davon ausgegangen werden, dass modelliertes Verhalten grunds¨atzlich terminiert.
128
4 Transformationen fur ¨ die Codegenerierung
Diese Annahme ist aus pragmatischen Grunden ¨ sinnvoll, weil in der vorgeschlagenen Entwicklungsmethode Schleifen grunds¨atzlich mit Tests so uber¨ pruft ¨ werden, dass eine nichtterminierende Schleife entdeckt werden wurde. ¨ 4.4.2 Umsetzung der Zust¨ande Die Statecharts, die nicht zur Darstellung eines Methodenablaufs dienen, beinhalten keine Kontrollzust¨ande und daher auch keine spontanen Transitionen. Die Zust¨ande eines solchen Statechart entsprechen daher Datenzust¨anden des Objekts. Das heißt, der Diagrammzustand des Statecharts muss aus dem Datenzustand des Objekts rekonstruierbar sein. Dies wurde bereits bei der Transformation in vereinfachte Statecharts in Abschnitt 6.6.3, Band 1 diskutiert und ein Verfahren zur Darstellung von Diagrammzust¨anden gezeigt. Hier werden weitere Verfahren besprochen. Die Statecharts, die nicht zur Darstellung eines Methodenablaufs dienen, beinhalten keine Kontrollzust¨ande und daher auch keine spontanen Transitionen. Die Zust¨ande eines solchen Statechart entsprechen daher Datenzust¨anden des Objekts. Das heißt, der Diagrammzustand des Statecharts muss aus dem Datenzustand des Objekts rekonstruierbar sein. Dies wurde bereits bei der Transformation in vereinfachte Statecharts in Abschnitt 6.6.3, Band 1 diskutiert und ein Verfahren zur Darstellung von Diagrammzust¨anden gezeigt. Hier werden weitere Verfahren besprochen. Leichtgewicht: Nutzung der Zustandsinvarianten Als besonders einfach anzusehen ist die Strategie, die paarweise disjunkten Zustandsinvarianten des vereinfachten Statecharts zu nehmen, um aus einem Objekt den Diagrammzustand jeweils zu berechnen. Abbildung 4.25 zeigt schematisch eine solche Umsetzung. Bei dieser Transformation wird der linken Transition der Vorrang vor der mittleren Transition gegeben, da ¨ ihre Vorbedingung zuerst evaluiert wird. Uberlappen die beiden Vorbedingungen, also vorb1&&vorb2 ist nicht a¨ quivalent zu false, dann wurde damit eine Entwurfsentscheidung getroffen, die eine spezielle Implementierung aus der Menge der moglichen ¨ Implementierungen ausw¨ahlt. Der Vorteil dieser Umsetzung ist, dass kein zus¨atzliches Attribut notwendig ist, um den Diagrammzustand im Objekt zu speichern. Umgekehrt mussen ¨ im ungunstigsten ¨ Fall jedoch die Zustandsinvarianten aller Zust¨ande evaluiert werden, wodurch ein deutlicher Effizienzverlust auftreten kann. Deshalb ist diese Umsetzung nur fur ¨ effizient evaluierbare Zustandsinvarianten sinnvoll. Meist bestehen eine Reihe von Optimierungsmoglichkeiten, ¨ weil Zustandsinvarianten verwandter“ Zust¨ande oft gemeinsame Teilbe” ¨ dingungen besitzen, deren Evaluierung nur einmal notwendig ist. Ahnliches gilt fur ¨ die Evaluierung der Vorbedingungen von Transitionen mit demselben Quellzustand. Gilt zum Beispiel vorb1<=>!vorb2, so l¨asst sich die innere if-Abfrage in Abbildung 4.25 deutlich vereinfachen.
4.4 Ausfuhrung ¨ von Statecharts
129
¨ Abbildung 4.25. Ubersetzung unter Ausnutzung von Zustandsinvarianten
Optimierungen bei der Codegenerierung, wie die oben besprochenen, sind im Allgemeinen nicht automatisiert erkennbar. Jedoch besteht die berechtigte Hoffnung, dass die Werkzeuge zur Generierung von Code aus Modellen in der n¨achsten Zukunft a¨ hnliche Optimierungsalgorithmen einbauen werden, wie dies fur ¨ Compiler textueller Programmiersprachen heute bereits der Fall ist. Bis dahin ist damit zu rechnen, dass die gesteigerte Entwicklereffektivit¨at bei der Verwendung abstrakter Modelle zu gewissen Effizienznachteilen beim realisierten Code fuhrt. ¨ Unter Umst¨anden ist dann, wie etwa bei den Herstellern eingebetteter Systeme, durchaus zu beobachten, dass nach Fertigstellung der Modelle zu Simulations- und Validierungszwecken ein zus¨atzlicher manueller Schritt zur Optimierung des Ergebnisses sinnvoll ist. Dafur ¨ lassen sich Refactoring-Techniken auf Ebene der Zielsprache ebenso verwenden, wie die Verwendung zus¨atzlicher Steuerungsmechanismen bei der Generierung des Codes. Beispielsweise konnen ¨ durch die Vergabe von Priorit¨aten und die Zusicherung der Disjunktheit von Vorbedingungen dem Codegenerator Optimierungen vorgeschlagen werden. Zust¨ande als Pr¨adikate Eine Variation der gezeigten Umsetzung ist in 4.26 zu sehen, in der die Auswertung einzelner Zustandsinvarianten und Aktionen in eigene Methoden ausgelagert wurde. Die Hilfsmethoden zur Umsetzung von Aktionen lassen sich dann gegebenenfalls wiederverwenden, wenn verschiedene Transitionen dieselbe Aktion besitzen. Die Auslagerung der Evaluierung von Zustandsinvarianten in eigene Pr¨adikate, die den Zustandsnamen als Pr¨adikatnamen tragen, hat daruber ¨ hinaus den Vorteil, dass auf diese Weise der Diagrammzustand des Statecharts an beliebigen Stellen im Code festgestellt
130
4 Transformationen fur ¨ die Codegenerierung
werden kann. Dies ist besonders fur ¨ Methoden hilfreich, deren Verhalten nicht im Statechart spezifiziert ist, aber dennoch von dem im Statechart modellierten Zustandskonzept abh¨angt.
Abbildung 4.26. Pr¨adikate evaluieren Zustandsinvarianten
Aufz¨ahlungsattribut als Speicher fur ¨ den Zustand Ist die Evaluierung der Zustandsinvarianten zu ineffizient, so eignet sich der heute meistens genutzte Standardweg, den Diagrammzustand in Form eines Attributs, das eine Aufz¨ahlung beinhaltet, explizit im Zustandsraum des Objekts abzulegen. Zur Feststellung des Diagrammzustands reicht es nun, das status-Attribut zu prufen. ¨ Abbildung 4.27 zeigt die verwendbare Codegenerierung. Vollst¨andiges Statechart Die Verwendung eines Attributs zur Speicherung des Diagrammzustands fuhrt ¨ zu einer besseren Laufzeiteffizienz, verhindert jedoch nicht, dass weiterhin die Vorbedingungen von alternativen Transitionen gepruft ¨ werden mussen. ¨ Allerdings kann die jeweils letzte Vorbedingung sowie auch die Zustandsinvariante in einer assert-Anweisung eingesetzt werden, um statt im konstruktiven Anteil der Implementierung zu Testzwecken verwendet zu werden.14 Abbildung 4.28 zeigt eine entsprechend modifizierte Umsetzung. 14
Um aussagekr¨aftige Testresultate zu erhalten, empfiehlt es sich, anstatt der von Java 1.4 zu Verfugung ¨ gestellten assert-Anweisung das in Abschnitt 5.2.3 diskutierte Test-Framework zu verwenden.
4.4 Ausfuhrung ¨ von Statecharts
131
Abbildung 4.27. Diagrammzustand wird in Attribut gespeichert
Abbildung 4.28. Verwendung von Zustandsinvarianten als Zusicherungen
Wurde das Statechart nicht, wie in Abschnitt 6.6.3, Band 1 beschrieben, explizit vervollst¨andigt, so kann in Abh¨angigkeit der gew¨ahlten Semantik diese Vervollst¨andigung auch w¨ahrend der Codegenerierung durchgefuhrt ¨ werden. Dazu dient zum Beispiel die default-Anweisung, die alle nicht durch explizite Transitionen abgedeckten Situationen abfangen kann. Auch kann zum Beispiel ein weiterer Wert in der Aufz¨ahlung der Zust¨ande in der
132
4 Transformationen fur ¨ die Codegenerierung
Form ERROR==-1 eingefuhrt ¨ werden, der in solchen Situationen angenommen wird. Fur ¨ das Abfangen von Exceptions aufgrund des Stereotyps excepti on kann eine umfassende try-catch-Anweisung verwendet werden. Dabei mussen ¨ allerdings je nach gew¨ahlter Umsetzungsstrategie mehrere Anweisungen in verschiedenen Methoden oder case-Alternativen eingesetzt werden. Schwergewicht: State-Entwurfsmuster Eine weitere Moglichkeit ¨ zur Umsetzung des Zustandskonzepts ist die Verwendung des State-Entwurfsmusters, zum Beispiel beschrieben in [GHJV94]. Dieses Entwurfsmuster wird als Schwergewicht bezeichnet, da es zu einer Reihe von zus¨atzlichen Klassen fuhrt. ¨ Der Zustand des eigentlich modellierten Objekts wird ausgelagert in eine eigene Zustandsklasse. Diese besitzt mehrere Unterklassen, die je einem Zustand des eigentlich modellierten Objekts entsprechen. Der aktuelle Zustand des Objekts wird durch Referenz auf eines dieser Zustandsobjekte gespeichert. Das Verhalten wird nicht direkt in der modellierten Methode realisiert, sondern an dieses Zustandsobjekt delegiert. Dadurch wird das im Statechart auf den Transitionen verteilte Verhalten nicht innerhalb einer Methode zusammengefasst, sondern entsprechend der Zust¨ande gruppiert. Dies bietet zum Beispiel die Flexibilit¨at, das Verhalten an einem Quellzustand durch Unterklassenbildung zu modifizieren. Der notationelle und operative Aufwand fur ¨ das State-Entwurfsmuster ist allerdings immens. So muss ein Management der Zustandsobjekte realisiert werden, das entweder dynamisch solche Objekte erzeugt oder in einem Pool von Objekten speichert. Abbildung 4.29 zeigt daher nur einen kleinen Ausschnitt der Umsetzung in einem State-Entwurfsmuster. Die Codeteile invarianteA’ und aktion1’ sind dabei entsprechend anzupassen, da die darin enthaltenen Attribute und Methodenaufrufe auf das Ursprungsobjekt k statt self zugreifen mussen. ¨ Die Verwendung des State-Entwurfsmusters ist nur zu empfehlen, wenn die dadurch entstehende Flexibilit¨at den Zusatzaufwand bei der Generierung rechtfertigen kann. Da die Umsetzung eines Statecharts in Java-Code normalerweise automatisiert erfolgt und ein manueller Eingriff in den generierten Code im Allgemeinen nicht sinnvoll ist, sollte dementsprechend auch das State-Entwurfsmuster nur selten ad¨aquat sein. 4.4.3 Umsetzung der Transitionen Stimuli Wie Abbildung 2.37 zeigt, werden drei Arten von Stimuli unterschieden. Spontane Transitionen und Empfang von return-Ergebnissen treten nur in¨ nerhalb von Methoden-Statecharts auf. Die Ubertragung asynchroner Nachrichten und der Methodenaufruf werden im Statechart nicht unterschieden.
4.4 Ausfuhrung ¨ von Statecharts
133
Abbildung 4.29. Schwergewicht: State-Entwurfsmuster
Erst bei der Umsetzung in Code ist die Unterscheidung zwischen einem Methodenaufruf und der Verwendung von Nachrichtenobjekten zur asyn¨ chronen Ubertragung relevant. Handelt es sich um einen Methodenaufruf, so wird dieser, wie bereits im letzten Abschnitt beschrieben, durch eine entsprechende Methode implementiert. Wird eine Objektifizierung der Stimuli vorgenommen, so werden Events typischerweise in Form einer Klassenhierarchie mit einer abstrakten Oberklasse Event umgesetzt, deren Unterklassen jeweils einzelnen Nachrichtentypen entsprechen. Nachrichten werden durch Aufruf des entsprechen¨ den Konstruktors erzeugt und durch einen geeigneten Ubertragungsund Scheduling-Mechanismus beim Zielobjekt zur Ausfuhrung ¨ gebracht. Fur ¨ den Transport dieser Nachrichten stehen eine Reihe von Frameworks und Middleware-Komponenten, wie zum Beispiel Corba [OH98], zur Verfugung. ¨ Weitere Varianten sind die Serialisierung der Nachrichtenobjekte zum Bei¨ spiel mit XML [W3C00] oder die Ubertragung durch ein selbstdefiniertes, typischerweise effizienteres Protokoll. Aufgrund der hohen Auswahl an zur Verfugung ¨ stehenden Losungen ¨ soll dieser technische Aspekt der Kommunikation hier nicht weiter vertieft werden. Fur ¨ die Umsetzung des Statecharts ist letztendlich nur wesentlich, dass das Nachrichtenobjekt an das zu verarbeitende Objekt ubergeben ¨ wird, indem eine geeignete Methode aufgerufen wird. Abbildung 4.30 skizziert eine mogliche ¨ Realisierung auf Basis einer doppelten switch-Anweisung. Durch Definition von Methoden, die jeweils ein spezifisches Nachrichtenobjekt verarbeiten oder durch Auslagerung der Verarbeitung einer Methode auf abh¨angige Objekte konnen ¨ auch in
134
4 Transformationen fur ¨ die Codegenerierung
diesem Fall die bereits fruher ¨ diskutierten Varianten zur Codegenerierung angewandt werden.
Abbildung 4.30. Verwendung von Event-Objekten als Stimuli
Ein bereits fruher ¨ diskutierter Vorteil der Verwendung asynchron kommunizierter Nachrichten ist die Vermeidung von rekursiven Objektaufrufen. Die Verarbeitung eines Nachrichtenobjekts findet immer unter exklusivem Zugriff auf den Objektzustand statt. Eine Parallelverarbeitung mehrerer Nachrichten ist ausgeschlossen. Um das sicherzustellen, werden geeignete Synchronisationsmechanismen der Programmiersprache Java eingesetzt. In einem Statechart konnen ¨ auch die Verarbeitung von Nachrichten und Methodenaufrufe gemischt vorkommen. Fur ¨ das Statechart ist letztendlich unerheblich, ob der Stimulus durch die spezielle Methode receive zur Nachrichtenverarbeitung oder durch einen normalen Methodenaufruf bearbeitet wird. Zu beachten ist nur, dass innerhalb einer Aktion des Statecharts keine weiteren Methodenaufrufe an dasselbe Objekt stattfinden, die bezuglich ¨ des Statecharts eine zustandsver¨andernde Wirkung besitzen. Diese, als Rekursionsfreiheit bezeichnete Bedingung, wurde bereits in den Abschnitt 6.1, Band 1 ausfuhrlich ¨ diskutiert. Aktionen Die Aktionsbeschreibungen eines Statecharts bestehen aus zwei moglichen ¨ Komponenten. Die prozedural formulierten Aktionen konnen ¨ nach Anpassung von Attibutzugriffen, etc. gem¨aß Abschnitt 4.1 in den generierten Code ubernommen ¨ werden. Wurde ein zus¨atzliches Attribut zur Speicherung des
4.4 Ausfuhrung ¨ von Statecharts
135
Diagrammzustands eingefuhrt, ¨ so ist zum Ende der Aktion eine zus¨atzliche Zuweisung des neuen Zustands notwendig. Die Umsetzung in Abbildung 4.27 illustriert dies. Wurden bei den Aktionen zus¨atzlich oder ausschließlich OCL-Nachbedingungen verwendet, so kann daraus im Allgemeinen kein operationeller Code generiert werden. Der Einsatz eines solchen Statecharts zur Programmierung ist daher nicht moglich. ¨ Solche Nachbedingungen werden deshalb typischerweise nur zur abstrakten Spezifikation von Verhalten verwendet, das zum einem bei einer Implementierung manuell in ablauff¨ahigen Code umgesetzt oder zum anderen bei Tests eingesetzt wird. Die Nachbedingungen konnen ¨ deshalb nur mithilfe von ocl-Anweisungen in den Code umgesetzt werden. Existente Codegenerierungen fur ¨ Statecharts Naturlich ¨ ist die oben beschriebene Form nicht die erste Form der Umsetzung von Statecharts in Code. Mehrere Werkzeuge, wie zum Beispiel Statemate oder Rhapsody [HN96] sowie einige der neueren UML-basierten Werkzeuge und Ans¨atze wie [SZ01, BS01a, BLP01] ubersetzen ¨ ihre Version der Statecharts in produktiven Code. Dabei werden teilweise auch Konzepte wie parallele Zust¨ande, ein History-Mechanismus, Pseudozust¨ande oder echte Parallelit¨at innerhalb eines Zustands umgesetzt, die hier nicht eingefuhrt ¨ wurden. Dies liegt unter anderem an der bisher dominierenden Verwendung von Statecharts zur Modellierung verteilter und eingebetteter Systeme, die meist einen hoheren ¨ Kontrollanteil besitzen als die datenlastigen Gesch¨aftssysteme [Dou98, Dou99]. Statecharts wurden bereits in [Har87] eingefuhrt ¨ und in [vdB94] wurde die bis dahin entstandene Vielzahl von Semantiken verglichen sowie in [vdB01] die UML-Semantik der Statechart in den Vergleich einbezogen. Ein interessantes Merkmal dieser Semantiken ist, dass sie teilweise unterschiedliches Verhalten beschreiben und damit zu unterschiedlichen Implementierungen der Statecharts fuhren, ¨ teilweise aber auch nur verschiedene Mechanismen nutzen, um den Statecharts die essentiell gleiche Semantik zuzuweisen. Von besonderer Aufmerksamkeit ist die Behandlung der Priorisierung und Unterbrechbarkeit von Transitionen verschiedener Hierarchieebenen und die damit eng verbundene Run to Completion“-Problematik fur ¨ State” charts. W¨ahrend fur ¨ eingebettete Systeme die a¨ ußeren Transitionen (bezogen auf den Quellzustand) bevorzugt werden, wird zum Beispiel in [HG97] fur ¨ objektorientierte Statecharts diese Priorisierung umgekehrt und inneren Transitionen der Vorzug gegeben. Der hier verfolgte Ansatz, dies uber ¨ Stereotypen dem Modellierer selbst entscheiden zu lassen, fuhrt ¨ zu mehr Flexibilit¨at. Run to Completion“ spielt bei den UML/P-Statecharts keine Rolle, ” denn wegen dem zugrunde liegenden, auf Java basierendem Maschinenmodell wird davon ausgegangen, dass die Exceptions, die als Stimuli auftreten,
136
4 Transformationen fur ¨ die Codegenerierung
durch das Statechart selbst oder eine aus einer Aktion des Statecharts heraus aufgerufenen Methode verursacht sind und daher eine Weiterfuhrung ¨ der Transition zu einem naturlichen ¨ Ende nur beschr¨ankt sinnvoll ist. Die Moglichkeit ¨ paralleler Verarbeitung von Transitionen in demselben Objekt wird durch die grunds¨atzlich verwendete Synchronisation auf zustandsbehafteten Objekten ausgeschlossen.
¨ 4.5 Ubersetzung von Sequenzdiagrammen Ein Sequenzdiagramm ist in seiner Natur exemplarisch. Es zeigt einen einzelnen moglichen ¨ Ablauf eines Systems, das typischerweise abh¨angig von der aktuellen Objektstruktur, den Inhalten der Attribute und der Systemumgebung alternative Abl¨aufe erlaubt. Die Beschreibung eines exemplarischen Ablaufs ist fur ¨ die konstruktive Codegenerierung nur schlecht geeignet. Die einzige Moglichkeit, ¨ einen exemplarischen Ablauf konstruktiv einzusetzen, ergibt sich, wenn eine damit modellierte Methode nur einen Ablauf besitzt. Sie darf dann keine Verzweigungen des Kontrollflusses oder Iterationen beinhalten. Eine derartig einfache Struktur haben typischerweise meist nur Testtreiber. Da Sequenzdiagramme jedoch vor allem fur ¨ die Modellierung von Tests eingesetzt werden, ist eine Codegenerierung fur ¨ die Prufung ¨ von Testabl¨aufen notwendig. 4.5.1 Sequenzdiagramm als Testtreiber Abbildung 4.31 enth¨alt ein typisches Sequenzdiagramm, von dem fur ¨ das Objekt t eine Methode generiert werden soll, die die mit dem Stereotyp trigger markierten Aufrufe durchfuhrt. ¨
Abbildung 4.31. Sequenzdiagramm mit Treiber
Die zu generierende Methode benotigt ¨ einen Namen, der aus dem Diagrammnamen extrahiert werden kann. In Kombination mit einem standard-
¨ 4.5 Ubersetzung von Sequenzdiagrammen
137
m¨aßig festgelegten Pr¨afix runSD ergibt sich damit der in der Klasse Class generierte Methodenname runSDTreiber in der Klasse. Die Signatur dieser Methode ist wie bei der konstruktiven Umsetzung von Objektdiagrammen gepr¨agt durch die freien Variablen des Sequenzdiagramms. Im Beispiel werden daher zumindest die beiden anderen Objekte a und b als Parameter eingesetzt. Freie Variablen, die zuerst als Argumente eines trigger-Aufrufs auftreten, werden ebenfalls als Parameter aufgenommen. Demgegenuber ¨ werden freie Variablen, die in Returns das erste Mal verwendet werden, durch diesen Return-Wert belegt. Aufrufe und Returns zwischen anderen Objekten des Sequenzdiagramms sowie Aufrufe an Treiber-Objekte werden bei der Codegenerierung fur ¨ die angegebene Methode ignoriert. Als Ergebnis entsteht der in Abbildung 4.32 angegebene Code. class Class { ... public void runSDTreiber(A a, B b, Type2 args2) { Type value = a.m1(); a.m2(args2); b.m3(); } }
Java
Abbildung 4.32. Aus einem Sequenzdiagramm generierter Treiber
Die Typen der im Sequenzdiagramm angegebenen Variablen konnen, ¨ soweit nicht aus dem Sequenzdiagramm ersichtlich, aus dem Kontext, also zum Beispiel der Signatur der Klassen A und B, bestimmt werden. Als Erweiterung konnte ¨ es von Interesse sein, zwischendurch und am Ende zus¨atzliche Aktionen in Form von Java-Code anzugeben, die zum Beispiel ein explizites Return-Ergebnis der Methode berechnen. Fur ¨ den Einsatz als Testtreiber ist allerdings die angegebene Form der Codegenerierung ausreichend. Eine Vereinfachung entsteht zum Beispiel, wenn die Variable a bereits als Attribut der Klasse Class deklariert ist. Dann wird auf die Verwendung des Parameters a verzichtet. Das Verfahren zur konstruktiven Umsetzung von Teilen eines Sequenzdiagramms kann auch eingesetzt werden, wenn der Methodenaufruf der generierten Methode im Sequenzdiagramm selbst angegeben ist. Abbildung 4.33 beschreibt ein Dummy-Objekt, das eine einfache Implementierung der Methode foo() benotigt. ¨ Diese wird nach demselben Verfahren generiert und steht damit fur ¨ den in Abbildung 4.33 angegebenen Test zur Verfugung. ¨ Das Zielobjekt b der durch foo() aufzurufenden Methode ist als Attribut in der Klasse Dummy festgelegt. Die Besetzung der Objektstruktur wird typischerweise durch ein Objektdiagramm vorgenommen.
138
4 Transformationen fur ¨ die Codegenerierung
Abbildung 4.33. Sequenzdiagramm mit Treiber und Dummy
4.5.2 Sequenzdiagramm als Pr¨adikat Ein Sequenzdiagramm beschreibt genau wie ein Objektdiagramm eine exemplarische Eigenschaft des Systems. Im Gegensatz zu einem Objektdiagramm kann diese aber nicht an einem Snapshot eines Systems, sondern muss w¨ahrend eines Systemablaufs gepruft ¨ werden. Um die w¨ahrend eines Ablaufs auftretenden Interaktionen prufen ¨ zu konnen, ¨ ist eine entsprechende Instrumentierung des Codes notwendig. Dabei muss zu Beginn und am Ende jeder beobachteten Methode eine Mitteilung uber ¨ deren Aufruf beziehungsweise Terminierung erfolgen. Dabei ist auch die anormale Terminierung durch eine Exception zu protokollieren. Dies kann innerhalb der instrumentierten Methode, aber auch durch das Adapter-Entwurfsmuster [GHJV94] erfolgen. Ein solcher Adapter kann zum Beispiel durch Redefinition der Methode in einer Unterklasse gebildet werden. Das Prinzip fur ¨ die Klasse A aus Abbildung 4.33 ist in Abbildung 4.34 dargestellt. Es ist allerdings in der Praxis sinnvoll, diese Informationen statt an ein globales Objekt SDlog zu ubergeben, ¨ aus dem Aufrufkeller uber ¨ die Virtual Machine auszulesen. Der Algorithmus zur Erkennung, ob ein Sequenzdiagramm in der angegebenen Form abgearbeitet wurde, basiert auf der in Abbildung 7.14, Band 1 angegebenen Form zur Interpretation eines Sequenzdiagramms als regul¨arer Ausdruck. Der regul¨are Ausdruck wird zun¨achst in einem nichtdeterministischen endlichen Automaten15 realisiert, der es erlaubt, diesen regul¨aren Ausdruck zu erkennen. Abbildung 4.35 demonstriert dies an einem Beispiel. Im Sequenzdiagramm konnen ¨ prototypische Objekte auftreten, fur ¨ die zun¨achst keine Zuordnung zu echten Objekten existiert. Diese Zuordnung findet bei der jeweils ersten Interaktion mit einem passenden Objekt statt. Deshalb werden die Zust¨ande des nichtdeterministischen Automaten um die Konfiguration dieser Objekte sowie weiterer freier Variablen erweitert. 15
Der Automat dient zur Erkennung von Eingabesequenzen und hat mit den in Kapitel 6, Band 1 beschriebenen Statecharts formal nichts zu tun.
¨ 4.5 Ubersetzung von Sequenzdiagrammen
139
class Ainstrumented extends A { ... Java public Type method() { // Protokolliere Methodenaufruf (Objekt, Methode, leere Argumentliste) SDlog.call(this, "method", new Object[] {}); Type result; try{ // Eigentlicher Aufruf result = super.method(); catch (Exception ex) { // Protokolliere Exception SDlog.exceptionReturn(this, "method", ex); throw ex; } // Protokolliere Return + Ergebnis SDlog.normalReturn(this, "method", result); return result; } } Abbildung 4.34. Adapter zur Codeinstrumentierung
Deshalb kann ein Automat mehrfach denselben Zustand mit verschiedenen Objektkonfigurationen einnehmen. Nach jeder Interaktion werden eventuell im Sequenzdiagramm nachfolgende OCL-Bedingungen gepruft ¨ und die Konfigurationen, welche die Bedingung nicht erfullen, ¨ entfernt. Dies kann im Automaten durch eine zus¨atzliche Transition dargestellt werden, die keine Interaktion verarbeitet, aber eine Vorbedingung besitzt. Beginnend mit einer Konfiguration im Startzustand wird unter Umst¨anden eine leere Menge von gultigen ¨ Konfigurationen erreicht. Ein Sequenzdiagramm gilt als erfullt, ¨ wenn nach der Testdurchfuhrung ¨ der Endzustand in den erreichten Konfigurationen enthalten ist. Als Nebenerzeugnis der Prufung ¨ entsteht dabei auch die Belegung der freien Variablen und der prototypischen Objekte. Die verschiedenen durch den Stereotyp match w¨ahlbaren Semantiken fur ¨ Sequenzdiagramme werden durch die in Abbildung 7.14, Band 1 beschriebene Beschr¨ankung von Interaktionen, die ignoriert werden durfen, ¨ umgesetzt. Der beschriebene Algorithmus kann anhand des in Abbildung 4.35 beschriebenen Sequenzdiagramms illustriert werden. Dabei wird von konkreten Werten der Parameter abstrahiert. Diese konnen ¨ genauso behandelt werden, wie die OCL-Bedingungen, also zus¨atzlich gepruft ¨ werden. Abbildung 4.35 beinhaltet auch den Automaten, der zur Erkennung des Sequenzdiagramms verwendet wird.
140
4 Transformationen fur ¨ die Codegenerierung
Abbildung 4.35. Erkennender Automat aus einem Sequenzdiagramm
Die ubliche ¨ Konstruktion, um den Automaten deterministisch zu machen und zu minimieren [HU90], kann aufgrund der Konfigurationen, die Auswirkungen auf die Schaltbereitschaft weiterer Transitionen und die Evaluierung der OCL-Bedingungen haben, im Allgemeinen nicht durchgefuhrt ¨ werden. Dies w¨are zum Beispiel moglich, ¨ wenn die im Sequenzdiagramm dargestellten Objekte im Voraus auf echte Objekte zugeordnet werden konnten. ¨ Andererseits hat zum Beispiel ein Automat, der aus einem mit dem Stereotyp match:complete markierten Sequenzdiagramm entsteht, keine Schleifen und ist damit bereits deterministisch. Ein Sequenzdiagramm, das bereits teilweise zur konstruktiven Generierung von Treibern benutzt wurde, kann zus¨atzlich zu einer Prufung ¨ verwendet werden. Dass dabei auch der Testtreiber instrumentiert wird, erzeugt nur wenig Zusatzaufwand, ist aber notwendig, um die Reihenfolge der auftretenden Nachrichten und die OCL-Bedingungen prufen ¨ zu konnen. ¨
4.6 Zusammenfassung zur Codegenerierung Kapitel 3 und dieses Kapitel diskutieren zun¨achst grunds¨atzliche Fragestellungen zur Codegenerierung, beginnend mit der Ausdrucksm¨achtigkeit der UML/P bis hin zu einer sinnvollen Architektur eines Codegenerators, der die notwendige Flexibilit¨at und Parametrisierbarkeit besitzt, um verschiedenen Zielplattformen und unterschiedlichen Einsatzgebieten der UML/P gerecht zu werden. Statt einer tats¨achlichen Darstellung der Skripte und Templates wurde eine abstrakte, an den Darstellungen von Regelkalkulen ¨ orientierte
4.6 Zusammenfassung zur Codegenerierung
141
Form gew¨ahlt, um Transformationen darzustellen. Dabei wurde der pragmatische Ansatz unvollst¨andiger und verkurzender ¨ Transformationsregeln in Kombination mit erkl¨arendem Text gew¨ahlt. Die Umsetzung der einzelnen UML/P-Notationen in Code werden auf Basis dieser Transformationsregeln in diesem Kapitel beschrieben. Ausblick zur Codegenerierung Die Ans¨atze der ersten Generation von CASE-Werkzeugen zeigen, dass bei der Verwendung von Codegenerierung neben den in diesem Kapitel beschriebenen Vorteilen auch einige Nachteile in Kauf zu nehmen sind. So ist die Wartbarkeit eines mit Codegenerierung entwickelten Systems davon abh¨angig, ob der Codegenerator in der verwendeten oder einer aufw¨artskompatiblen Form w¨ahrend des Einsatzzeitraums des Produktionssystems zur Verfugung ¨ steht. Ist das nicht der Fall, ist der einzige Ausweg, den generierten Code manuell weiterzubearbeiten. Wird zum Beispiel die technische Plattform migriert, so ist es daruber ¨ hinaus notwendig, dass Entwickler mit F¨ahigkeiten zur Anpassung ( Programmierung“) des Generators zur ” Verfugung ¨ stehen. Wird ein Codegenerator daher im eigenen Projekt entwickelt, dann sollte er sehr einfach sein geschrieben und seine Verwendung wenn bei Wartung und Evolution des Systems notwendig wieder rekonstruierbar sein. Die Komplexit¨at der heutigen Quellsprachen wie UML steht aber im Widerspruch zu diesem Wunsch. Als vernunftige ¨ Alternative steht daher ein extern entwickelter, produktreifer Codegenerator zur Diskussion, der eine ausreichende Stabilit¨at aufweist, um auch in der Wartungsphase noch zur Verfugung ¨ zu stehen. Um Inkompatibilit¨aten bei Versionswechseln zu verhindern oder wenigstens zu minimieren, ist hier eine Standardisierung a¨ hnlich der Standardisierung von Compilern und der Semantik der zugrunde liegenden Sprachen geboten. Eine fur ¨ diese Zwecke ausreichend detaillierte Standardisierung ist in der UML-Standardisierungsdiskussion derzeit nicht zu finden. Dennoch konnte ¨ die Interoperabilit¨at heutiger UML-Werkzeuge einen gewissen Standardisierungseffekt fur ¨ die Codegenerierung bewirken. Die Stabilit¨at von Generierungswerkzeugen und das Vorhandensein geeigneter Experten ist unter Umst¨anden bei Open-Source-Werkzeugen wie ARGO/UML [RVR+ 01] und seinem Nachfolger Poseidon [BBWL01, BS01a] großer ¨ als bei kommerziellen Werkzeugen, da die quasi demokratisch organisierte Weiterentwicklung des Werkzeugs plotzliche ¨ Inkompatibilit¨aten verhindert und einen großeren ¨ Entwicklerstamm schafft. Auch vermeidet die Offenlegung des Quellcodes in Open-Source-Projekten Situationen, in denen der Hersteller kommerzieller Werkzeuge seine T¨atigkeit einstellt und ein Upgrade damit grunds¨atzlich nicht mehr moglich ¨ ist.
5 Grundlagen des Testens
Qualit¨at ist kein Zufall; sie ist das Ergebnis angestrengten Denkens. John Ruskin
Die Durchfuhrung ¨ von Tests fur ¨ alle Teile des Produktionssystems ist eine wesentlichen Maßnahme zur Softwarequalit¨atssicherung. Das Testen der Implementierung auf Robustheit, Konformit¨at zur Spezifikation, Korrektheit gegenuber ¨ den Anforderungen muss daher essentieller Bestandteil jeder qualit¨atsorientierten Softwareentwicklungsmethode sein. In diesem Kapitel werden die dazu notwendigen Grundlagen gekl¨art.
5.1 5.2
Einfuhrung ¨ in die Testproblematik . . . . . . . . . . . . . . . . . . . 144 Definition von Testf¨allen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
144
5 Grundlagen des Testens
Ein System, das den Anwender erfolgreich in seiner T¨atigkeit unterstutzen ¨ soll, muss moglichst ¨ frei von Fehlern sein. Da Softwaresysteme eine große Komplexit¨at besitzen, ist davon auszugehen, dass praktisch relevante Systeme nie vollst¨andig fehlerfrei sein werden. Wesentliche Aufgabe der Entwicklung ist es daher, die Fehlerrate und ihre Auswirkungen unter den vorhandenen zeitlichen und personellen Ressourcen so weit wie mo¨ glich zu minimieren und die fur ¨ die Anwendungsdom¨ane notwendige Qualit¨at zu erreichen. Das Testen des Softwaresystems ist dabei ein wesentliches Hilfsmittel zur Erkennung von Fehlern. Allgemein anerkannt ist, dass der Testaufwand im Durchschnitt ca. 40-50% des Gesamtaufwands der Softwareentwicklung betragen kann [Kru00a, Mye00]. Tests wurden sowohl in traditionellen als auch agilen Vorgehensweisen als wesentliches Kriterium zur Qualit¨atssicherung erkannt. Deshalb sind die in diesem Kapitel diskutierten Techniken nicht auf agile Methoden beschr¨ankt, sondern werden in der einen oder anderen Form seit l¨angerem eingesetzt. Durch die intensive Integration der Testentwicklung in die Methodik, dem Wunsch nach moglichst ¨ einfacher und effektiver Definition von Tests und dem durchg¨angigen Einsatz der UML fur ¨ Test- und Codegenerierung sind aber Anpassungen und Erweiterungen vorhandener Vorgehensweisen zur Testdefinition sinnvoll. Die große Anzahl verfugbarer ¨ Literatur zum Thema Testen allgemein und objektorientierter Systeme insbesondere zeigt, dass es sehr viele unterschiedliche Herangehensweisen und Techniken zur Testentwicklung gibt. Es w¨are jenseits der Kapazit¨at dieses Kapitels, das darin entwickelte Wissen zur Entwicklung und zum Management von Tests wiedergeben zu wollen. Stattdessen wird an den jeweils relevanten Stellen auf geeignete weiterfuhrende ¨ Literatur verwiesen. Der Inhalt dieses Kapitels richtet sich in der Terminologie weitgehend nach [Bin99], [Mye00], [Bal98] beziehungsweise [Lig90]. Der Inhalt dieses Kapitels ist deshalb keine allgemeine Einfuhrung ¨ in Testverfahren und -technologien, sondern nimmt eine kompakte Begriffsbestimmung fur ¨ Tests und eine Diskussion technischer Grundlagen vor. Im folgenden Kapitel 6 werden diese Grundlagen dann mit der UML/P umgesetzt. Fur ¨ erg¨anzende Vorgehensweisen zur Testentwicklung seien das eher pragmatische Buch [LF02] zum Thema Test-First“, die ausfuhrliche ¨ Samm” lung an Testtechniken in [Bei90, Bei95], das objektorientierte, ebenfalls um¨ fassende Analogon [Bin99] und die kompakte Ubersicht zur Testtheorie [Bal98] empfohlen. In seinen Grundzugen ¨ nach wie vor gultig ¨ ist [Mye79] (aktuelle deutsche Fassung [Mye00]).
5.1 Einfuhrung ¨ in die Testproblematik Zur Sicherung oder Verbesserung der Qualit¨at von Software gibt es eine Reihe von Verfahren, die w¨ahrend eines Softwareentwicklungsprojekts oder
5.1 Einfuhrung ¨ in die Testproblematik
145
projektubergreifend ¨ zum Einsatz kommen konnen. ¨ Qualit¨at“ ist ein viel ge” brauchter Begriff, der jedoch nur schwer zu definieren ist. In [Lig90] werden eine Reihe von Qualit¨atseigenschaften genannt, von denen unter anderem die zur Produktnutzung wichtigen Eigenschaften funktionale Korrektheit und Robustheit durch Tests uberpr ¨ uft ¨ werden konnen. ¨ Weitere Qualit¨atseigenschaften wie Laufzeit- und Speichereffizienz lassen sich durch statistische Tests zumindest in eingeschr¨ankter Form prufen. ¨ 5.1.1 Testbegriffe Abbildung 5.1 enth¨alt einige Definitionen des Begriffs Test“ aus der Litera” tur. In der Literatur sind unterschiedliche Definitionen fur ¨ den vielfach gebrauchten Begriff Test und die T¨atigkeit Testen zu finden (teilweise ins Deutsche ubersetzt): ¨ •
Testen ist der Prozess, ein Programm mit der Absicht auszufuhren, ¨ Fehler zu ” finden.“ [Mye00, S. 4]
•
Testen von Software ist die Ausfuhrung ¨ der Softwareimplementierung auf Testdaten und die Untersuchung der Ergebnisse und des operationellen Verhaltens, um zu prufen, ¨ dass die Software sich wie gefordert verh¨alt. [Som01, S. 420]
•
Die Anwendung von Test-, Analyse- und Verifikationsverfahren dient im we” ¨ sentlichen (sic) zur Uberpr ufung ¨ der Qualit¨atseigenschaften funktionale Korrektheit und Robustheit.“ [Lig90, S. 17]
•
Ein Test ist der Entwurf und die Implementierung einer speziellen Form eines Softwaresystems. Es pruft ¨ ein anderes Softwaresystem mit dem Ziel, Fehler zu finden. Tests werden entworfen, um das zu testende System zu analysieren und zu entscheiden, wie fehlerhaft es wahrscheinlich ist. Testentwurfe ¨ stellen Anforderungen an das automatisierte Testsystem, das die Tests automatisiert anwendet und evaluiert. Das Testsystem muss so entworfen werden, dass es mit den physischen Schnittstellen, der Struktur und der Laufzeitumgebung des zu testenden Systems zusammenarbeitet. Naturlich ¨ spielen manuelle Tests immer noch eine Rolle, aber Testen bedeutet haupts¨achlich die Entwicklung eines automatisierten Systems, das anwendungsspezifische Tests implementiert. [Bin99, S. 41]
•
Es gibt zwei Arten von Tests: (1) Unit-Tests und (2) Akzeptanztests. Entwickler schreiben Unit-Tests gemeinsam mit dem Code. Anwender schreiben Akzeptanztests nachdem die Anwendungsf¨alle definiert sind. [AM02, S. 6]
•
Unter Testen versteht man den Prozeß (sic) des P