Enterprise Architect 6.5

Sparx Systems
Enterprise Architect 6.5
im Überblick
©Copyright SparxSystems GmbH 2007
Enterprise Architect 7.0
MDG Integration, Visual Studio 2003 Visual Studio 2005
MDG Plugins Eclipse Doors Team Foundation Server
Sparks
www.sparxsystems.at
Inhalt
Einleitung ............................................................................................................................................. 4
Was ist Enterprise Architect? .............................................................................................................. 4
Was unterscheidet Architect von anderen UML Werkzeugen?............................................................ 4
Wie verbreitet ist Enterprise Architect heute? ..................................................................................... 5
Enterprise Architect – Funktionen im Überblick................................................................................. 5
Was ist neu in Enterprise Architect 6.5?.............................................................................................. 6
Einige Enterprise Architect Funktionen im Detail .............................................................................. 8
UML 2.1 Unterstützung .................................................................................................................. 8
Modell-Validierung ......................................................................................................................... 8
Codeumsetzung und Darstellung .................................................................................................... 8
Import von .jar files und .NET assemblies ................................................................................... 9
Vorlagengetriebene Codeerstellung ............................................................................................ 9
Angestoßene und automatische “live”-Codeerstellung............................................................. 10
Eingebauter Codeeditor mit Hervorhebungen und dynamischer Strukturanzeige.................... 10
Debugging, Compiling und Darstellung von Programmen........................................................... 10
Erstellen und Ausführen von Scripts.......................................................................................... 10
Debugging von .NET- und Java-ausführbarem Code mit der Debug Workbench .................... 10
Automatische Erzeugung von Sequenzdiagrammen ................................................................. 11
Eingebaute Unterstützung für jUnit und nUnit Tests.................................................................... 11
Integration des Unit-Testings in den Entwicklungszyklus ......................................................... 11
Performanz und Skalierbarkeit...................................................................................................... 11
Versionierung ................................................................................................................................ 11
Zusammenspiel und Integration mit anderen Werkzeugen........................................................... 12
Automatisiertes Interface .............................................................................................................. 12
Add-ins .......................................................................................................................................... 12
MDG Link .................................................................................................................................. 12
MDG Integration ....................................................................................................................... 12
Benutzer-Interface, Werkzeuge und Produktivitätsanreicherung ................................................. 13
“Quick Linking” Technik........................................................................................................... 13
Modellvorlagen .......................................................................................................................... 13
Direktes Editieren von Diagrammelementen............................................................................. 13
Weitere Diagramm-Funktionen ................................................................................................. 13
Nachvollziehbarkeit ...................................................................................................................... 13
Die hierarchische (Abhängigkeits-)Ansicht ............................................................................... 13
Die Matrix-Ansicht..................................................................................................................... 13
Nachvollziehbarkeit der Elementverwendung ........................................................................... 14
Diagrammerstellung mittels Elementeverkettung...................................................................... 14
Dokumentations- und Reporterstellung im Enterprise Architect .................................................. 14
Der Rich Text Format (RTF) Reporteditor ................................................................................ 14
HTML Reporterstellung ............................................................................................................. 14
Der eingebaute Dokumenteneditor und verlinkte Dokumente................................................... 15
Suchfunktion und Suchansicht ...................................................................................................... 15
Weitere Reports............................................................................................................................. 15
Entwicklung und Zusammenarbeit im Team ................................................................................ 15
Unterstützung große Modelle oder vieler gleichzeitiger Anwender .......................................... 15
XML Import/Export ...................................................................................................................... 16
Versionskontrolle .......................................................................................................................... 16
Sicherheit/Locking ........................................................................................................................ 16
Das Modell-Diskussionsforum...................................................................................................... 16
2
MDA (Model Driven Architecture) Unterstützung....................................................................... 16
Vorlagengesteuerte Transformationen ...................................................................................... 17
Reproduzierbare Transformationen........................................................................................... 17
Eingebaute Transformationen.................................................................................................... 17
Hinzufügen weiterer Transformationen ..................................................................................... 17
Datenbankmodellierung ................................................................................................................ 18
Verfügbares Datenbank-Modellierungsprofil............................................................................ 18
Unterstützung gängiger Datenbanksysteme .............................................................................. 18
DDL Erstellung (Eingangsdatei für den Schema-Prozessor) .................................................... 19
Import von Datenbankstrukturen aus ODBC-Verbindungen..................................................... 19
Unterstützung der Projektabwicklung ........................................................................................... 19
Baselines und Differenzermittlung............................................................................................. 19
Projektkennzahlenermittlung mittels “Use Case metrics” ........................................................ 20
Ressourcen ................................................................................................................................. 20
Testen ......................................................................................................................................... 20
Change Management ................................................................................................................. 20
Projektaufgaben ......................................................................................................................... 20
Wörterbuch ................................................................................................................................ 21
Import - Export Funktionalitäten................................................................................................... 21
Unterschiedliche XMI Formate ................................................................................................. 21
CSV ............................................................................................................................................ 21
UML-Erweiterungen in Enterprise Architect................................................................................ 21
UML Profile ............................................................................................................................... 21
UML Muster (Patterns).............................................................................................................. 21
MDG Technologie...................................................................................................................... 22
Spezielle Add-Ins........................................................................................................................ 22
Unterstützung von SOA (Service Oriented Architecture)............................................................. 22
XSD Funktionalität .................................................................................................................... 22
WSDL Funktionalität ................................................................................................................. 23
Modellierung von Geschäftsprozessen.......................................................................................... 23
Das BPMN Profil ....................................................................................................................... 23
Requirements Management - Anforderungsmanagement............................................................. 23
Prozessunterstützung ......................................................................................................................... 23
Über Sparx Systems ........................................................................................................................... 25
Firmen-Vision ............................................................................................................................... 25
Langfristige Ausrichtung auf unternehmensweite UML Werkzeuge ........................................... 25
Kontaktdaten ................................................................................................................................. 25
3
Einleitung
Dieses Dokument verschafft einen umfassenden Überblick über die Funktionalität und die
Leistungsfähigkeit von Sparx Systems’ Enterprise Architect (EA) 6.5. Jedem speziellen Merkmal
wird ein Abschnitt gewidmet - jeweils mit Erläuterung des Zwecks und des Nutzens der Funktion.
Was ist Enterprise Architect?
Enterprise Architect ist ein Computer Aided Software Engineering (CASE) Tool,
also ein Softwareentwicklungswerkzeug zum Entwurf und zur Herstellung von
Softwaresystemen, zur Geschäftsprozessmodellierung und zur Modellierung
beliebiger Prozesse oder Systeme.
EA stützt sich auf die letztgültige UML 2.1 Spezifikation (Unified Modelling
Language, siehe www.omg.org). UML definiert eine grafische Symbolsprache, um
einen bestimmten Bereich oder ein System zu beschreiben – während der
Planungsphase oder zur Dokumentation eines bestehenden Systems.
EA ist ein fortschrittliches Werkzeug, das alle Teile des Entwicklungszyklus abdeckt und eine
umfassende Nachvollziehbarkeit des Projekts vom ersten Entwurf bis zur Auslieferung und bis in
die Wartungsphase hinein einräumt. Auch die Testphase und das Änderungsmanagement werden
unterstützt.
Was unterscheidet Architect von anderen UML Werkzeugen?
•
Die umfassende Berücksichtigung von UML 2.1
•
Das eingebautes Anforderungsmanagement
•
Eine starke Projektmanagementunterstützung, einschließlich Ressourcenplanung, Metriken,
Testvorgabe und Testverfolgung
•
Eine Testunterstützung: Testfälle, jUnit und nUnit werden unterstützt
•
Flexible Dokumentationsfunktionen: HTML und Rich-Text (RTF) Reportgeneratoren
•
Die Codeerstellungsunterstützung für zahlreiche Programmiersprachen ‘out of the box’
•
Eine integrierte Debug-Einrichtung für ausführbare Java und .Net Projekte/Programme, mit
automatischer Erstellung eines Laufzeitmodells und eines Ablauf-Sequenzdiagramms aus
dem jeweiligen Debug-Protokoll
•
Eine umfangreiche Modellierungsumgebung mit der Möglichkeit, benutzerdefinierte Profile
und Technologien einzubinden
•
Die leichte Bedienbarkeit
•
Die Geschwindigkeit: EA arbeitet spektakulär schnell
•
Die Skalierbarkeit: EA kann problemlos extreme große Modelle verarbeiten und viele
gleichzeitig arbeitende Benutzer unterstützen
•
Die Kosten: Die Lizenzpreise von EA sind ausgelegt, um das ganze Team ausstatten zu
können. Interaktive Zusammenarbeit und eine Entwicklung im Team werden dadurch
Realität.
4
Wie verbreitet ist Enterprise Architect heute?
Mit 110.000 verkauften Lizenzen hat Enterprise Architect seine Popularität in vielen
Industriesparten bewiesen und wird von tausenden Firmen weltweit genutzt. Von großen,
bekannten, multinationalen Organisationen bis zu unabhängigen Kleinfirmen und Beratern ist
Enterprise Architect das UML-Modellierungswerkzeug der ersten Wahl für Entwickler,
Konsulenten und Analysten in über 60 Ländern geworden.
Die Sparx-Software wird zur Entwicklung verschiedenster Softwaresysteme in einem breiten
industriellen Spektrum verwendet: Luft-/Raumfahrt, Bankwesen, Internetentwicklung, Fertigung,
Finanzwesen, Medizin, Militär, Forschung, Lehre, Transport, Einzelhandel, Energieversorgung und
Elektrotechnik. Sie wird auch weltweit in vielen prominenten Schulen, Universitäten und
Schulungsunternehmen effektiv zur UML-Schulung und zur Business-Prozessmodellierung
eingesetzt. Die Einsatzbreite reicht von singulären Anwendern bis zu Großfirmen mit über 400
Nutzern , die an großen, verteilten Projekten arbeiten.
Enterprise Architect – Funktionen im Überblick
EA ermöglicht:
•
die Modellierung komplexer Software- und Hardwaresysteme in UML-gerechter
Darstellung
•
die Erstellung detaillierter und hochqualitativer Dokumentation in den Formaten RTF und
HTML
•
die Erzeugung und die Rückeinbindung (Reverse Engineering) von ActionScript, C, C++,
C#, Delphi, Java, PHP, Python, Visual Basic und VB.NET*
•
die Modellierung von Datenbanken und das automatische Erstellen von DDL scripts und die
rückläufige Erstellung von Datenbakschemata direkt über ODBC Verbindungen*
•
das Änderungsmanagement, das Erstellen von Wartungsanweisungen und Testfällen
•
die Modellierung von Abhängigkeiten zwischen Modellelementen
•
die Vorgabe von Objektklassifizierungen
•
die Modellierung der Systemdynamik und der Systemzustände
•
die Modellierung von Klassenhierarchien
•
die Modellierung der Ausführung, der Komponenten und der Implementationsdetails
•
die Sammlung von Projektaufgaben, von Vorfällen bei der Projektabwicklung und die
Erstellung eines Systemglossars
•
eine Zuordnung von Ressourcen zu Modellelementen und die Erfassung und
Gegenüberstellung von tatsächlichem und geplantem Aufwand
•
eine Ausgabe der Modelle in Formaten kompatibel zu XMI 1.0, XMI 1.1, XMI 1.2, XMI 2.0
und XMI 2.1 zum Export in andere XMI-kompatible Werkzeuge
•
eine Übernahme von Modellen in den Formaten XMI 1.0, XMI 1.1, XMI 1.2, XMI 2.0 und
XMI 2.1 von anderen Werkzeugen
•
eine Versionierung über XMI unter Benutzung von SCC, CVS oder Subversion**
•
die Benutzung von UML Profilen, um kundenspezifische Modellierungserweiterungen
bereitzustellen
•
komplette Diagramme als “UML Pattern” - also als Ikone - zu speichern und in andere
Projekte zu laden
5
•
die Analyse von Beziehungen zwischen Elementen in Tabellenform mittels der sogenannten
Beziehungs-Matrix
•
das Scripting, um mit Elementen automatisiert zu arbeiten - über ein eigenes, detailreiches
Automatisierungsinterface
•
den Anschluß an SQL Server, MySQL, Oracle9i, PostgreSQL, Adaptive Server Anywhere,
und Progress OpenEdge Datenbanken**
•
die ändernde Migration über verteilte Umgebungen mit JET-Replikation
•
die Benutzung von Steuerpaketen basierend auf XMI Import und Export
•
die automatisierte Ausführung von Management-Aufbereitungen .*
*
nur in der Professional und Corporate Ausgabe
**
nur in der Corporate Ausgabe
Was ist neu in Enterprise Architect 6.5?
Unterstützung von UML 2.1
Die Version 6.5 bietet eine umfassende Modellierungsunterstützung zu den letzten Erweiterungen
der UML-Spezifikation. Als erstes, alle 13 UML-2.0-Diagramme unterstützendes UML-Werkzeug
unterstreicht EA seine Führungsposition in der Unterstützung der letztgültigen Erweiterungen und
Verfeinerungen der UML 2.1 Spezifikation durch OMG, wie zum Beispiel die Untergliederung der
Assoziationsbeziehungen, Informationselemente, Generalisierungs-Sets und erweiterte UML
Profile.
XMI 2.1 Import & Export
EA erlaubt jetzt den Austausch von Modelldaten mittels des letzten Industriestandards sowohl in
UML 2.1 als auch UML 2.0 Format. Die Unterstützung von XMI 2.1 stärkt das Zusammenspiel von
EA mit Werkzeugen von Drittherstellern und Produkten anderer Hersteller und speichert jetzt mehr
Information in einem offenen und standardisierten Austauschformat.
Debugging, Profiling und Darstellung laufender Objekte
Die Erweiterungen des internen Debuggers und Profilers erlauben es dem EA sich an aktive Java
und .Net-Prozesse wie z.B. ASP.Net Web-Dienste anzudocken. Zusätzlich erlaubt der neue
Workbench-Modus eine Instanzierung von benutzergewählten Java und .Net-Klassen in einer
eigenen Laufzeitumgebung zu Test- und Überprüfungszecken. Zusammen mit der bestehenden
Funktion zum Sammeln von Laufzeitinformationen, ergibt dies eine hervorragende Möglichkeit des
Testens mit gleichzeitiger, automatischer Erstellung von Sequenzdiagrammen aus dem laufenden
Code.
Unterstützung des Microsoft Team Foundation Servers
EA unterstützt jetzt die Verwendung des Team Foundation Server (TFS) als vorgebenden
Versionierungsmechanismus. Zusätzlich bereichert dieVisual Studio Integration (MDG Integration
für Visual Studio 2005) die TFS Unterstützung durch die Zugangsmöglichkeit zu Arbeitsschrittdaten sowohl im EA als auch im MDG-Integrationsprodukt.
Erweiterter HTML Reportgenerator
EA unterstützt die automatische Web-Publikation von Modellen. Eine neue, strukturierte
6
Inhaltslistung gibt die Modellstruktur klar wieder und erleichtert das Modellverständnis wesentlich.
Mit dem verbesserten Aussehen und der Möglichkeit auch sehr große Modelle nun online leicht
durchforsten zu können, ist das neue Web-Publishing eine wesentliche Bereicherung der Version
6.5.
Pan & Zoom Ansicht
Die “Pan & Zoom” Funktion bietet eine Ansicht der Diagramme aus der Vogelperspektive. Da EA
ein komfortables Editieren sehr großer Diagramme erlaubt, ist die “Pan & Zoom” Funktion eine
wesentliche Erleichterung für die Navigation.
Erweiterung der Datenmodellierung
Die Version 6.5 bringt die Unterstützung Sybase ASE Datenmodellen und die entsprechende DDL
Erstellung, als auch eine Unterstützung der Modellierung von Views (SQL Server, Oracle, und
Sybase ASE).
‘C’ Sprachunterstützung
Sowohl die Professional als auch die Corporate Ausgabe des EA 6.5 unterstützen jetzt ANSI C. Mit
C als einer der meist gängigen Programmiersprachen, speziell im Embedded- und Echtzeitindustriebereich, hilft diese neue Erweiterung die ohnehin solide Positionierung des EA in diesem
Marksegment nochmals zu stärken.
Viele Verbesserungen der Grafik
EA 6.5 enthält auch viele Bereicherungen und Verfeinerungen der grafischen Darstellung der
Modellelemente, zudem wurde die ohnehin schon exzellente Bedienbarkeit bereichert als auch die
Fähigkeit auf einfachem Weg beeindruckend gut aussehende Diagramme zu gestalten.
Dies schließt die neuen Stil der Bezier-Linienform ein, neue Umriss-Skripte, verbesserte Zeichnung
der Stereotype, neue Legendenelemente, verbesserte Rücknahmeunterstützung, eine neue
Handhabung der Verknüpfungen, Tastenkürzel, die Möglichkeit kundenseitiger Einfügungen von
Zeichnungselementen und andere, stark zeitsparende Bedienungsverkürzungen.
Verbesserte Unterstützung für Kundenmodule und Technologien
Es wurde eine hohe Anzahl von Erweiterungen in EA 6.5 implementiert um Moduleinfügungen und
Anwendertechnologie-Einbindung zu ermöglichen - zur fortschreitenden Verfeinerung der
Darstellung und Handhabung von Modellelementen.
Die einfügbare, von Sparx Systems angebotene SysML-Technologie ist ein gutes Beispiel wie eine
anwenderseitig erstellte Technologie die Benutzerschnittstelle übernehmen kann und
benutzerdefinierte Aktionen oder Prüfungsvorgänge – auch abweichend von UML2.1 - ausführen
kann.
Verbesserungen bei Sequenzdiagrammen
Sequenzdiagramme sind die meistverwendete Diagrammform um zeitlichen Ablauf und zeitliches
Verhalten zu modellieren. Die Vorgängerversionen des Enterprise Architect waren berühmt für ihre
hervorragende Bedienbarkeit dieses Diagrammtyps; Version 6.5 wurde in dieser Hinsicht nochmals
deutlich verbessert, sie macht es noch einfacher, rasch detaillierte und korrekte Diagramme zu
erstellen. Komplizierte Diagramme zusammenzustellen ist ganz einfach geworden, mit
automatischen Berechnungen, Unterstützung für eingefügte Untergliederungen, Unterbrechungen in
Lebenslinien, unbegrenzter Eingaberücknahme und einer Schnell-Verbinde-Technik.
Ferner ….
Viele weitere Änderungen stecken in Version 6.5, der intuitivsten, leistungsfähigsten und
potentesten Ausgabe des Enterprise Architect.
7
Einige Enterprise Architect Funktionen im Detail
Jeder der nachfolgenden Abschnitte behandelt ein Teilaspekt der Fähigkeiten des EA’s und zeigt
den Zweck und Nutzen der Funktion auf.
UML 2.1 Unterstützung
Enterprise Architect unterstützt alle in UML 2.1 definierten Modelle und Diagrammarten. Sie
können Geschäftsprozesse, Webseiten, Benutzerschnittstellen, Netzwerke, Hardwarekonfigurationen, Meldungen und viele andere Aspekte Ihrer Entwicklung modellieren. Sie können
den Aufwand Ihrer Projektarbeit in Stunden planen. Sie können Anforderungen, Ressourcen,
Testpläne, Störungen und Änderungsanträge erfassen und verfolgen. Vom ersten Konzept bis zur
Produktivsetzung mit Wartung und Produktionsunterstützung, Enterprise Architect hat alle
Funktionalitäten, die Sie für Ihren Entwurf und das Management Ihrer Umsetzung und
Implementation brauchen.
In Kurzfassung, EA
•
war das erste UML-Werkzeug, das eine Abdeckung der UML 2-Definition bereitstellte - im
April 2004
•
fortlaufend an die UML 2 Erweiterungen angepasst wurde
•
alle 13 Diagrammarten von UML 2 unterstützt
Leser, die mit UML nicht vertraut sind, finden eine Kurzeinführung unter folgender Internetadresse:
http://www.sparxsystems.com/UML_Tutorial.htm
Modell-Validierung
Die Modell-Validierungsfunktion überprüft UML Modelle auf die Einhaltung definierter UML
Regeln, als auch alle im Modell festgelegten Beschränkungen unter Verwendung der “Object
Constraint Language“ (OCL). Sie können die eingebaute Modell-Validierung auf ein einzelnes
UML Element, ein Diagramm oder ein ganzes Package anwenden, wie nachfolgend beschrieben.
Validierung eines UML•
Elements: Prüft das Element und seine Kinder, seine Merkmale (Attribute) und
Beziehungen (Verbindungen und Verlinkungen)
•
Diagramms: Prüft das Diagramm selbst (auf Korrektheit) als auch alle Elemente und
Verbindungen darin
•
Paket: Überprüft das Paket, Unterpakete, alle Elemente und Verbindungen darin.
Codeumsetzung und Codedarstellung
Die Codeumsetzung umfasst automatische Codeerstellung, Code-Rückumsetzung aus Quellencode
und die Synchronisation zwischen Quellencode und Modelldarstellung. Dies ist allerdings nur in
der Professional- und in der Corporate Ausgabe des Enterprise Architects enthalten. Besitzer der
Desktop-Version können ihre Version auf der Upgrade-Seite
http://www.sparxsystems.com/registered/reg_ea_upgrade.html hochrüsten.
Der Enterprise Architect ermöglicht Ihnen die Quellencodeerstellung unmittelbar aus UMLModellen in mehr als zehn gebräuchlichen Programmiersprachen, einschließlich:
8
•
ActionScript (Macromedia Flash Entwicklungssprache)
•
C
•
C# (sowohl .NET 1.1 als auch .NET 2.0)
•
C++ (Standard und .NET bedingte C++ Erweiterungen)
•
Delphi
•
Java (einschließlich Java 1.5, Signalisierung und Gattungen)
•
PHP
•
Python
•
Visual Basic
•
Visual Basic .NET
Die Quellencodeerstellung schließt Klassendefinitionen, Variablen und Funktionsrümpfe für jedes
Attribut und jede Methhode eine UML-Klasse mit ein. Zusätzlich erlaubt der EA XSD und WSDL
XML-Quellencode zu editieren und zu erzeugen, (siehe auch Abschnitt SOA in diesem Dokument).
Die Codeerstellung wird auch als Forward Engineering bezeichnet. Der Import von Quellencode
in eine Modelldarstellung wird auch Reverse Engineering genannt. Alle für Quellcodeerzeugung
eingebaute Sprachen sind auch für Reverse Engineering im EA verfügbar.
Von Synchronisation spricht man, wenn Änderungen im Modell in den Quellencode exportiert
werden oder wenn Änderungen im Quellencode in das Modell übernommen werden. Dies
ermöglicht Ihnen, Ihr Modell und Ihren Quellencode abgeglichen auf letztem Stand zu halten, wenn
sich das Projekt weiterentwickelt.
Als Round Trip Engineering bezeichnet man die Kombination von Reverse und Forward
Generation von Code als auch die Synchronisation, ein typischer Vorgang in Softwareprojekten.
Import von .jar files und .NET assemblies
Der Enterprise Architect (Professional und Corporate Ausgaben) gestatten das Reverse-Engineering
folgender binärer Module:
•
Java Archive (.jar)
•
.Net PE Dateien (.exe, .dll); native Windows DLL und Exe Dateien werden nicht
unterstützt, nur PE Dateien, die .Net Assembly Daten enthalten.
•
Intermediate Language Dateien (.il).
Vorlagengetriebene Codeerstellung
Sie benutzen grundsätzlich das Code Template Framework (CTF) - die EA-Vorlagenverwaltung
- beim Forward Engineering eines UML-Modells. Vorlagen bestimmen dabei eine durch Sie
adaptierbare Umsetzung von UML Elementen in die verschieden Teile einer Programmiersprache.
Das Code Template Framework ermöglicht Ihnen:
•
Quellencodeerstellung aus UML Modellen
•
Anpassung der Art und Weise, wie der EA den Quellencode erstellt
•
Das Forward Engineering von Sprachen, die nicht im originalen Lieferumfang des EA’s
enthalten sind.
Das Code Template Framework besteht aus:
9
•
Standard-Codevorlagen, die bereits in EA für die unterstützten Sprachen eingebaut sind
•
Einem Code-Editor zum Erstellen und Warten benutzerdefinierter
Codeumsetzungsvorlagen.
Angestoßene und automatische “live”-Codeerstellung
Der Enterprise Architect stellt eine “Live Code Generation” Funktion zur Verfügung, die
automatisch ihren Quellencode auf letzten Stand bringt, wenn Sie Änderungen in ihrem Modell
vornehmen. Zum Beispiel, wenn Sie neue Methoden oder Attribute in ihrem Klassenmodell anlegen
– diese werden dann automatisch in ihren Quellencode eingetragen.
Eingebauter Codeeditor mit Hervorhebungen und dynamsicher Strukturanzeige
Sie können den eingebauten Codeeditor zur Anzeige und zum Ändern von Quellencode verwenden.
Wenn Sie ein Element mit einer zugewiesenen Quellencodedatei im Modell auswählen, wird der
Quellencode in einem Editor mit Grammatik-Hervorhebung und einer navigierbaren Codestrukturanzeige angeboten. Die Quellencodeanzeige bietet auch eine Werkzeugleiste für schnelle
Codeerstellung und Synchronisation mit dem Modell.
Debugging, Compiling und Darstellung von Programmen
Die Professional und die Corporate Ausgabe des Enterprise Architects erlauben das Erstellen,
Testen, Debuggen und Ausführen von Code innerhalb der Entwicklungsumgebung des Enterprise
Architects.
Diese Funktion stattet Entwickler mit einem Werkzeug aus, UML-Entwicklung mit Codeerstellung
und –Umsetzung zu vereinen. Mit der Möglichkeit, nUnit- und jUnit-Testklassen aus
Quellencodeklassen mittels MDA-Transformation zu erzeugen und der Möglichkeit, den
Testprozess direkt in die EA-Entwicklungsumgebung durchzuführen, lässt sich nun UMLModellierung mit dem gesamten Codeerstellungsprozess vereinen.
Zusätzlich zu den Funktionalitäten Erstellung und Test bietet der EA Debugging-Möglichkeiten für
.NET und Java. Die im EA enthaltenen Debugger wurden speziell dafür entwickelt, für Entwickler
und Tester Stack-Inhalte beim Durchlauf durch den ausführbaren Code zu sammeln. Das
gesammelte Stack-Log kann dann dazu in EA benutzt werden, um Sequenz-Diagramme zu
erstellen, d.h. die aktuell aufgetretenen Programmaufrufe in Diagrammform zu visualisieren. Dies
ist eine äußerst zeitsparende und effiziente Technik, mit komplexen Projekten umzugehen, weil hier
verlässlich und leicht lesbar dokumentiert werden kann, dass sich der erstellte Code genau so
verhält, wie vom Architekten und Entwickler geplant.
Erstellen und Ausführen von Scripts
Es ist möglich durch Anweisungen am Ende jedes Packages vorzugeben, wie Code umgesetzt und
ausgeführt wird. Jedes Package kann mehrfach Konfigurationen enthalten, sodass es einfach ist,
Varianten zu handhaben. Der EA kann auch die Compiler-Ergebnisse des Compilers Ihrer Wahl
parsen und den Quellen-Editor beim Auffinden von Compilerfehlern öffnen.
Debugging von .NET- und Java-ausführbarem Code mit der Debug Workbench
Der Enterprise Architect erlaubt das Debuggen von Code durch die Verwendung von auf die
Quellencodesprache abgestimmter Debug-Interfaces. Sie konfigurieren das Debuggen durch
Erstellung eines Debug-Scripts für die zu testenden Packages. Der Hauptzweck dieser Lösung liegt
darin, einen Durchlauf durch das Programm zu ermöglichen und dabei den Stack zu tracen, um
direkt ein Sequenzdiagramm automatisch erstellen zu können. Das ist eine exzellente Art, zu
verstehen und zu dokumentieren, was ein Programm während der Ausführung tatsächlich
10
durchführt.
Systemanforderungen:
•
Enterprise Architect Version 6.1 oder höher – unterstützt das Debuggen von .Net 1.n und
.Net 2.0
•
Java 2 Platform Standard Edition (J2SE) Version 5.0
•
Java 2 Enterprise Edition (J2EE) JDK 1.4 oder höher.
Automatische Erzeugung von Sequenzdiagrammen
Es ist einfach, detaillierte und auch umfangreiche Sequenzdiagramme aus dem aufgezeichneten
Debug-Durchgang automatisch zu erzeugen. Der EA erlaubt Ihnen, entweder durch das Programm
manuell durchzusteppen oder den Debugger automatisch durchlaufen zu lassen.
Der Enterprise Architect erzeugt das Sequenzdiagramm automatisch aus dem Stack-Trace-Log einschließlich der Zusammenfassung von Schleifendurchgängen zur Verbesserung der Lesbarkeit.
Eingebaute Unterstützung für jUnit und nUnit Tests
Der Enterprise Architect bietet zweifache Unterstützung für das Unit-Testen mit jUnit und nUnit.
Er hilft durch die jUnit- und nUnit-Transformation Testklassen und –methoden zu erstellen. Wenn
das Ergebnis dieser Transformation vorliegt, haben Sie ein “Testgerüst”, das mit Testlogik gefüllt
werden kann.
Der sich ergebende Code kann über die Build- und Run-Kommandos compiliert und ausgeführt
werden. Alternativ können Sie ein Testscript mit dem originalen Package bereitstellen, das ihr
Unit-Testing-Programm ausführt. Der EA kann die Ergebnisse der Kommandozeilenausführung
sammeln und so aufzeigen, ob Fehler auftreten – das alles, ohne den EA zu verlassen.
Integration des Unit-Testings in den Entwicklungszyklus
Ein Grundprinzip der Unit-Tests besteht darin, die Tests vorab zu schreiben. Der Enterprise
Architect hilft, dieses Prinzip einzuhalten. Beim Hinzufügen einer neuen Methode zu einer Klasse
führt man die Transformation der Klasse aus. Der EA erzeugt die korrespondierende Methode und
Sie können die Details festlegen und einfügen. Dies kann einfach erfolgen, noch bevor der zu
testende Code erstellt wird.
Performanz und Skalierbarkeit
Der EA ist schnell! Enterprise Architect Benutzer stimmen darin überein – der EA lädt in einem
Bruchteil der Zeit vieler am Markt befindlichen anderen Werkzeuge und er verarbeitet auch
extreme große Modelle ohne nennenswerte Performanzeinbußen.
Versionierung
Der Enterprise Architect unterstützt die Versionierung von Packages und darin enthaltener SubPackages in einem zentralen Repository. Dieses Repository wird von Drittanbietern bereitgestellt
und ist selbst nicht Bestandteil von EA, spielt aber voll mit ihm zusammen.
Die Versionierungssteuerung des EA bietet zwei Schlüsselmerkmale:
•
Unterstützung der gemeinsamen Nutzung von Packages zwischen einzelnen Benutzern
•
Speicherung des Entwicklungsverlaufs, die einzelnen Versionen werden gespeichert, auch
ältere können abgerufen werden.
11
Der EA unterstützt folgende Versionierungssysteme:
•
Alle Versionierungssysteme kompatibel mit dem “Microsoft Common Source Code Control
Standard”, ab der Version 1.1. (Zum Beispiel Visual Source Safe oder Clear Case)
•
Microsoft Team Foundation Server (TFS)
•
Subversion, verfügbar unter http://subversion.tigris.org
•
CVS, verfügbar http://www.wincvs.org
Zusammenspiel und Integration mit anderen Werkzeugen
Der Enterprise Architect bietet mehrere Mechanismen um ihre Modelle in Werkzeuge anderer
Hersteller überzuführen, einschließlich eines programmierbaren APIs, also ein bereits enthaltenes
Framework, einer Generator-Lösung von Sparx.
Automatisiertes Interface
Das “Automation Interface” erlaubt Ihnen den Zugriff auf die EA-internen Modelle. Als Beispiel
seien einige Aufgaben genannt, die durch dieses Interface gelöst werden können:
•
Ausführung rekursiver Aufgaben, wie z.B. die Veränderung der Versionsnummer aller in
einem Modell enthaltenen Elemente
•
Automatische Codeerzeugung aus einem State-Machine-Diagramm
•
Erzeugung spezieller Reports
•
Ad-Hoc-Abfragen.
Alle Entwicklungsumgebungen, die ActiveX Com Clients erzeugen können, können mit dem
Enterprise Architect Automation Interface arbeiten.
Add-ins
Add-ins erlauben Ihnen weitere Funktionalität dem Enterprise Architect hinzuzufügen. Das
Enterprise Architect Add-in Framework baut auf den Funktionen des Automation Interface auf und
erlaubt so, das Benutzer-Interface des EA zu erweitern. Add-ins bieten einige wesentliche Vorteile
gegenüber abgesetzten Erweiterungslösungen - einschließlich der Möglichkeit, erweiterte EAMenüs zu definieren und der Möglichkeit der Übernahme von Ereignissen aus der EABedienumgebung, wie Klicks in Menüs und Auswahlen durch den Benutzer.
MDG Link
Sparx hat eine ganze Anzahl an MDG-Produkten entwickelt um ein direktes Zusammenspiel mit
anderen Werkzeugen zu ermöglichen. MDG Link Produkte zeigen beispielhaft den Gebrauch des
eingebauten „Add-in Frameworks“ um die Funktionalität des Enterprise Architects wesentlich zu
erweitern. Der MDG Link für Visual Studio und der MDG Link für Eclipse ermöglichen dem
Enterprise Architect mit dem Microsoft® Visual Studio® 2003 und Eclipse IDE's direkt zu
interagieren.
MDG Integration
MDG Integration für Visual Studio 2005 vereint den Enterprise Architect mit der Microsoft® Visual
Studio® 2005 Entwicklungsumgebung. Dieses Produkt ermöglicht Anwendern, das UML-Modell
innerhalb von Visual Studio einzusehen, zu editieren und stellt auch viele der Hauptfunktionen des
Enterprise Architects direkt in der Entwicklungsumgebung zur Verfügung, einschließlich der Rich
Text und Web-Dokumentenerstellung, der MDA Transformationen, des Baseline Managements und
12
der XML-basierten Techniken.
Benutzer-Interface, Werkzeuge und Produktivitätsanreicherung
“Quick Linking” Technik
Der “Quick Linker” stellt einen raschen Mechanismus bereit um neue Elemente und Verbindungen
in einem Diagramm einzufügen. Er stellt kontextabhängige Menüs bereit, die es erleichtern,
grammatikalisch korrekte Modelle zu zeichnen – das spart dem Anwender wesentliche Zeit und
erhöht die Produktivität deutlich.
Modellvorlagen
Der Enterprise Architect enthält bereits eine große Anzahl an vorgefertigten Modellen, die zur
Erstellung neuer Projekte und Modelle verwendet werden können. Jede Vorlage enthält hilfreiche
Anmerkungen, Referenzen und Ausgangselemente; dies ergibt zusammen genommen eine
Plattform von der aus Sie ihr Modell einfach gestalten können.
Direktes Editieren von Diagrammelementen
Der Enterprise Architect erlaubt ein rasches Editieren von Elementeigenschaften direkt aus dem
Diagramm. Durch Nutzung der Direkteingabe-Kommandos können Sie rasch und einfach
Elementeigenschaften wie Attribute, Methoden und Parameter eingeben, ohne das Diagramm
verlassen zu müssen.
Weitere Diagramm-Funktionen
•
Sie können Diagramme in einer großen Anzahl verschiedener Formate exportieren (.bmp,
.jpg, .png, .gif, .emf and .wmf)
•
Swimlanes erlauben die logische Aufteilung von Diagrammen
•
Der wartbare Werkzeugkasten erlaubt drag-and-drop-Plazierung von benutzerdefinerten
Profilelementen
•
Das Pan & Zoom Fenster gestattet die einfache Navigation in komplexen Diagrammen
•
Diagramme können gegen unabsichtliche Änderungen gesperrt werden.
Nachvollziehbarkeit
Die hierarchische (Abhängigkeits-)Ansicht
Das “Hierarchy”-Fenster zeigt die Abhängigkeiten des gegenwärtig selektierten Elements zu
anderen Elementen. Diese Information wird von Tochter-Beziehungen und/oder anderen
Beziehungen zu anderen Elementen abgeleitet. Die im “Hierarchy”-Fenster angezeigten
Beziehungen umfassen auch Aggregation, Vererbung und Abhängigkeit, aber auch
Realisierungsbeziehungen. Filter-Tasten erlauben die Eingrenzung auf gewünschte
Beziehungsarten. Dies gibt ein umfassendes Bild auf die Vernetzung, weil alle Beziehung
dargestellt werden, auch jene, die aus dem gegenwärtig betrachteten Diagramm hinausführen und
den ganzen Modellumfang betreffen können.
Die Matrix-Ansicht
Die Beziehungs-Matrix erlaubt die Einsicht in das Beziehungsgeflecht in Tabellenform.
Darüberhinaus können hier auch direkt Beziehungen eingetragen, modifiziert oder gelöscht werden
13
– mit einem einfachen Mausklick.
Nachvollziehbarkeit der Elementverwendung
Der Enterprise Architect macht es her einfach, die Verwendung der Elemente in verschiedenen
Diagrammen nachzuvollziehen. Die Anzeige “Elementverwendung” listet alle Einträge eines
Elements in verschiedenen Diagrammen auf, mit einem einfachen Mausklick kann an die richtige
Stelle des gewünschten Diagramms gesprungen werden.
Diagrammerstellung mittels Elementeverkettung
Der Enterprise Architect kann Diagramme automatisch ausgehend von einem gewählten Element
aus erweitern – durch Vorgabe der Verkettungsart der Verkettungsrichtung können „logisch
benachbarte“ Elemente selektiv und automatisch in das Diagramm eingefügt werden. Diese ‘Insert
Related Element’-Funktion ist ein rasches und mächtiges Werkzeug zur Erzeugung von
Übersichtsdiagrammen aus reverse engineertem Quellencode oder reverse ermittelten
Datenbankstrukturen.
Dokumentations- und Reporterstellung im Enterprise Architect
Die Dokumentationserstellung trägt wesentlich zur Wertschöpfung der Verwendung des Enterprise
Architecs bei. Der EA erzeugt hochqualitative Dokumentation entweder in rtf- oder HTML-Format.
Sie können die rtf-Formatausgabe mittels rtf-Vorlagen selbst gestalten. Mit MS Word® können Sie
die Ausgabe weiter verfeinern – durch das Zusammenfügen und Vernetzen mit verlinkten
Dokumenten.
Es gibt viele Möglichkeiten, die EA-Ausgabe vorzuwählen und einzugrenzen. Sie können:
•
Ein Package und/oder seine Sub-Packages durch Auswahl des Packages und nachfolgender
Anwahl der Dokumenatationssteuerung eingrenzen
•
Kennzeichnung der eingeschlossenen Packages zum Ausschluß von der Dokumentation,
falls die Unterpackages rekursiv dokumentiert werden sollen
•
Verlinken eines Packages zu einem RTF-Template zur Vereinfachung der Erzeugung
konsistenter Dokumententypen (wie z.B. Anwendungsfälle).
Sie können einzelne Packages auswählen, gruppieren und zusammenbinden in beliebiger Art und
Weise, auch unabhängig von der Sichtweise im Projekt durch die Erstellung ‚virtueller‘
Dokumente.
Der Rich Text Format (rtf) Reporteditor
Der rtf-Textvorlagen-Editor erlaubt die Erstellung und das Editieren von anwenderspezifischen
Vorlagen zur Erstellung beliebiger rtf-Dokumentationen. Der Vorlageneditor erlaubt die Anwahl
beliebiger Modellelemente und die Auswahl der Feldinhalte des Elements, die in die
Dokumentation einzubinden sind.
Formatierungen können im Vorlageneditor verfügt werden ebenso können Tabellen und Kopf- und
Fußzeilen ergänzt werden.
HTML Reporterstellung
Der Enterprise Architect erlaubt Ihnen das ganze Modell oder einen einzelnen Zweig als HTMLStruktur zu exportieren. Der HTML-Report ist eine einfach zu benutzende und umfassende
Darstellung des Modell-Baums – in Übereinstimmung mit der Gliederung im Projekt-Browser.
Zusätzlich erleichtert die automatisch eingefügte Verlinkung der Elemente das Auffinden der
Inhalte wesentlich. Die HTML-Erstellung benutzt eine durch den Benutzer auch veränderbare
14
HTML-Vorlage, derart können leicht Webseiten erstellt werden, die Ihren Firmenstandards
entsprechen.
Der eingebaute Dokumenteneditor und verlinkte Dokumente
Der Enterprise Architect ermöglicht die Verlinkung von Richt-Text-Dokumenten von jedem
einzelnen Modellelement aus. Verlinkte Dokumente werden basierend auf den anpassbaren
Vorlagen erstellt und werden automatisch in Web- und Word-basierenden Reports eingefügt.
Suchfunktion und Suchansicht
Sie können nach beliebigen Zeichenfolgen oder Worten durch das ganze Projekt mit der flexiblen
Suchfunktion des Enterprise Architects suchen. Der zusätzliche, ausführliche Suchmodus erlaubt
die Vorgabe spezieller Suchkriterien. Suchergebnisse können mit dem Richt-Text-Reportgenerator
gedruckt oder in eine Datei geschrieben werden.
Weitere Reports
Der Enterprise Architect enthält bereits eine Vielzahl weiterer, nützlicher Reports:
•
Ressourcen- und Planungs-Details
•
Projektvorfälle
•
Projektwörterbuch
•
Projektgrößen-Statistik
•
Abhängigkeits- und Implementations-Details
•
Test-Details.
Entwicklung und Zusammenarbeit im Team
Der EA bietet einen ganzen Satz an Funktionalitäten an, die entworfen wurden, um Projekte
gemeinsam in Teamarbeit und in verteilten Entwicklungsumgebungen abzuwickeln. Projekte
können gemeinsam über Netzwerk, mit Modell-Repositories, Replikation, XMI Import/Export, mit
Versionierungssystemen, Package-Versionierung und Sicherheits-/Lockingmechanismen betrieben
werden.
Arbeiten über Netzwerk kann mit EAP (dateibasiert) oder mittels eines Datenbankservers erfolgen.
Unterstützung große Modelle oder vieler gleichzeitiger Anwender
Die Corporate Ausgabe des EAs erlaubt die Datenbankverwendung zur Modellspeicherung, die in
diesem Fall vorzuziehende Variante. Der Enterprise Architect unterstützt folgende
Datenbanksysteme (DBMS):
•
MS SQL Server
•
MySQL
•
Oracle
•
PostgreSQL
•
Progress OpenEdge
•
MSDE
•
Adaptive Server Anywhere.
15
XML Import/Export
Die XMI Import/Export Funktion kann benutzt werden, um einzelne Modellpackages an
verschieden Entwickler zu verteilen und sie untereinander auszutauschen. XMI erlaubt den Export
von Packages in XML-Dateien, die dann wieder in ein beliebiges Modell importiert werden können.
Die Package-Versionierung kann benutzt werden, um einzelne Packages zum Einchecken in
Versionierungssysteme vorzubereiten – unter Verwendung der XMI-Formatierung. Dies ermöglicht
die Versionierungsverwaltung in einem Versionierungssystem eines Drittanbieters, das dann den
Zugang und die Zugangsrechte zu den einzelnen Versionen verwaltet.
Versionskontrolle
Der Enterprise Architect unterstützt die Versionierung von Packages und ihrer Sub-Packages in
einem zentralen Speicher. Diese Abspeicherung wird von einer Drittanbieter-Lösung verwaltet, die
auch die Zugangsrechteverwaltung abdeckt. EA-unterstützte Versionierungssysteme sind CVS,
Subversion, Microsoft Team Foundation Server (TFS) und SCC-kompatible Systme
(einschließlichVisual Source Safe und Clear Case).
Sicherheit/Locking
Die Zugriffssteuerung des EAs kann benutzt werden um den Zugang zu ändernden Funktionen im
Modell zu begrenzen. Elemente können pro Anwender oder pro Anwendergruppe gesperrt werden;
die abgestufte Sperrmöglichkeit wird durch die Verwendung zu vergebender Benutzer/Passwortkombinationen zum Einstieg ins Modell sichergestellt. Die Sicherheits-/Zugangsfunktion ist nicht
primär zur Abwendung unautorisierten Zugangs geschaffen worden; vielmehr dient sie zur
Unterstützung der gleichzeitigen Arbeit am Projekt im Projektteam. Gleichzeitiges Editieren am
selben Element durch mehrere Benutzer mit dem Risiko von Konflikten und/oder Datenverlust soll
verhindert werden.
Die Locking-/Sicherheits-Funktion ist nur in der Enterprise Architect Corporate Ausgabe verfügbar.
Die Funktion ermöglicht zwei Vorgehensweisen: Standardvorgehen und rigoroses Vorgehen. Im
Standard-Sicherheits-Vorgehen sind alle Elemente unversperrt und bei Bedarf kann der Anwender
abhängig von seinen funktionalen Rechten Elemente oder Diagramme inklusive aller enthaltenen
Elemente oder Packages inklusive aller enthaltenen Elemente und Diagramme sperren. Das rigorose
Vorgehen sieht vor, dass im Modell alles gegen Eingabe gesperrt ist bis es explizit “ausgecheckt”
wird - durch eine Verwendungssperre für den Anwendersperre. Die für durch den Anwender
gesperrten Teile können jederzeit dem Anwender als Liste angezeigt werden. Ebenso erhält ein
anderer Anwender im Kollisionsfall – er möchte für sich etwas sperren - die volle Information, wer
der Inhaber der kollidierenden Sperre ist.
Das Modell-Diskussionsforum
Das Modell-Diskussionsforum erlaubt den Anwendern den Entwicklungsprozess und den
Fortschritt eines Projektes zu diskutieren. Teammitglieder können Nachrichten lesen und
Nachrichten einfügen – und können Nachrichten direkt mit Modellelementen verlinken. Bei Teams
mit verteilter Entwicklung können die Anwender das EA-Modell mit einem externen Diskussionsforum auf einem Remote-Server verbinden.
MDA (Model Driven Architecture) Unterstützung
Der Enterprise Architect hat die Möglichkeit zur Ausführung von MDA-Transformationen. Er
unterstützt eine voll konfigurierbare Methode, Modellelemente oder Modellfragmente von einer
Domäne in eine andere zu konvertieren. Das betrifft typischerweise die Umwandlung eines
plattformunabhängigen Modells (PIM) in ein plattformspezifisches (PSM). Ein einzelnes Element
16
eines PIM kann so der Ausgangspunkt für mehrere Elemente in einzelnen PSMs in mehreren
Domänen sein.
Transformationen sind ein deutlicher Produktivitätsgewinn und reduzieren den Aufwand, manuell
Stammklassen und Elemente einer einzelnen Implementationsdomäne aufzusetzen; zum Beispiel
können Datenbanktabellen automatisch aus persistenten PIM Klassen abgeleitet werden. Der EA
enthält bereits einige eingebaute Transformationen, wie PIM zu Datenmodell, PIM zu C#, PIM zu
Java und PIM zu XSD.
Vorlagengesteuerte Transformationen
Sie können Transformationen mit der einfachen Codeerstellungssprache definieren, die im EA
schon seit einigen Jahren verwendet wird. Der Vorgang braucht nicht mehr als die Erstellung einer
Vorlage um eine einfache Zwischen-Quell-Datei zu erzeugen. Der EA liest die Quellendatei und
schließt sie im neuen PSM mit ein. Alle Vorlagen sind editierbar, daher können Sie alle
mitgelieferten Transformationen an ihre Bedürfnisse anpassen.
Reproduzierbare Transformationen
Die mit dem EA zur Verfügung gestellten Transformationen stellen die Reproduzierbarkeit sicher,
die für verlässliche Softwareentwicklung erforderlich ist. Sie können sicherstellen, dass alle
Komponenten ihres Systems konsistent bleiben. Der EA ermöglicht auch komplexere Prozeduren,
indem Sie auf automatisch generierten Code weitere Transformationsschritte anwenden.
Eingebaute Transformationen
Der Enterprise Architect wird mit einigen eingebauten Transformationen ausgeliefert. Diese
Transformationen sind ausgelegt, um möglichst vielen Anwendern nützlich zu sein, um als Basis
für ihre spezifischen Anpassungen und andererseits als gute Beispiele der Transformationserstellung zu dienen.
Folgende Transformationen sind im EA enthalten:
•
C#
•
DDL
•
EJB Entity
•
EJB Session
•
Java
•
JUnit
•
NUnit
•
WSDL
•
XSD.
Hinzufügen weiterer Transformationen
Es ist einfach im EA den von Sparx beigestellten weitere Transformationen hinzuzufügen und sie
gemeinsam zu verwenden. Das bedeutet, dass Sie nicht auf die bereits mitgelieferten
Transformationen beschränkt sind.
17
Datenbankmodellierung
Verfügbares Datenbank-Modellierungsprofil
Datenbankmodellierung und Datenbankdesign werden nicht ausdrücklich durch die UML
Spezifikation bedeckt, aber sie können im Enterprise Architect mit dem eingebauten UMLDatenmodellierungsprofil ausgeführt werden. Dieses Profil bietet einfach verwendbare und leicht
verständliche Erweiterungen des UML-Konzepts, einer Abbildung von Datenbankstrukturen mit
ihren Tabellen und Beziehungen auf Klassen und Assoziationen. Diese Erweiterung erlaubt Ihnen
auch, Datenbankschlüssel, Trigger, Begrenzungen, RI und andere Eigenschaften relationaler
Datenbanken abzubilden.
Beim Datenbankentwurf werden folgende typischen Vorgänge auftreten:
•
Erstellen eines Datenmodell-Diagramms
•
Anlegen einer Tabelle
•
Eigenschaften einer Tabelle festlegen
•
Spalten anlegen
•
Primäre Schlüssel anlegen
•
Fremdschlüssel anlegen
•
Anlegen von stored procedures
•
Anlegen von Indizierungen und von Triggern
•
Erstellen einer DLL für eien Tabelle
•
Erstellen der DLL für ein ganzes Package
•
Datentypumwandlungen in einer Tabelle
•
Datentypumwandlungen für ein ganzes Package
•
Anpassen der Datentypen für eine Datenbank
•
Importieren eines Datenbankschemas aus einer ODBC-Datenquelle
•
Anlegen von Views (SQL Server, Oracle und Adaptive Server Enterprise).
Unterstützung gängiger Datenbanksysteme
Der EA unterstützt die Modellierung mit Schemaerstellung zu folgenden Datenbanken:
•
DB2
•
InterBase
•
MS Access
•
MySQL
•
Oracle
•
PostgreSQL
•
MS SQL Server
•
Sybase Adaptive Server Anywhere
•
Sybase Adaptive Server Enterprise
•
Firebird.
18
DDL Erstellung (Eingangsdatei für den Schema-Prozessor)
Typische Datenbankeigenschaften, die mittels eines DDL Skripts erzeugt werden können,
umfassen:
•
Tabellen
•
Primäre Schlüssel und Fremdschlüssel
•
Indizierung und Begrenzungen
•
Trigger
•
Stored procedures (SQL Server, Oracle und Adaptive Server Enterprise)
•
Drop-Anweisungen
•
Kommentare für Tabellen und Spalten
Import von Datenbankstrukturen aus ODBC-Verbindungen
Typische Beschreibungen von Datenbankeigenschaften, die über eine ODBC-Verbindung
importiert werden können, umfassen:
•
Tabellen
•
Primäre und Fremdschlüssel
•
Indizierungen und Grenzwerte
•
Trigger
•
Stored procedures (SQL Server, Oracle und Adaptive Server Enterprise)
•
Drop-Anweisungen
•
Kommentare für Tabellen und Spalten.
Sie können Datenbankobjekte in ein Diagramm und in ein Package - oder nur in ein Package
importieren, und Sie können diese als neue Objekte importieren oder eine Synchronisation mit
bestehenden Dokumentationsinhalten ausführen.
Unterstützung der Projektabwicklung
Der Enterprise Architect bietet Unterstützung für das Projektmanagement. Projektmanager können
den Enterprise Architect verwenden, um Ressourcen einem Element zuzuweisen, Risiken und
Aufwände einzutragen und um die Projektgröße zu ermitteln. Der EA unterstützt auch die
Abwicklung von Änderungen und Wartungsaufgaben.
Baselines und Differenzen-Ermittlung
Der Enterprise Architect bietet in der Corporate Ausgabe eine ‘Baseline’ (snapshot) –
Funktionalität an, die den Modellzustand zu einem gewünschten Zeitpunkt festhält. Baselines
werden im XMI-Format abgelegt und gemeinsam mit dem Modell in komprimierter Form
gespeichert. Es können auch mehrere Baselines für ein einzelnes EA-Package gespeichert werden.
Eine zu einem bestimmten Projektzeitpunkt abgespeicherte Baseline kann später dazu verwendet
werden, einen Vergleich des aktuellen Package-Standes mit der Baseline anzuzeigen.
Die Differenzermittlungs-Funktion der Professional und Corporate Ausgabe zeigt auf, was im
Laufe der Zeit geändert wurde und wie sich dies von der Version zum Zeitpunkt der Baseline
unterscheidet. Diese Funktion erlaubt Ihnen einen Modellzweig im EA zu vergleichen mit:
•
Einer Baseline, die mit der Baselinefunktionalität erstelt wurde
19
•
Einer Datei auf einem Datenträger, die zuvor mit der EA-XMI-Exportfunktion erzeugt
wurde, oder
•
Einer XMI-Datei aus dem (externen) Versionierungssystem, die aus dem EA heraus erstellt
worden ist.
Projektkennzahlenermittlung mittels “Use Case Metrics”
Die “Use Case Metrics”-Funktion im EA erleichtert es, die relative Komplexität eines
Softwareprojektes zu bestimmen, basierend auf der Anzahl der im Modell enthaltenen
Anwendungsfälle als auch aufgrund der Merkmale des Entwicklungsprojekts und der Eigenschaften
der Entwicklungsumgebung. Mit einiger Erfahrung ist die “Use Case Metrics”-Methode ein guter
Weg, rasch einen Projektumfang zu ermitteln.
Ressourcen
Der EA kann ressourcenbezogene Informationen und Basisinformationen über die
Entwicklungsanteile im Modell speichern. Dieser Zugang erlaubt eine enge Kopplung zwischen
Projektmanager und dem Entwicklungsteam, weil er für den Projektmanager Transparenz schafft,
aktuelle Information über den Projektfortgang bietet und auftretende Wechselwirkungen sichtbar
macht. Sich anbahnende Planabweichungen, kritische Ressourcenverfügbarkeiten können mit
direktem Bezug zu Modellelementen ermittelt werden und durch die leistungsfähige Such- und
Filterfunktion des EAs leicht lokalisiert werden.
Testen
Zusätzlich zur mit eingeschlossenen jUnit und nUnit Testfunktion erlaubt der EA die Zuordnung
von beliebig vielen und beliebig komplexen Testfällen zu jedem einzelnen Modellelement. Die
Modellelemente und die zugehörige Testdokumentation in einem einzigen, integrierten System zu
halten, verbessert die Kommunikation zwischen dem Testteam, den Softwareentwicklern und den
Software-Architekten wesentlich. Auch hier macht es die umfangreiche Suchfunktion leicht,
fehlgeschlagene Testfälle, noch nicht begonnene Test oder erfolgreich abgeschlossene Testfälle
aufzufinden. Durch die Nutzung der Test- und Suchfunktionalitäten ist es einfach, durch das Projekt
zu navigieren, die Problempunkte unmittelbar aufzufinden, Designschwachpunkte zu identifizieren
oder andere kritische Umstände einzugrenzen. Der EA ist nicht nur ein UML-Werkzeug, er ist auch
ein komplettes Test Management-Werkzeug.
Change Management
Wenn sich Projekte entwickeln und ausreifen, wird das Thema Change Management ein kritisches.
Die Berücksichtigung nachgereichter Änderungswünsche ist immer im Zusammenhang mit dem
Gesamtentwicklungsprozess zu sehen. Auch hier beim Thema Change Management hilft der EA
weiter - durch die Möglichkeit der Speicherung und Nachverfolgung von Meta-Information zu
Änderungen, Vorfällen, Erweiterungen und Anforderungen, jeweils im Bezug zu den gerade
aktuellen UML-Modell-Elementen.
Projektaufgaben
Das Setzen, Priorisieren, Zuteilen und Nachverfolgen von Aufgaben in einem Projekt ist ein
kritischer Teil des Projektmanagments während einer Systementwicklung.
In Erweiterung der bereits vorgestellten Projektmanagment-Funktionalitäten, erlaubt der EA auch
die Handhabung von Projektaufgaben, die direkt dem Projekt und nicht einzelnen Modellelementen
zugeordnet werden.
20
Wörterbuch
Als Zusatzfunktion verwaltet der EA ein Modellwörterbuch, eine einfache Möglichkeit,
Fachbegriffe des Projektbereichs, die möglicherweise einzelnen Projektmitgliedern nicht geläufig
sind, zentral zu definieren und zu kommunizieren.
Import - Export Funktionalitäten
Ein Datenaustausch zwischen unterschiedlichen Modellen und zwischen unterschiedlichen
Werkzeugen ist eine gängige Anforderung bei einem Entwicklungsprojekt. Der Enterprise Architect
unterstützt die beiden gängigsten Datenaustauschformate (XMI und CSV) und erleichtert bei Bedarf
die Informations- und Modellportierung in unterschiedliche Werkzeuge oder Repositories.
Gemeinsam mit dem EA API ist derart ein automatischer Import/Export leicht einrichtbar, die
Verteilung von Modellen und die automatische Softwareerstellung werden dadurch sehr einfach.
Unterschiedliche XMI Formate
Der Enterprise Architect unterstützt den Import und den Export vieler XML-basierter ModellAustauschformate. XMI ist eine Spezifikation für den Umbruch komplexer Modellinformation in
für einen Anwender leserliche XML-Strukturen und zum Zweck des Datenaustauschs mit anderen
Werkzeugen. XMI ist ein offener Standard, verwaltet von der OMG. Der Enterprise Architect
unterstützt XMI 1.0, XMI 1.1 und XMI 2.1. Diese Unterstützung mehrerer Formate ist wesentlich,
da viele Werkzeuge eine spezielle XMI-Version voraussetzen.
CSV
Zusätzlich zum XMI Import/Export, bietet der EA eine einfache CSV-Import/Export Funktion. Das
ist hilfreich, um Inhalte an Werkzeuge wie Microsoft Excel zu übergeben oder ähnliche Listen aus
Tabellenkalkulationen zu übernehmen.
UML-Erweiterungen in Enterprise Architect
UML Profile
UML Profile erweitern in gewisser Weise den UML-Sprachumfang. Dies gibt Ihnen die
Möglichkeit, UML-Modelle für spezielle Anwendungszwecke zu erstellen. Profile bauen auf
zusätzlichen Stereotypen und Tagged Values auf, die auf Elemente, Attribute, Methoden,
Beziehungen oder Beziehungsendpunkte angewandt werden. Ein Profil ist eine Sammlung solcher
Erweiterungen, die zusammen eine spezielle Modellierungsaufgabe beschreiben und die
Modellkonstruktion in diesem Bereich unterstützen. Das von David Carlson in Modeling XML
Applications with XML (p. 310) entwickelte UML-Profil beschreibt einen Satz von Erweiterungen
zur grundlegenden UML um das korrekte Modellieren eines XSD Schemas zu ermöglichen.
Der Enterprise Architect hat einen generischen UML-Profil-Mechanismus zum Laden und Arbeiten
mit unterschiedlichen Profilen. UML Profile für den Enterprise Architect werden mittels XMLDateien in einem spezifischen Format definiert. Derartige XML-Dateien können in das RessourcesFenster des Projekt-Browsers des EAs eingefügt werden. Sobald sie eingefügt wurden, können sie
in ein Diagramm mit der Maus gezogen werden. Der EA fügt die Stereotypen, Tagged Values und
die Standardwerte, Notizen und, falls vorhanden, auch eine Metadatei in das neue Element ein. Sie
können auch Attribute und Operationen in bestehende Klassen ziehen und dadurch direkt
hinzufügen – mit dem vorgegebenen Stereotyp, den Werten und anderen Parametern.
UML Muster (Patterns)
Muster/Patterns sind parametrisierte Vorlagen; d.h. es handelt sich um eine Gruppierung von
21
zusammengefassten Objekten und Klassen, die von Modellierungsvarianten abstrahiert werden
kann. Patterns sind Musterbeispiele für Wiederverwendung und dadurch erzielte Robustheit. Sobald
die Verwendbarkeit eines Musters in einem neuen Projekt erkannt wird, kann das eingefügte Muster
aus früheren Projekten mit angepassten Variablennamen im gegenwärtigen Projekt verwendet
werden.
Patterns beschreiben generisch die Lösung eines abstrakten Problems und es ist die Aufgabe des
Anwenders eines Patterns, dieses an den konkreten Bedarf im aktuellen Projekt anzupassen.
MDG Technologie
Die Model Driven Generator (MDG) Technologie erlaubt Ihnen die Bündelung einer logischen
Vorlagensammlung einer spezifischen Technologie an zentraler Stelle im Enterprise Architect. Mit
der MDG Technologie bekommen Sie die Möglichkeit, UML-Profile, UML-Patterns, Codevorlagen
und Codeteile gut gegliedert in der Resource View des Enterprise Architects abzulegen. Alle
notwendigen Teile zur Verwendung der MDG Technologie finden Sie als Angebot von Sparx
Systems zum Download unter from: www.sparxsystems.com/resources/mdg_tech.
Spezielle Add-Ins
Add-Ins fügen dem Enterprise Architect weitere Funktionen hinzu. Die Enterprise Architect Add-In
Funktionalität stützt sich auf das erprobte Automationsinterface, sodass Sie auch das BenutzerInterface erweitern können.
Add-Ins sind ActiveX COM Objekte, die öffentliche Aufrufmethoden zur Verfügung stellen. Dies
hat verschiedene Vorteile gegenüber abgesetzten Automatisierungslösungen:
•
Add-Ins können EA-Menüpunkte und Untermenüs anlegen
•
Add-Ins erhalten Bestätigungen über verschiedenste EA-Benutzer-Interface Vorgänge,
einschließlich Klicks in Menüs und Dateiwechselvorgänge
•
Add-Ins können (und sollten) als Prozesskomponenten (DLL) geschrieben werden; dies
bedingt weniger Aufrufaufwand und bessere Integration in die EA Umgebung.
•
Läuft schon eine Instanz des EAs, gibt es keinen Grund eine zweite Kopie über das
Autoamtionsinterface zusätzlich zu starten
•
Da das Add-In der aktuell laufenden Kopie des EAs zugeordnete Object Handles erhält, ist
mehr Information über das aktuelle Benutzerverhalten verfügbar – z.B. über gerade im
Diagramm selektierte Elemente.
•
Um Add-Ins verfügbar zu machen, genügt es, sie zu installieren; es ist keine Konfiguration
erforderlich.
Unterstützung von SOA (Service Oriented Architecture)
Der Enterprise Architect erlaubt das rasche Modellieren, Forward Engineering und Reverse
Engineering zweier Schlüssel W3C XML Technologien: XML Schema (XSD) und Web Service
Definition Language (WSDL).
Die Unterstützung von XSD und WSDL ist wichtig für die Entwicklung einer vollständigen Service
Oriented Architecture (SOA), und die Verbindung von UML 2.1 und XML stellt den naheliegenden
Mechanismus zum Spezifizieren, Aufbau und zur Verteilung von XML-basierten SOAAusprägungen SOA in einer Organisation dar.
XSD Funktionalität
XML Schemas werden mit UML-Klassendiagrammen und der XML-Schema-Toolbox modelliert.
22
Die XML-Schema-Toolbox bietet das UML-Profil für XSD. Dies gestattet die automatische
Erzeugung einer W3C XML Schema (XSD)-Datei aus einem abstrakten UML-Klassenmodell.
WSDL Funktionalität
Der EA unterstützt Forward und Reverse Engineering der W3C Web Service Definition Language
(WSDL). Die WSDL-Toolbox des EAs kann zum einfachen Modellieren von WSDL-Dokumenten
verwendet werden, die als Komponenten mit dem Stereotyp WSDL gekennzeichnet werden.
WSDL-Dokumente werden in einer Package-Hierarchie abgelegt, die den WSDL Namespace und
die zusammensetzenden XSD-Typen, Meldungen, Port Typen, Bindings und Dienste
repräsentieren.
Modellierung von Geschäftsprozessen
Es gibt viele Annäherungen, mit UML als Basis-Modellierungssprache Geschäftsprosse (business
processes modeling BPM) zu modellieren. Aktivitätendiagramme, Objektdiagramme und
angepasste Profile stellen zum Teil eine Möglichkeit für Analysten zum Modellieren von
Geschäftsprozessen dar. Der Enterprise Architect ergänzt die Basis-UML 2.1 Sprachpalette durch
Elemente für Vorgangsanalyse, Requirements Management (Anforderungsmanagement) und
Prozess Management (wie z.B. Änderung/Change, Erweiterung/Feature und Vorfalls-Elemente).
Das BPMN Profil
Eine populäre Notation der Geschäftsprozessmodellierung ist die Business Process Modeling
Notation (BPMN) (siehe auch www.bpmi.org). Diese Notation ist für eine spezielle Anwendergruppe ausgelegt, hat aber eine relative direkte Abbildung an UML - durch das BPMN-Profil. Sparx
Systems implementiert ein BPMN Profil und stellt ein BPMN Technologie Add-In für den
Enterprise Architect für Anwender zur Verfügung, die die Basis-UML-Grammatik um die BPMNNotation erweitern wollen. Ein kostenloser Download bietet exzellente BMPN-Unterstützung mit
allen Zeichenelementen und den in der BPMN für sie spezifizierten Beziehungen.
Requirements Management - Anforderungsmanagement
Typischerweise ist der erste Schritt der Lösungsfindung die Sammlung von Anforderungen, sei es
eine Softwareentwicklung, sei es eine Geschäftsprozessoptimierung. Anforderungen stellen
schlechthin dar, was ein System liefern oder ergeben soll. Die im EA eingebaute
Anforderungsverwaltung kann verwendet werden zur:
•
Anlage eines gegliederten und hierarchisch organisierten Anforderungsmodells
•
Verknüpfung der Systemanforderungen mit Modellelementen und Nachverfolgung der
Umsetzung über die Verknüpfungen
•
Suche nach Anforderungen und Reporterstellung zu Anforderungen als auch eine
Auswirkungsanalyse bei Anforderungsänderungen.
Prozessunterstützung
UML ist eine Sprache, kein Prozess. UML beschreibt die Elemente einer Modellierungssprache und
wie diese Elemente zusammengesetzt werden können, um Umstände in einer realen Welt zu
repräsentieren. UML beschreibt nicht, wie diese Elemente der Reihe nach einzusetzen sind, um ein
neues Softwaresystem aufzubauen.
Wie UML ist der EA prozess-neutral, d.h. er enthält alle Bestandteile und Funktionen um einen
gewünschten Entwicklungsprozess umzusetzen, aber er schreibt nicht vor, wie dieser Prozess
aussehen soll oder umzusetzen ist.
23
Viele EA-Anwender wenden hochstrukturierte Prozesse an, z.B. RUP, während andere Anwender
flexiblere und weniger restriktive Prozesse bevorzugen. Unabhängig davon, welchen Grad der
Prozessorientierung Sie wünschen, der EA enthält die benötigten Werkzeuge und Bestandteile um
den fortschreitenden Prozess einer Softwareentwicklung zu handhaben.
---
24
Über Sparx Systems
Sparx Systems wurde 1996 von Geoffrey Sparks in
Creswick Australien gegründet. Sparx Systems ist
beitragendes Mitglied der Object Management Group
(OMG), dem verantwortlichen Standardisierungsgremium
der UML Spezifikation und vieler anderer, zugehöriger
Spezifikationen.
SparxSystems Central Europe Software GmbH ist seit Mai 2004 in Europa aktiv, wobei zunächst
mit der Übersetzung für den deutschsprachigen Markt begonnen wurde. Nunmehr haben wir uns als
lokaler Ansprechpartner für den gesamten Deutschsprachigen Raum etabliert.
Firmen-Vision
Sparx Systems ist der Überzeugung, dass ein umfassendes Modellierungs- und Entwurfswerkzeug
für den gesamten Software-Lebenszyklus eingesetzt werden soll. Unsere langfristige Planung
spiegelt dies wieder, ebenso wie unsere Überzeugung, dass eine Software für den Lebenszyklus
genau so dynamisch und modern wie die von Ihnen entworfenen und betriebenen Systeme sein soll.
Die Software von Sparx ist zum Einsatz durch Analysten, Designer, Architekten, Entwickler,
Tester, Projektmanager und die Wartungsmannschaft gedacht; das ist also praktisch jeder, der in
einer Softwareentwicklung oder einer Analyse beteiligt ist. Es ist die Überzeugung von Sparx, dass
hochpreisige CASE-Tools in ihrer Sinnhaftigkeit für ein Team und damit für eine Organisation
stark beschränkt sind, weil sie durch ihre Kosten den einfachen Zugang zum Modell und damit zum
Entwicklungswerkzeug behindern. Daher fühlt sich Sparx Systems verpflichtet, einerseits eine
akzeptable Preispolitik zu betreiben und andererseits einen EA-Reader kostenlos für jene zur
Verfügung zu stellen, die nur die Einsicht in ein Modell benötigen.
Langfristige Ausrichtung auf unternehmensweite UML Werkzeuge
Sparx Systems hat über zehn Jahre Modellierungswerkzeuge entwickelt und hat dabei den
Enterprise Architect auf unternehmensweite Verwendung ausgelegt. Zusätzlich bemüht sich Sparx
Systems Anforderungen und Vorschläge aus der breiten Anwenderschar zu berücksichtigen.
Dadurch konnten schon viele Funktionen eingebunden werden, die für Entwickler wichtig sind und
viele Aspekte der Praxis bedecken. Sparx Systems fühlt sich der Weiterentwicklung sowohl des
UML-Modellierungswerkzeuges Enterprise Architect als auch der der zahlreichen Plug-Ins
verpflichtet, die anwenderspezifische Anforderungen erfüllen.
Kontaktdaten
SparxSystems Software GmbH
Ferrogasse 80/3
A-1180 Wien, Austria
Tel.: +43 (0)662 90 600 2041
Fax: +43 (0)662 90 333 3041
e-Mail: [email protected] Verkauf und Bestellabwicklung: [email protected]
Produkt-Support: [email protected]
25