Enterprise Architect 6.5
Transcrição
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