Evaluation von Frameworks für die Entwicklung und In- tegration einer graphischen Darstellung von Beziehungen zwischen Entitäten in Datenbanken ...
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Evaluation von Frameworks für die Entwicklung und In-
tegration einer graphischen Darstellung von Beziehun-
gen zwischen Entitäten in Datenbanken und JPA basier-
ten Softwaresystemen in Japedo
Seminararbeit
Student: Felix Tietz
Matrikelnummer: 3199486
1. Prüfer: Prof. Dr. Alexander Voß
2. Prüfer Dr. Wolfgang WinterAbkürzungen und Glossar
Tabelle 1 Abkürzungen
Abkürzung Bedeutung
JDK Das Java Development Kit wird verwendet, um Java-Anwendungen zu
entwickeln.
JVM Die Java Virtual Machine ist ein Container, in dem Java-Code ausge-
führt wird.
JPA Die Java Persistence API ist eine Schnittstelle für die Übertragung von
Java-Objekten und Attributen in Datenbanken.
PNG Portable Network Graphics ist ein Bild- und Graphikformat mit ver-
lustfreier Komprimierung.
SQL Die Structured Query Language ist eine Datenbanksprache zur Defi-
nierung von Datenstrukturen und Bearbeiten von Daten in relationa-
len Datenbanken.
SVG Scalable Vector Graphics sind Vektorgraphiken, die ohne Qualitäts-
verlust verschieden skaliert werden können.
UML Die Unified Modeling Language ist eine Modellierungssprache, die
durch Visualisierung die Konstruktion von Einzelteilen eines Software-
systems darstellt.
Tabelle 2 Glossar
Begriff Erklärung
Classpath Dieser ist eine Liste von Quellen, die einem Programm zur Verfügung
stehen.
Doclet Doclets sind Softwaremodule, die durch Dokumentationswerkzeuge
für die automatisierte Generierung von Dokumentation verwendet
werden.DOT Diese Sprache ist eine schlicht gehaltene Beschreibungssprache für
gerichtete und ungerichtete Graphen sowie ihre visuellen Darstellun-
gen.
ER-Diagramm Dieses Diagramm stellt Beziehungen von Datenbankobjekten dar.
Framework Das Framework ist ein Programmiergerüst, das im Bereich der objekt-
orientierten Softwareentwicklung verwendet wird. Es stellt eine Basis
für das zu entwickelnde System dar.
GitHub Dies ist eine Plattform im Internet, die es ermöglicht, sowohl öffentli-
che als auch private Softwareprojekte anzulegen.
GraalVM Dies ist eine alternative JVM und bietet ein eigenes JDK. Es werden
auch weitere Programmiersprachen wie JavaScript unterstützt.
Javadoc Javadoc ist ein Dokumentationswerkzeug für Java-Code. Dieser wird
in eine nutzerfreundliche und leicht lesbare HTML-Darstellung ge-
bracht.
JavaScript Dies ist eine Scriptsprache für die Entwicklung von Web-Anwendun-
gen - auch bekannt unter ECMAScript.
Klassendiagramm Dies ist ein UML-Diagramm, das den Aufbau von und die Abhängigkei-
ten zwischen Klassen darstellt.
Maven Maven ist ein Java-basiertes Build-Management-Tool der Apache
Software Foundation. Mit ihm können auf Java basierende Software-
projekte verwaltet und standardisiert werden.
Persistenzklassen Dies sind Klassen innerhalb des Programmcodes, deren Daten in der
Datenbank abgespeichert (persistiert) werden.
Sequenzdiagramm Dies ist ein UML-Diagramm, das den Ablauf innerhalb eines Software-
systems darstellt.
UML-Diagramme Diese sind Diagramme, die den UML-Spezifikationen entsprechen.
Wireframes Wireframes werden als Modelle für Weboberflächen verwendet.Inhaltsverzeichnis
Abkürzungen und Glossar .......................................................................................................... 2
Abstrakt ...................................................................................................................................... 7
Einleitung .................................................................................................................................... 8
Konventionen ......................................................................................................................... 8
Gegebenheiten ....................................................................................................................... 8
Motivation .............................................................................................................................. 8
Ziel der Seminararbeit ............................................................................................................ 9
Ausgangssituation .................................................................................................................... 10
Japedo ................................................................................................................................... 10
Datenbankdokumentation in Kombination mit Programmcode ...................................... 10
Funktionsweise ................................................................................................................. 10
Graphische Darstellung ........................................................................................................ 11
Anforderungsanalyse ............................................................................................................... 12
Ziel......................................................................................................................................... 12
Pflichtanforderungen............................................................................................................ 12
Zusätzliche Anforderungen................................................................................................... 12
Relevant ............................................................................................................................ 12
Zweitrangig........................................................................................................................ 13
Frameworks und Vorgehensweisen ......................................................................................... 14
UMLGraph............................................................................................................................. 14
PlantUML .............................................................................................................................. 16
PlantUML Builder .................................................................................................................. 17
GraphViz-java........................................................................................................................ 18
Datenbankdokumentation – ER-Diagramm ......................................................................... 20
Auswertung........................................................................................................................... 20
GraphViz-Java.................................................................................................................... 20
UMLGraph oder PlantUML (mit PlantUML Builder) ......................................................... 21
Datenbankdokumentation ................................................................................................ 22
Zweitrangige Zusatzanforderungen .................................................................................. 22
Fazit und Ausblick ..................................................................................................................... 24Hinweise und mitgeltende Unterlagen .................................................................................... 26 Eidesstattliche Erklärung ...................................................................................................... 26 Tabellenverzeichnis .............................................................................................................. 26 Abbildungsverzeichnis .......................................................................................................... 26 Literaturverzeichnis .............................................................................................................. 28
Abstrakt In dieser Seminararbeit wird das Thema behandelt, wie und mit welchen Frameworks die Dokumentation von Java Persistence API-Projekten sowie den dazu gehörigen Datenstruktu- ren aus einer Datenbank visuell als Graph dargestellt werden können. Dazu werden verschie- dene Frameworks vorgestellt und für die weitere Implementation evaluiert. Diese Evaluation basiert auf den Anforderungen an das Projekt und wie dieses umgesetzt werden soll. In der Einleitung wird zunächst in das Thema Softwaresysteme eingeleitet. Daraufhin wird die Relevanz von Dokumentationen eines solchen Systems samt Programmcode und Datenbank dargestellt. Zudem wird erläutert, wie aktuelle Datenbankdokumentationen in Tabellenform aussehen und daraus die Notwendigkeit einer vereinfachten graphischen Darstellung abgelei- tet. Weitergehend wird die Ausgangssituation beschrieben. Das Dokumentationstool Japedo soll eine solche graphische Darstellung erhalten. Aus diesem Grund wird der aktuelle Aufbau die- ses Programms und der dadurch generierten Daten aufgezeigt. Im Laufe der Anforderungsanalyse werden Anforderungen an den Graphen und verwendete Frameworks gestellt. Diese werden sowohl in Pflichtanforderungen als auch weitere zusätzli- che Anforderungen unterteilt. Letztere wurden nach Relevanz priorisiert, um einen besseren Vergleich zu schaffen und Frameworks abschließend für die Implementation empfehlen zu können. Im Kapitel Frameworks und Vorgehensweisen werden ebensolche vorgestellt sowie evaluiert und anhand ihrer Funktionalitäten und Eigenschaften analysiert. So können diese abschlie- ßend gegenübergestellt und bewertet werden. Abschließend wird ein Fazit gezogen und für die ausstehende Implementation eine Empfeh- lung der zu verwendenden Frameworks und Vorgehensweisen ausgesprochen. Ebenfalls folgt ein grober Ausblick auf den anstehenden Aufwand von Implementation und Integration. 6
Einleitung Konventionen Für eine leichtere Lesbarkeit der Arbeit wird im Folgenden auf eine geschlechtsspezifische Dif- ferenzierung wie zum Beispiel Leser/-in verzichtet. Entsprechende Begriffe schließen beide Geschlechter ein. Gegebenheiten In der aktuellen Zeit sind moderne Rechner im Alltag der Gesellschaft omnipräsent. Durch ihre steigende Leistung und zunehmende Vernetzung werden sie für jegliche Zwecke verwendet. Das Smartphone in der Hosentasche ist nur einen Griff entfernt, wenn der Weg zu einem be- stimmten Ort, eine Telefonnummer oder einfach die Öffnungszeiten eines Geschäfts unklar sind. Nachrichten werden heutzutage über wenige Gesten auf dem Smartphone eingegeben und innerhalb von Sekunden an die Zielperson zugestellt. Selbst Fernseher sind heute mit mo- dernen Rechenchips ausgestattet und dem Internet verbunden, um Medien und Inhalte rund um die Uhr auf Abruf bereitzustellen. Je weiter die Technik voranschreitet, desto komplexer und vielfältiger wird sie. Im Hintergrund dieser alltäglich genutzten Dienste arbeiten hoch skalierte Softwaresysteme, die mit Hilfe von komplexen Datenbanken Daten speichern, verarbeiten und bereitstellen kön- nen, um den Nutzer zu jeder Zeit zufriedenzustellen. Sowohl diese Softwaresysteme als auch die Datenbanken müssen gepflegt und gewartet werden. Bei wachsender Anzahl an Funktio- nen und Nutzern steigt entsprechend die Komplexität hinter den verwendeten Datenstruktu- ren. So kann es mit der Zeit schwierig werden, den Überblick über ein System zu behalten. Aus diesem Grund sind Programme zur Datenbankvisualisierung in den verschiedensten Be- reichen der Softwareentwicklung zu einem integralen Bestandteil geworden. Motivation Datenbankdokumentationen werden für SQL-Datenbanken klassischerweise in Tabellenform generiert. Diese können abhängig von der Komplexität des Systems schwer verständlich sein. So fehlt damit arbeitenden Personen wie beispielsweise Softwareentwicklern, die neu an ein 7
existierendes Projekt herantreten, ohne jegliches Vorwissen zu dem zu Grunde liegenden Sys- tem, die Übersicht über alle Informationen. Es ist nicht auf den ersten Blick ersichtlich, in wel- cher Beziehung Tabellen oder Entitäten zueinanderstehen. Diese Metadaten sind für gewöhn- lich nur für Datenbankarchitekten auf den ersten Blick erkennbar. Aus diesem Grund soll eine graphische Darstellung entwickelt werden, die Beziehungen zwi- schen Inhalten simpel und auf den ersten Blick verständlich darstellt. Sie soll leicht zu lesen und zu bedienen sein, um für verschiedenste Nutzer einen übersichtlichen und schnellen Ein- blick in das gegebene System zu bieten. Ziel der Seminararbeit Das Ziel dieser Arbeit ist es, eine Anforderungsanalyse für ein Tool zur Generierung von Gra- phen aus Programm- und Datenbankstrukturen durchzuführen. Daraufhin soll ein Konzept entwickelt werden, wie die Anwendung zu implementieren ist. Dazu werden verschiedene bereits auf dem Markt verfügbare Frameworks vorgestellt, auf An- wendbarkeit und Funktionalität geprüft, sowie für die weitere Implementierung als Möglich- keit herangezogen und evaluiert. Dabei muss beachtet werden, dass die Generierung des Gra- phen in das Datenvisualisierungsprogramm Japedo integriert werden soll. 8
Ausgangssituation Japedo Datenbankdokumentation in Kombination mit Programmcode Struktur und Aufbau einer Datenbank zu kennen, ist immer ein guter Anfang, um mit dieser arbeiten zu können. Allerdings ist der Umgang mit einer solchen schwierig, wenn nicht ersicht- lich ist, wie Daten generiert und verarbeitet werden. Aus diesem Grund müssen die Struktur aus der Datenbank und dem verbundenen Programmcode in Beziehung gebracht werden, um das gesamte Softwaresystem darstellen zu können. Um einen solchen Überblick für den Endbenutzer leicht darzustellen, wurde Japedo entwi- ckelt. Diese Anwendung ermöglicht, Dokumentation von Code und Datenbank miteinander zu verknüpfen. Dies bietet nicht nur Übersicht über die Architektur der einzelnen Systeme, son- dern auch zwischen Datenerzeugung und Datenverwaltung. Japedo selbst generiert aus den gegebenen Quellen eine vollwertige dynamisch aufgebaute HTML-Seite, in der die verknüpften Daten tabellarisch gelistet sind (vgl. Winter, Briesemeister, Paquet, & Tietz, 2020). Funktionsweise Japedo ist es möglich, aus Java Persistence API (kurz JPA) basierten Applikationen die Meta- daten der verschiedenen Entitäten, ihre Attribute und auch ihre Beziehungen zueinander aus- zulesen. Diese werden miteinander verknüpft und in tabellarischer Form dargestellt. In einer mit JPA realisierten Applikation werden die einzelnen Datenbankbeziehungen innerhalb der verschiedenen Entitäten angegeben. So können durch eine entsprechende Datenbankverbin- dung alle mit den Entitäten verknüpften Tabellen ausgelesen und mit dem Quellcode in Rela- tion gebracht werden. Dadurch entsteht die Verbindung von Klassen- und Datenbankdoku- mentation. Im folgenden Bild ist ein Auszug aus den von Japedo generierten Daten zu sehen: 9
Abbildung 1 Aus Japedo generierte Tabellendarstellung Graphische Darstellung Derzeit ist die einzige mögliche Darstellung der ausgelesenen Daten die Tabellenform. Um die Beziehungen zwischen einzelnen Tabellen herauszustellen, müssen diese innerhalb eines Gra- phen, zum Beispiel einem ER-Diagramm, verknüpft werden. Durch in Beziehung setzen mit den Java-Klassen wird ersichtlich, welche Tabellen korrespondierende Persistenzklassen be- sitzen und umgekehrt. Dieser Graph soll in eine statische HTML-Seite integriert und optional mit Hilfe von JavaScript oder vergleichbaren Technologien mit dieser Seite interagieren kön- nen. 10
Anforderungsanalyse
Ziel
Ziel dieser Arbeit ist es, eine fundierte Empfehlung zu geben, welches Framework sich für die
Generierung eines Graphen am besten eignet oder ob diese Funktionalität leichter von Hand
zu implementieren ist.
Ebenfalls soll, sofern möglich, der zu erwartende Aufwand abgeschätzt werden.
Es gelten verschiedene Bedingungen für den Graphen sowie die verwendeten Frameworks,
welche im Folgenden dargestellt werden. Die Anforderungen werden dabei in zwei Kategorien
unterteilt;
- Die Pflichtanforderungen beschreiben alle Funktionen, die obligatorisch für das Pro-
gramm sind.
- Die zusätzlichen Anforderungen sind optionale Funktionen, die wiederum nach Rele-
vanz kategorisiert werden.
Pflichtanforderungen
- Der Graph soll vergleichbar wie ein ER- oder UML-Klassendiagramm aufgebaut sein.
Hierbei sollen Klassen und Tabellen im Diagramm mit wichtigsten Daten dargestellt
werden.
- Der Graph muss nativ in eine statische HTML-Seite eingebunden werden können.
- Es sollen so wenig wie möglich Interdependenzen zu Drittsoftware, die nicht auch
durch Maven oder ein beliebiges anderes Build-Management-Tool in das Projekt ein-
gebunden werden kann, vorhanden sein.
Zusätzliche Anforderungen
Relevant
- Bei Auswahl eines Elementes in der tabellarischen Form soll das dazugehörige Objekt
im Graphen angezeigt beziehungsweise fokussiert werden.
- Ebenfalls soll bei der Auswahl eines Elements im Graphen die entsprechende Tabelle
in der Übersicht ausgewählt und geöffnet werden.
11- Verwendete Frameworks sollten möglichst aktuell sein und weiterentwickelt werden.
Zweitrangig
- Elemente im Graphen können vergrößert oder verkleinert werden.
- Der Graph ist mit Hilfe der Maus insoweit verschiebbar, dass andere Elemente und ihre
Beziehungen zueinander sichtbar werden.
- Die Strukturierung und Anordnung von Elementen kann nach Generierung des Gra-
phen geändert werden.
12Frameworks und Vorgehensweisen Im Folgenden werden verschiedene Frameworks samt ihrer Vor- und Nachteile sowie Arten von Einbindung und Anwendung vorgestellt. UMLGraph UMLGraph ist ein OpenSource-Programm, das von Diomidis Spinellis entwickelt wurde. Es wurde 2002 erstmals in Version 1.15 veröffentlicht. Seither wird es über GitHub gepflegt, hat sein letztes Release im Oktober 2014 erhalten und liegt in der Entwickler Version 5.7.2 vor. (vgl. Spinellis, UMLGraph - GitHub, 2020). Dieses Programm ist offen für Modifikationen von anderen Entwicklern und wurde bereits von diversen Personen unterstützt und weiterentwi- ckelt (vgl. Spinellis, UMLGraph, 2014). Mit UMLGraph wurde ein Java-Framework entwickelt, das sowohl Klassen- als auch Sequenz- diagramme nach UML generieren kann. Da Sequenzdiagramme in dieser Arbeit keinem An- wendungszweck dienen, wird sich im Folgenden auf Klassendiagramme konzentriert. Um diese zu erzeugen, muss nur der Java-Quellcode des Programms vorliegen, aus dem Klassen- diagramme generiert werden können. In der folgenden Abbildung sind ein einfacher Java-Code und das daraus mit UMLGraph er- zeugte Klassendiagramm zu sehen. Abbildung 2 Beispiel UMLGraph Klassendiagramm Für die Ausführung von UMLGraph wird eine Installation von Javadoc vorausgesetzt, da das Programm als Doclet realisiert ist. Javadoc ist für gewöhnlich in jedem JDK enthalten und kann somit auf jedem Rechner ausgeführt werden, auf dem Java-Programme entwickelt werden. Derzeit wird allerdings nur Javadoc bis Java 8 unterstützt. Mit Hilfe des Doclets werden die Diagramme in der DOT-Language von GraphViz generiert. Diese wiederum müssen mit Hilfe einer GraphViz-Installation in Bildformate wie SVG, PNG oder andere umgewandelt werden. 13
Für die Ausführung des Doclets gibt es verschiedene Möglichkeiten.
1. Das mitgelieferte Skript wird in das zu visualisierende Java-Verzeichnis gelegt und der
Pfad zur UMLGraph-Installation muss angepasst werden. Danach kann das Skript über
die Kommandozeile aufgerufen werden. Das geschieht wie üblich durch den Skriptna-
men. Als notwendige Parameter sind die Java-Quelldatei sowie das gewünschte Bild-
format anzugeben. Optional können weitere Javadoc-Argumente angefügt werden. Im
Folgenden wird ein möglicher Konsolenaufruf dargestellt:
umlgraph Testklasse png {javadoc-argumente}
(vgl. Spinellis, Class Diagram Options, 2015)
2. Sollte die Verwendung des Skriptes unerwünscht sein, kann das Programm auch über
die Konsole mit Hilfe von Java selbst ausgeführt werden. Dafür wird mit dem Java-Be-
fehl die Klasse UMLGraph aufgerufen. Zu dieser wird (wie im ersten Schritt) als Para-
meter der Pfad zur Java-Quelldatei übergeben. Zusätzlich kann über den „package“-
Parameter das gesamte Package verarbeitet werden.
Allerdings wird für die Ausführung mit Java eine Bibliothek namens Tools.jar aus Ja-
vadoc benötigt. Liegt UMLGraph im gleichen Pfad wie diese Bibliothek, so kann das
Programm durch folgenden Konsolenaufruf gestartet werden:
java -jar path_to/UmlGraph.jar -package Testclass.java (vgl. ebd.)
Liegt UMLGraph nicht im gleichen Pfad, so müssen beide Bibliotheken in den Classpath
eingebunden werden:
java -classpath "path_to_/UmlGraph.jar; path_to_jdk\lib\Tools.jar"
org.umlgraph.doclet.UmlGraph -package
Testclass.java (vgl. ebd.)
3. Alternativ kann auch Javadoc über die Konsole aufgerufen werden. Dabei werden drei
Parameter übergeben. Dazu gehören unter docletpath der Pfad zur UMLGraph-Bibli-
othek, unter doclet der voll qualifizierte Klassenname der auszuführenden UMLGraph
Klasse (org.umlgraph.doclet.UmlGraph) und zuletzt die Quelldatei, aus der Dia-
gramme generiert werden sollen. Es folgt ein beispielhafter Konsolenbefehl.
„javadoc -docletpath UmlGraph.jar -doclet org.umlgraph.doclet.UmlGraph
-private Simple.java„ (Spinellis, Class Diagram Options, 2015)
14Die letzten beiden Möglichkeiten generieren allerdings nur Diagramme im GraphViz-Dot-For- mat, welche mit Hilfe von GraphViz in Bilddateien umgewandelt werden können. PlantUML PlantUML ist eine Open-Source-Anwendung, mit der sich diverse Diagramme erzeugen lassen. Die erste frei verfügbare Version trägt die Nummer 6055 und wurde vom Entwickler Arnaud Roques 2009 unter der GNU General Public License veröffentlicht. Sie wird fortlaufend wei- terentwickelt. Die derzeit aktuelle Version 1.2020.26 wurde im Dezember 2020 freigegeben (vgl. Roques, PLantUML - Maven Repository, 2020). Mit PlantUML lassen sich diverse Diagramme erzeugen. Zu diesen gehören sowohl UML-Dia- gramme wie Klassen- und Objektdiagramme aber auch Mindmaps oder Wireframes. Im wei- teren Verlauf sind im Vergleich zu Klassendiagrammen die Objektdiagramme von Bedeutung, da sich diese flexibler handhaben lassen. Denn diese können im Vergleich zu Klassendiagram- men nicht nur Namen, Attribute und Beziehungen von Entitäten abbilden. Sie können auch als ER-Diagramm strukturiert oder mit diesen verbunden werden, um die Verknüpfung von Da- tenbanktabellen und Klassen besser darzustellen. Diese müssen für PlantUML in einer eigenen menschlich leicht lesbaren Sprache geschrieben werden. Dadurch wird das Erstellen von Dia- grammen durch die notwendige Konvertierung der Daten aufwändiger. Doch dies lässt sich mit Hilfe von PlantUML Builder, der im weiteren Verlauf näher beleuchtet wird, leicht lösen. Folgende Abbildung zeigt ein beispielhaftes Objektdiagramm von drei Klassen und einer dazu- gehörigen Datenbanktabelle. Abbildung 3 Beispielhaftes Objektdiagramm PlantUML kann über verschiedene Wege eingebunden und ausgeführt werden. Dazu gehören verschieden lizensierte und zum Download zur Verfügung gestellte Versionen, das Abrufen von Diagrammen über einen Server oder aber die Einbindung einer Bibliothek, zum Beispiel 15
mit Hilfe von Maven. Bei bestehender Internetverbindung oder einem im lokalen Netz ausge- führten PlantUML-Server kann auch auf eine integrierte Anwendung zur bildlichen Diagram- merzeugung verzichtet werden. Dazu müssen die textuellen Diagrammbeschreibungen über einen HTTP-Request an einen PlantUML-Server gesendet werden, um die erzeugten Bildda- teien abzurufen. Es besteht die Möglichkeit, den öffentlich verfügbaren Server oder aber ei- nen selbst gehosteten zu verwenden. Sollten die HTTP-Requests und ein PlantUML-Server verwendet werden, sind zwar keine wei- teren Programme/Installationen notwendig, allerdings eine Internetverbindung und ein ver- fügbarer PlantUML-Server. Diese Art der Einbindung ist vor allem bei Programmen sinnvoll, die besonders platzsparend sein müssen. Da Japedo mit Hilfe eines Maven-Projekts realisiert wird, ist das Einbinden von einer Plan- tUML-Bibliothek leicht umzusetzen. Nach der Integration können alle Funktionen innerhalb des Java-Codes aufgerufen werden, ohne dass im Vergleich zu UMLGraph eine Konsole not- wendig ist. Allerdings wird bei der Nutzung der Bibliothek eine Anwendung benötigt, die die Diagramme offline erzeugen kann. Damit wird die Funktionalität auf Systemen sichergestellt, die nicht an das Internet angebunden sind. Dies kann sowohl durch eine lokale GraphViz-In- stallation als auch durch Einbindung einer weiteren Java-Bibliothek via Maven erfolgen. In die- sem Fall ist die Einbindung durch Maven sinnvoll, da dies leichter zu handhaben und neben Japedo keine zusätzliche Programminstallation notwendig ist. PlantUML Builder PlantUML Builder ist ein Open-Source Projekt und wurde im Juni 2017 erstmals von Julien Boz unter der Apache License 2.0 veröffentlicht. Die derzeit aktuelle Version 1.5 wurde im Juni 2020 veröffentlicht (vgl. Boz, 2020). Mit Hilfe des PlantUML Builders lassen sich Entitäten aus einem Java-Projekt für die Generie- rung eines Diagramms mit PlantUML vorbereiten. So wird die Struktur des Projektes ausgele- sen und in eine von PlantUML lesbare Textform gebracht. Aus diesem Text kann sofort ein Klassendiagramm generiert werden. 16
Nachdem PlantUML Builder mit Hilfe von Maven in ein Java-Programm eingebunden wurde,
kann innerhalb einer Codezeile ein Klassendiagramm aus gegebenen Klassen generiert wer-
den. Dazu wird folgender Code ausgeführt:
new ClassDiagramBuilder()
.addClasses(Example.class, AnotherExample.class)
.build();
(vgl. Boz, 2020)
Somit werden dem ClassDiagramBuilder die zu visualisierenden Klassen mitgegeben und zu
einem Klassendiagramm im PlantUML-Format verarbeitet, das in Form eines Strings zurück-
gegeben wird. In dieser Textform lässt sich das Klassendiagramm durch wenige Adaptionen in
ein Objektdiagramm umwandeln, um wie zuvor beschrieben verwendet werden zu können.
Dazu muss das Schlüsselwort class durch object ersetzt werden. Dadurch können nachträg-
lich zu den Klassen auch Datenbanktabellen eingefügt werden.
Neben den Quellen benötigt der PlantUML Builder keine weiteren Hilfsmittel, die Maven nicht
organisieren kann.
GraphViz-java
GraphViz-java ist eine Java-Bibliothek zur Erzeugung von GraphViz-Diagrammen ohne eine zu-
sätzliche GraphViz-Installation auf dem verwendeten System. Es ist ein auf GitHub gehostetes
Open-Source-Projekt von Stefan Niederhauser. Dieses wurde in seiner ersten Version im Ok-
tober 2015 freigegeben und stetig weiterentwickelt. Es liegt derzeit in Version 0.18.0 vor und
wurde im November 2020 veröffentlicht (vgl. Niederhauser, 2021).
Dieses Framework ist eine Implementierung von GraphViz in Java. So können Diagramme in-
nerhalb von Java-Code erstellt, modifiziert und erzeugt werden. Sie können ebenfalls aus einer
Datei im DOT-Format ausgelesen und abschließend bearbeitet werden. Für die Generierung
der Diagramme gibt es drei Möglichkeiten.
1. Wenn GraphViz lokal installiert ist, kann die Engine direkt über das dot-Kommando
aufgerufen werden.
2. Ohne GraphViz-Installation können mit Hilfe einer alternativen JavaScript-GraphViz
Engine namens viz.js Diagramme generiert werden.
173. Sogar die interne JavaScript-Engine von Java, auch Nashorn genannt, lässt sich für die
Generierung einsetzen. Da diese ab JDK 15 aber nicht mehr enthalten ist, kann alter-
nativ oder beim Wechsel des JDK die Engine aus GraalVM bemüht werden.
Die Anwendung selbst lässt sich mit Hilfe von Maven in ein Java-Programm einbinden, sodass
es in vollem Umfang im Programmcode eingesetzt werden kann. Zu Beginn wird mit Hilfe der
Methode useEngine() festgelegt, welche der drei zuvor genannten Optionen der Graphener-
zeugung benutzt wird. Durch useEngine(new GraphvizCmdLineEngine()) wird beispielsweise
die lokale GraphViz-Installation verwendet. Für die Erstellung eines Graphen gibt es zwei Mög-
lichkeiten.
1. Existiert noch kein Graph, muss ein neuer konstruiert werden.
MutableGraph g = mutGraph("Beispiel")
erzeugt einen neuen Graphen mit dem Titel „Beispiel“.
2. Liegt bereits ein Graph als DOT-Datei vor, so kann dieser mit einem InputStream ein-
gelesen und verarbeitet werden. Anstatt einen neuen Graphen zu konstruieren, wird
in
MutableGraph g = new Parser().read(input)
der vorhandene Graph mit dem InputStream (input) aufgerufen. Diesem wurde zuvor
der Dateipfad der DOT-Datei mitgegeben. Dadurch wird der existierende Graph in eine
von Java verarbeitbare Form gebracht.
Nachdem der Graph nun vorbereitet wurde, können über Methodenaufrufe wie add() Attri-
bute oder Objekte hinzugefügt und über mutNode() verändert werden. Unter solchen Objekten
können sich Links aber auch JavaScript-Code befinden. Sobald der gewünschte Graph zusam-
mengestellt ist, wird er durch folgenden Code generiert:
Graphviz
.fromGraph(g)
.render(Format.SVG)
.toFile(new File("example/graph.svg"));
So wird der zuvor in Java erstellte Graph g in das Bildformat SVG gerendert. Dieses soll im
Ordner „example“ unter dem Namen „graph.svg“ gespeichert werden. Sowohl Bildformat als
auch Speicherort und Dateiname können beliebig gewählt werden.
18Sofern Nashorn verwendet wird, werden keine weiteren Programme oder Konfigurationen
benötigt, die nicht automatisch durch die Einbindung in Maven mitgeliefert werden. Dies er-
möglicht eine einfache Integration in das System.
Datenbankdokumentation – ER-Diagramm
Die graphische Darstellung der Beziehungen zwischen Tabellen soll in Anlehnung an ein ER-
Diagramm erzeugt werden. Dazu wurde kein Framework gefunden, das innerhalb von Java-
Code durch eine einfache Datenbankverbindung alle Informationen aus einer SQL-Datenbank
auslesen, geschweige denn verarbeiten und als Graph, zum Beispiel wie PlantUML, darstellen
kann.
Aus diesem Grund müssen die Beziehungen von Datenbanktabellen innerhalb und mit Hilfe
des bereits existierenden Japedo-Programmcodes verarbeitet werden. Im Laufe des Analyse-
Prozesses von Programmcode und Datenbanken durch Japedo werden alle Detaildaten im lo-
kalen Speicher bei Ausführung des Programms vorgehalten. So muss der vorhandene Pro-
grammcode ergänzt werden, um die gesammelten Daten aus den entsprechenden Quellen
auszuwerten und miteinander zu verknüpfen. Dadurch entsteht ein Konstrukt, das einem ER-
Diagramm ähnelt.
Auswertung
GraphViz-Java
Da sowohl bei UMLGraph als auch PlantUML GraphViz benötigt wird, um die Diagramme/Gra-
phen zu visualisieren, muss dieses auf dem Endgerät vorhanden sein. Da Nutzer von Japedo
aber nicht dazu aufgefordert werden sollen, zusätzliche Software auf ihren Computern zu in-
stallieren, ist ein Weg zu finden, dies zu vermeiden. Mit der GraphViz-Java-Bibliothek kann die
Graphen-Generierung direkt in das Java-Programm eingebunden werden. Dadurch entstehen
zwei Vorteile:
1. Die Objektdiagramme können innerhalb des Codes bearbeitet werden, sodass weitere
Informationen wie Datenbank-Tabellen oder aber auch Links sowie Aufrufe von Ja-
vaScript-Funktionen hinzugefügt werden können.
2. Durch Verwendung von Nashorn kann bei der Generierung ebenfalls ein Overhead
durch zusätzliche Abhängigkeiten minimiert werden.
19Aus diesen Gründen ist dieses Framework unumgänglich.
UMLGraph oder PlantUML (mit PlantUML Builder)
Sowohl UMLGraph als auch PlantUML (in Kombination mit PlantUML Builder) können aus ge-
gebenen Klassen ein Klassendiagramm nach UML erzeugen. Dies geschieht allerdings unter
etwas verschiedenen Voraussetzungen. UMLGraph benötigt neben dem zu verarbeitenden
Quellcode noch Javadoc sowie die darin enthaltene Bibliothek Tools.jar und wird über die Kon-
sole ausgeführt. Die Tools.jar ist in Javadoc ab Java 11 allerdings nicht mehr verfügbar. Da
Japedo auf ebendieser Version aufbaut, ist diese Möglichkeit nicht anwendbar.
PlantUML Builder sowie PlantUML können innerhalb des Java-Codes genutzt werden und be-
nötigen außer dem Quellcode keine weiteren Daten, um ein Diagramm im DOT-Format zu ge-
nerieren. Aus diesem Grund kann PlantUML die Pflichtanforderungen im Gegensatz zu UML-
Graph erfüllen.
Tabelle 3 Übersicht und Vergleich der Pflichtanforderungen
Anforderung UMLGraph PlantUML
Struktur vergleichbar mit einem Klassendia-
gramm
Integrierbar in statische HTML-Seite Wird durch SVG-Generierung von
GraphViz erfüllt
Keine zusätzlichen nicht durch Maven integrier-
bare Interdependenzen
Hinzu kommt, dass UMLGraph nicht mehr aktiv weiterentwickelt wird, sodass die aktuell ver-
fügbare Version aus dem Jahre 2014 stammt. PlantUML hingegen hat im Jahre 2020 mehrere
Releases erhalten und wird aktiv weiterentwickelt. Durch Aktualität und kontinuierliche Wei-
terentwicklung können bei Software sowohl die Fehlerhäufigkeit als auch die Sicherheitsrisi-
ken minimiert werden (vgl. Schäfers, 2018). Damit erfüllt PlantUML eine weitere zusätzliche
Anforderung.
20Tabelle 4 Übersicht und Vergleich relevanter Zusatzanforderungen Anforderung UMLGraph PlantUML Auswahl einer Tabelle/Klasse fokussiert das Ele- Abhängig von der Einbindung in die ment im Graphen HTML-Seite möglich Auswahl eines Elements im Graphen öffnet Ta- Durch Einfügen von JavaScript in das ge- belle/Klasse (durch JavaScript im SVG möglich) nerierte SVG möglich Aktualität und Weiterentwicklung gegeben Datenbankdokumentation Auf Grund eines fehlenden Frameworks müssen die Informationen und vor allem die Bezie- hungen von und zwischen Tabellen in der Datenbank durch eine eigene Implementation aus- gelesen und verarbeitet werden. Um diese nach der erfolgreichen Verarbeitung vergleichbar mit der Programmstruktur gra- phisch aufbereiten zu können, ist es möglich, die Struktur ebenfalls mit PlantUML zu visuali- sieren. So können selbst bei getrennter Darstellung die gleichen visuellen Eigenschaften vor- liegen. Des Weiteren kann dem Benutzer dadurch ein einheitliches Bild geboten werden. Um Datenbank- und Programminformationen gegebenenfalls in einem einzigen Graphen zu verknüpfen, müssen aus allen Persistenzklassen die zugehörigen Tabellen ausgelesen und die Verbindung zu diesen in Textform eingebracht werden. Dadurch kann eine allgemeine Über- sicht über alle Daten entstehen. Zweitrangige Zusatzanforderungen Die zweitrangigen Zusatzanforderungen sind von den zuvor genannten Frameworks größten- teils unabhängig. Sie betreffen speziell die Art und Weise der Integration des Graphen in die HTML-Seite. Da sie ausschließlich nutzerfreundliche Zusatzfunktionen darstellen und weder die Erzeugung noch die Integration des/der Graphen beeinflussen, werden sie nicht näher be- trachtet. Allerdings wird im Folgenden kurz auf die Umsetzbarkeit der Anforderungen einge- gangen. Das Verändern der Größe von SVGs innerhalb einer HTML-Seite ist generell nicht allzu schwer umzusetzen. Dafür muss das SVG in eine so genannte ViewBox eingebettet werden. Diese 21
stellt einen durch HTML bereitgestellten Container dar, der die eingefügten Elemente abhän- gig von der Größe der ViewBox skaliert (vgl. Bellamy-Royds, 2017) Sowohl Zoomen als auch Verschieben des Graphen kann mit Hilfe von JavaScript implementiert werden. Die Anordnung der Elemente im Graphen nachträglich zu ändern, ist innerhalb der Website nicht mehr möglich, da der Graph in der Struktur des SVGs mit Hilfe von festgelegten Vektoren bestimmt ist. 22
Fazit und Ausblick Ziel dieser Arbeit ist es, einige auf dem Markt verfügbare Frameworks zu betrachten, die dabei helfen, ER- , Klassen- und/oder Objektdiagramme aus gegebenen Datenstrukturen zu generie- ren. Diese sollten vor allem mit Bezug auf die Integration in Japedo auf ihre Tauglichkeit ge- prüft und bewertet werden. Auf Grund der aktuellen Struktur und den gewünschten graphischen Funktionalitäten wurden entsprechende Anforderungen an die Frameworks gestellt, die in der finalen Implementation verwendet werden können. GraphViz-Java ist ein Framework, um Diagramme zu visualisieren. Dieses ist in jedem Fall notwendig, um in Webseiten integrierbare Bilddateien zu erstellen, da keines der anderen Frameworks dies ohne zusätzliche Software beherrscht. Sowohl UML- Graph als auch PlantUML dienen dem Aufbau von Diagrammen. Während UMLGraph sich auf den Java-Code beschränkt, sind durch PlantUML erzeugte Diagramme unabhängig vom Pro- grammcode. Dieser kann zusätzlich mit Hilfe des PlantUML Builders wie in UMLGraph ausge- lesen werden. Im Vergleich zu PlantUML kann UMLGraph allerdings nicht die notwendigen Anforderungen erfüllen, da es eine Bibliothek aus Javadoc benötigt, die ab Java 11, der von Japedo genutzten Java-Version, nicht mehr enthalten ist. Da diese Bibliothek nicht für die ver- wendete Version vorgesehen ist, sollte sie nicht nachgeladen werden. Dadurch ist UMLGraph nicht funktionsfähig. Der Aufwand der Implementierung berechnet sich aus zwei verschiedenen Teilen: zum einen die Integration im Programmcode; zum anderen die Einbindung des Graphen in die Webseite. Bei der Implementation im Code müssen PlantUML alle Klassen bekannt sein. Ebenfalls müs- sen Tabellen aus der Datenbank, die nicht durch Persistenzklassen erreichbar sind, program- matisch in das Diagramm eingepflegt werden. Die Schwierigkeit der Einbindung in die Web- seite hingegen liegt darin, dass für das Anzeigen von Tabellen keine Links, sondern JavaScript verwendet wird. So muss in die Elemente des Graphen kein Link, sondern JavaScript einge- bunden werden. Basierend auf den Ergebnissen dieser Arbeit wird ein Programm entwickelt werden. Dieses soll aus gegebenen Datenstrukturen in Programmcode und dazugehörigen Datenbanken ei- nen übersichtlichen und in eine Webseite integrierbaren Graphen erzeugen können. Dazu werden PlantUML samt dem PlantUML Builder sowie GraphViz-Java verwendet. Das Pro- gramm wird zukünftig in Japedo integriert, um die Visualisierung eben solcher 23
Datenstrukturen zu vereinfachen. Wie exakt die Integration in Japedo von statten gehen soll, muss im weiteren Verlauf mit den anderen Entwicklern abgesprochen werden. 24
Hinweise und mitgeltende Unterlagen Eidesstattliche Erklärung Hiermit versichere ich, dass ich die Seminararbeit mit dem Thema „Evaluation von Frame- works für die Entwicklung und Integration einer graphischen Darstellung von Beziehungen zwischen Entitäten in Datenbanken und JPA basierten Softwaresystemen in Japedo“ selbst- ständig verfasst und keine anderen als die angegebenen Quellen und Hilfsmittel benutzt habe, alle Ausführungen, die anderen Schriften wörtlich oder sinngemäß entnommen wurden, kenntlich gemacht sind und die Arbeit in gleicher oder ähnlicher Fassung noch nicht Bestand- teil einer Studien- oder Prüfungsleistung war. Ich verpflichte mich, ein Exemplar der Seminar- arbeit fünf Jahre aufzubewahren und auf Verlangen dem Prüfungsamt des Fachbereiches Me- dizintechnik und Technomathematik auszuhändigen. Name: Felix Tietz Aachen, den 15.01.2021 Unterschrift: ______________________ Tabellenverzeichnis Tabelle 1 Abkürzungen ............................................................................................................... 2 Tabelle 2 Glossar ........................................................................................................................ 2 Tabelle 3 Übersicht und Vergleich der Pflichtanforderungen ................................................. 21 Tabelle 4 Übersicht und Vergleich relevanter Zusatzanforderungen ...................................... 22 Abbildungsverzeichnis Abbildung 1 Aus Japedo generierte Tabellendarstellung ........................................................ 11 Abbildung 2 Beispiel UMLGraph Klassendiagramm ................................................................. 14 Abbildung 3 Beispielhaftes Objektdiagramm........................................................................... 16 25
Literaturverzeichnis
Bellamy-Royds, A. (27. Juni 2017). How to Scale SVG. Von CSS-Tricks: https://css-
tricks.com/scale-svg/ abgerufen
Boz, J. (31. Dezember 2020). PlantUML Builder. Von GitHub:
https://github.com/jboz/plantuml-builder abgerufen
Niederhauser, S. (4. Januar 2021). graphviz-java. Von GitHub:
https://github.com/nidi3/graphviz-java abgerufen
Roques, A. (19. Dezember 2020). PlantUML. Von https://plantuml.com/ abgerufen
Roques, A. (31. Dezember 2020). PLantUML - Maven Repository. Von
https://repo1.maven.org/maven2/net/sourceforge/plantuml/plantuml/ abgerufen
Schäfers, S. (25. April 2018). Software-Aktualisierung. Von IT-Service.Network: https://it-
service.network/blog/2018/04/25/software-aktualisierung-veraltete-software/
abgerufen
Spinellis, D. (28. Oktober 2014). UMLGraph. Von
https://www.spinellis.gr/umlgraph/index.html abgerufen
Spinellis, D. (5. Oktober 2015). Class Diagram Options. Von UMLGraph:
https://www.spinellis.gr/umlgraph/doc/cd-oper.html abgerufen
Spinellis, D. (28. Dezember 2020). UMLGraph - GitHub. Von GitHub:
https://github.com/dspinellis/UMLGraph/ abgerufen
Winter, W., Briesemeister, R., Paquet, O., & Tietz, F. (22. Dezember 2020). Japedo. Von
http://www.logitags.com/japedo/ abgerufen
26Sie können auch lesen
