Modul-Entwicklung auf der NetBeans Rich-Client Plattform
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Dokumentation zur betrieblichen Projektarbeit
Fionn Ziegler - Fachinformatiker Fachrichtung Anwendungsentwicklung
Modul-Entwicklung auf der
NetBeans Rich-Client Plattform
Entwicklung eines dynamisch ladbaren Moduls zur Verwaltung
der Zugangsdaten für verschiedene Vergabeplattformen
© 2008 Administration Intelligence AG, Würzburg
Administration Intelligence AG Seite 2 von 37
Inhaltsverzeichnis
1 Vorwort 5
2 Einführung 6
2.1 Projektdefinition 6
2.2 Entscheidung für die NetBeans RCP 6
3 Grundbegriffe 8
3.1 NetBeans Rich-Client Plattform 8
3.2 System Filesystem 8
3.3 Package 9
3.4 Modul 9
3.5 Extension Points / Erweiterungspunkte 10
4 Projektkonzept / Zielsetzung 11
4.1 Projektziel 11
4.2 Konzeptphase 11
4.2.1 Modulkonzept 11
4.2.2 GUI-Konzept 12
4.2.2.1 Plattform-Übersichtstabelle 12
4.2.2.2 Plattform-Einstellungen 12
4.3 Persistenz 12
4.3.1 Java-DB 13
4.3.2 Hibernate und Java Persistence API 13
5 Implementierung 14
5.1 Datenbank 14
5.1.1 Peristenz NetBeans Modul 14
5.1.2 Datenmodell 14
5.2 Registrierung der TopComponent 14
5.3 GUI 16
5.4 Darstellung der Vergabeplattformen 16
5.4.1 PlatformTable 17
5.4.1.1 PlatformTableModel 17
5.4.1.2 PlatformTableCellRenderer 18
5.4.1.3 Mögliche Benutzer-Aktionen zum Öffnen des Plattform-Fensters 18
Administration Intelligence AG Seite 3 von 37
5.5 Auffinden der Modulimplementation 22
5.6 Webservice 24
5.6.1 Implementation serverseitig 24
5.6.2 Implementation clientseitig 25
5.7 Plattform Modul 25
5.7.1 Grafische Oberfläche (GUI) 26
5.7.2 Persistenz 26
6 Test 27
6.1 Modul-Auffindung 27
6.2 Persistenz-Test mit JUnit 27
7 Projektresumé 29
7.1 Soll-Ist-Vergleich 29
8 Literaturverzeichnis 30
9 Abbildungsverzeichnis 31
A. Glossar 32
B. Anhang 34
a) Skizzen 34
I. Übersichtstabelle 34
II. Plattform-Fenster 34
b) Klassendiagramm - PlatformOverview 36
c) Aktivitätsdiagramm 37
C. Erklärung 38
Administration Intelligence AG Seite 4 von 37
1 Vorwort
1 Vorwort
In der EU werden jährlich ca. 1,5 Billionen Euro für öffentliche Aufträge ausgegeben, das entspricht
etwa 15 % des Bruttoinlandsprodukts. Dadurch ist die elektronische Vergabe (Ausschreibung) eines der
wichtigsten Themen für Unternehmen im öffentlichen Sektor, die Produkte und Dienstleistungen zur
Ausschreibung anbieten. Potentielle Auftragsnehmer haben mit elektronischen Vergaben eine Reihe
von Möglichkeiten, komplexe Prozesse zu optimieren und damit Zeit und Kosten zu sparen.
1
Das Problem ist jedoch, dass zur Zeit eine Vielzahl von unterschiedlichen Vergabeplattformen
existieren und es pro Plattform auch nur eine spezielle Bietermanagement-Lösung gibt. Dadurch
ergeben sich mehrere Probleme. Eine effektive Recherche über mehrere Vergabeplattformen ist daher
schwierig bis unmöglich. Mitarbeiter der Unternehmen müssen mit unterschiedlichen Softwarelösungen
und inhomogenen Angebotsformaten arbeiten. Diese Nachteile sind sicherlich ein Grund dafür, dass
sich viele Unternehmen noch von dem Thema elektronische Vergabe fernhalten.
Die Firma Administration Intelligence AG (AI-AG) will deshalb durch eine modulare
Softwareanwendung Abhilfe schaffen. Anfang des Jahres hat die Planung und Entwicklung des
Angebotsassistenten angefangen, die es einem Ausschreibungsteilnehmer (Bieter) ermöglichen soll, mit
verschiedenen Vergabeplattformen zu kommunizieren und innerhalb eines elektronischen
Vergabeprozesses digitale Angebote abzugeben.
1 Eine Vergabeplattform ist eine Webseite, auf der Bieter bzw. Interessenten Vergabe-Informationen erhalten
können.
Administration Intelligence AG Seite 5 von 37
2 Einführung
2 Einführung
Rich Clients sind meist Frameworks, die durch Module und Plug-ins erweiterbar sind und auf denen die
eigentliche Verarbeitung der Daten auf dem Client vollzogen wird. Rich Client Plattformen bieten die
Möglichkeit, immer wiederkehrende Funktionen, insbesondere im Bezug der grafischen
Benutzeroberfläche, zu vereinfachen. Eine der bekanntesten Plattformen ist die auf Java basierende
NetBeans Platform (Rich Client Anwendungen werden im nächsten Kapitel näher erläutert).[Wiki08a]
2.1 Projektdefinition
Ziel meines Abschlussprojektes ist es, auf Basis der NetBeans Platform eine Art Kontenverwaltung für
die verschiedenen Vergabeplattformen zu entwickeln. Der Benutzer bekommt eine Übersicht über die
verschiedenen Vergabeplattformen sowie die Möglichkeit, die Zugangsdaten und
Verbindungsinformationen der Vergabeplattformen zu konfigurieren.
Das Projekt gliedert sich in ein zentrales Core Modul, sowie mehrere Plattform-Module. Weiterhin
können die Vergabeplattformen über einen Webservice abgerufen werden. Die Organisation der
Vergabeplattformen sowie das Vorhalten gemeinsamer Schnittstellen, wird vom Core-Modul
übernommen. Die Konfiguration der einzelnen Plattformen und dessen Zugangsdaten, sowie das
Editieren und Speichern der jeweiligen Kommunikationsdaten muss jedoch in den einzelnen Plattform-
Modulen geschehen, da diese sehr plattformspezifisch sein können. Weiterhin wird durch die strenge
Modularisierung gewährleistet, dass Plattform-Module für neue Vergabeplattformen ohne weiteres
implementiert werden können und somit die Funktionalität der Anwendung leicht erweitert werden
kann.
Das Projekt beinhaltet die Implementierung des Plattform-Moduls für die firmeninterne
Vergabeplattform (im folgendem „AIPlatform“ oder „Plattform-Modul“ genannt). Die Entwicklung
weiterer Plattform-Module würde den Zeitrahmen des Projektes sprengen.
2.2 Entscheidung für die NetBeans RCP
Ein wichtiger Punkt am Anfang der Planungs-Phase war die Wahl des passenden Frameworks, das
unseren Anforderungen entspricht. Bisher wurde in der AI-AG in der Entwicklungsumgebung Eclipse
programmiert. Auch der neue Angebotsassistent sollte anfangs in Eclipse, mit eigenem modularem
Framework (OSGI) und Rich Client Plattform (Eclipse-RCP), entwickelt werden. Einige Gründe
sprachen jedoch gegen den Einsatz dieser Kombination, unter anderem eine aufwändige Konfiguration
des modularen OSGI-Frameworks und außerdem die grafische Oberfläche SWT(Standard Widget
2
Toolkit) der Eclipse Rich Client Platform. Da alle firmeninternen Komponenten mit Swing entwickelt
3
wurden und diese nur über größere Umwege (über SWT-Swing bridge ) in die Rich Client Plattform
von Eclipse einzubinden sind, fiel die Entscheidung gegen OSGI & Eclipse.
2 Swing ist eine Hilfsbibliothek von SUN zur Erstellung von grafischen Oberflächen.
3 Eine Brücke, um Swing-Oberflächen in einer SWT-Applikation anzeigen zu können. Benötigt viel
Rechenleistung und Ressourcen.
Administration Intelligence AG Seite 6 von 37
2 Einführung
Die NetBeans Plattform hingegen bietet alle relevanten Merkmale, welche entscheidend für die Wahl
der NetBeans Plattform waren:
● Verkürzung der Entwicklungszeit
Durch zahlreiche NetBeans APIs für grafische Oberflächen, Persistenz und andere Standardsoftware-
Funktionalitäten, kann sich der Entwickler vollständig auf die Geschäftslogik der Anwendung
konzentrieren.
● Modularität / Wiederverwendbarkeit
Die Anwendung kann durch spätere Anforderungen/Kundenwünsche mittels PlugIns bzw. Module
erweitert werden, ohne Änderungen an der ganzen Software vorzunehmen. Module können mit einer
Zip-Datei (*.nbm 'NetBeans module') installiert werden, entweder lokal oder über das Netzwerk.
Außerdem kann die Software wie nach dem Baukasten-Prinzip, je nach Kundenwunsch bzw.
Finanzmodell, aus Modulen zusammen gebaut werden.
● Flexible grafische Oberfläche
Die NetBeans Rich-Client-Plattform erlaubt es, über eine XML-Datei (sog. Layer.xml) z.B. Menüs zu
bearbeiten oder das Look-and-Feel anzupassen. Außerdem bietet NetBeans die Möglichkeit, die
Oberflächen konsistent zu halten, wenn also ein User seine Komponenten innerhalb der Anwendung
verschiebt oder die Größe des Fensters anpasst, werden diese Informationen gespeichert und beim
nächsten Start der Anwendung wiederhergestellt.
● Swing
Im Gegensatz zu der RCP von Eclipse (OSGI), welche SWT als grafische Oberfläche benutzt, basiert
die NetBeans RCP auf Swing, genau wie unsere firmeninternen Bibliotheken.
● Plattform-Unabhängigkeit
4
Die NetBeans-Plattform kann auf allen Systemen benutzt werden, auf der eine JRE vorhanden ist.
4 Eine plattformspezifische Java Runtime Environment / Java Laufzeitumgebung beinhaltet eine Java Virtual
Machine, die den Java-Bytecode in Maschinencode übersetzt und dann ausführt.
Administration Intelligence AG Seite 7 von 373 Grundbegriffe
3 Grundbegriffe
Dieses Kapitel erklärt einige Begriffe, die Grundlage für das Verständnis der NetBeans Rich-Client
Plattform und insbesondere meines Projektes sind.
3.1 NetBeans Rich-Client Plattform
„The NetBeans Platform allows applications to be developed from a set of modular
software components called modules.“[Wiki08c]
Auf Basis der NetBeans Rich-Client Platform können Desktop-Anwendungen erstellt werden. Die
grundlegenden Anforderungen an eine Softwareanwendung wie z.B. Menüs, Toolbars,
Datenverwaltung, Hilfesystem, Einstellungen etc. können mit Hilfe der RCP vereinfacht implementiert
werden. Einer der wohl wichtigsten Aspekte der Rich-Client Plattform ist das Auffinden und
Verwalten bestimmter Modul-Implementierungen. Abbildung 1 zeigt eine Anwendung, in der nur die
Core-Module der NetBeans Platform geladen sind. Es kann durch eigenen Module erweitert werden,
wodurch später eine separat installierbare Anwendung entsteht.
Abbildung 1: RCP-Applikation ohne zusätzlich geladene Module
3.2 System Filesystem
Die Konfiguration der RCP-Anwendung erfolgt über ein virtuelles Dateisystem, das durch XML-
Dateien namens layer.xml beschrieben wird. Dies ist ein zentraler Speicher für die NetBeans
Konfiguration.
Administration Intelligence AG Seite 8 von 373 Grundbegriffe
Abbildung 2: Aufbau des
System Filesystem
Alle aktivierten/installierten Module melden ihre layer.xml im Konfigurations-System von NetBeans
('System Filesystem') an (siehe Abbildung 2). Aus allen „Layern“ ensteht dadurch eine XML-Datei, die
für die Konfiguration der RCP-Anwendung benutzt wird.
Im 'System Filesystem' werden beispielsweise die Toolbars aufgebaut, Menüpunkte erstellt und Actions
definiert. In meinem Projekt habe ich mittels der layer.xml ein Menü 'Einstellungen' mit Unterpunkt
'Plattformen' erstellt. Außerdem wird definiert, welche Standard-Menüs und Toolbar-Icons (siehe
Abbildung 1) nicht sichtbar sein sollen.
3.3 Package
Ein Package ist ein Mechanismus, um Klassen in Namensräume zu organisieren. Klassen mit ähnlicher
Funktionalität oder der gleichen Kategorie werden oft in einem
Namensraum zusammengefügt. [Wiki08d]
Außerdem erlaubt die Organisation in Packages, Sichtbarkeit von
Klassen und Methoden einzuschränken.
Ein Package repräsentiert ein Verzeichnis im Dateisystem. Eine
Klasse im selben Package muss stets eindeutig sein, das bedeutet,
dass Klassen auch den gleichen Namen haben können, solange sie
sich in verschiedenen Namensräumen (Packages) befinden.
Abbildung 3: Package
3.4 Modul
Im Gegensatz zu nicht-modularer Software, werden Funktionen einer modularen Applikation in
verschiedene Einheiten, repräsentiert durch Module, aufgeteilt. Dadurch können komplexe Programme
in relativ eigenständige Einheiten (Module) gegliedert werden. Ziel der modularen Entwicklung ist es
unter anderem, dem Prinzip der Abstraktion zu folgen. Eine Abstraktion beschreibt z.B. eine
Funktionalität, blendet jedoch die Details der Implementierung aus. Mit der Abstraktion können
verschiedene Problemstellungen, die in bestimmten Punkten gleich sind, zusammengefasst werden.
Bei der Betrachtung eines Moduls, bzw. eines „Clusters“ (Sammlung von Modulen), ist es wichtig, dass
einzelne Module bestimmte Funktionen eines Gesamtproblems übernehmen können. Also eine Art
Aggregation: Ein Modul ist Teil eines Ganzen, kann aber auch ohne das Ganze existieren. Dabei kann
ein Modul wiederum von anderen Modulen abhängig sein. Ziel ist es, Wiederverwendbarkeit und
Erweiterbarkeit auch bei komplexen Applikationen auf längere Zeit zu gewährleisten.[Gal02]
Administration Intelligence AG Seite 9 von 373 Grundbegriffe
Manchmal ist es sinnvoll, Packages nach außen hin sichtbar zu machen, damit andere Module auf diese
Klassen zugreifen können. Jedoch sollte vorsichtig damit umgegangen werden, weil es leicht
unübersichtlich werden kann, wenn zu viele direkte Abhängigkeiten zwischen Modulen bestehen.
In Java werden Module in Form von JAR-Bibliotheken dargestellt und bestehen gewöhnlich aus
folgenden Teilen:
● Manifest-Datei (manifest.mf)
● Layer-Datei (layer.xml) (NetBeans spezifisch)
● Java-Klassen
● Ressources (Icons, Properties, Bundles etc.)
In der NetBeans Terminologie gibt es keine fachlichen Unterschiede zwischen PlugIns und Modulen:
Sie werden beide eingesetzt, um eine Software dynamisch um bestimmte Features bzw. Dienste zu
erweitern. [Gal]
„As an aside: in NetBeans terminology, "plug-in" is an adjective while "module" is a
noun. There is no semantic difference between them„ [NBP]
3.5 Extension Points / Erweiterungspunkte
Extension Points sind dann sinnvoll, wenn ein Algorithmus, bzw. eine Funktionalität dynamisch
ausgetauscht oder erweitert werden soll.
In meinem Projekt verwende ich Extension Points, um den Vergabeplattform-spezifischen Quellcode
ansprechen zu können. Dies ist sinnvoll, da spätere Änderungen einer Plattform-Schnittstelle sich nicht
auf den Angebotsassistenten auswirken, sondern nur auf das spezifische Plattform-Modul.
Administration Intelligence AG Seite 10 von 374 Projektkonzept / Zielsetzung
4 Projektkonzept / Zielsetzung
4.1 Projektziel
Das Ziel meines Projektes ist es, die Möglichkeit zu schaffen, Vergabeplattformen bzw. deren Zugangs-
und Verbindungsdaten, dynamisch zu verwalten und anderen Modulen zugänglich zu machen. Konkret
sollen dem Bieter die Möglichkeiten geboten werden, verfügbare Vergabeplattformen in einem
Übersichts-Fenster einzusehen, die Liste verfügbarer Plattformen von einem Server via Webservice zu
synchronisieren und einzelne Plattformen zu konfigurieren.
Als komplex erweist sich dabei die Konfiguration unterschiedlicher Vergabeplattformen, denn jede
Plattform benötigt komplett unterschiedliche Verbindungsinformationen. Um das Programm dynamisch
erweiterbar zu halten, kommt das Modul-Konzept von NetBeans zum Einsatz. Dieses Konzept ist auch
für die Preisgestaltung der Software wichtig, denn der Bieter soll nur mit Vergabeplattformen
kommunizieren können, wenn er das entsprechende Modul erworben hat.
4.2 Konzeptphase
4.2.1 Modulkonzept
Es wurde ein Haupt-Modul (Core) angelegt, in dem Projekte, Angebote und Benutzer verwaltet werden
können. Dieses Modul wird benutzt, um eine Übersichtstabelle der verfügbaren Plattformen, die von
einem Webservice bereitgestellt werden, darzustellen. Jede Plattform hat einen bestimmten Typ, z.B.
'AIPlatform' oder 'eVergabe'. Durch diese ID wird der Plattform eine bestimmte Modul-
Implementierung zugeordnet. Für einen Vergabeplattform-Typ kann es mehrere Vergabeplattformen
geben. Beispielsweise gibt es die AI-Vergabeplattform – Hessen, oder die AI-Vergabeplattform – EZB.
Abbildung 4: Plattform-Module implementieren das Platform Interface
Administration Intelligence AG Seite 11 von 374 Projektkonzept / Zielsetzung
5
Konkret funktioniert es folgendermaßen: Klickt der Benutzer auf eine Plattform im Core-Modul , wird
über eine Hilfsklasse das entsprechende Modul gesucht und die Implementierung des Plattform-
Interfaces zurückgegeben. Ein Aktivitätsdiagramm zu diesem Vorgang befindet sich im Anhang (siehe
Abbildung 16).
4.2.2 GUI-Konzept
4.2.2.1 Plattform-Übersichtstabelle
Innerhalb der NetBeans Plattform ist es möglich, sogenannte TopComponents zu erstellen.
TopComponents sind Fenster (Inkl. Position, Größe usw.), welche von der Plattform verwaltet werden.
Der Aufbau wird in drei Bereiche getrennt: Im oberen Bereich ein Info Panel, im mittleren Bereich die
Tabelle mit den Plattformen und im unteren Bereich ein Panel für die Buttons.
Der rote Bereich hat eine statische Größe und ist immer sichtbar.
Der grüne Bereich (Tabelle der Vergabeplattformen) ist in einer
Scrollpane und somit dynamisch.
Als Info-Panel gibt es schon eine vorgefertigte Komponente der
Firma, die verwendet werden kann. Diese stellt einen
gewünschten Infotext mit passendem Icon und Layout dar.
Die Tabelle inkl. eigenem TableModel und TableCellRenderer
(werden jeweils im nächsten Kapitel erläutert) werden selbst Abbildung 5: Top-Komponenten
entwickelt. Genauso wie das Button-Panel mit den Layout
ActionListenern usw.
4.2.2.2 Plattform-Einstellungen
Wird in der Tabelle eine Plattform ausgewählt, öffnet sich ein Fenster, um die Plattform zu bearbeiten.
In diesem Fenster sollen Daten wie z. B. Username, Passwort, Host, Port, Protokoll usw. eingegeben
werden. Das Konfigurations-Panel soll in zwei Tabs - „Allgemein“ und „Erweitert“ unterteilt werden.
Dies soll dazu führen, dass unerfahrene Benutzer nicht überfordert werden und trotzdem eine flexible
Konfiguration gewährleistet wird.
Konzeptskizzen beider GUI-Komponenten befinden sich im Anhang.
4.3 Persistenz
„The Java Persistence API provides a POJO persistence model for object-relational
mapping.“ [JPA08]
Die Persistenz wird mit der Java-DB realisiert. Um eine Abbildung der Objekte auf Entitäten der
Datenbank zu bekommen, wird JPA (Java Persistence API) verwendet, welches ein leichtgewichtiges
Persistenz-Framework ist. Außerdem wird die Hibernate Implementierung der JPA verwendet. Mit
Hilfe von Annotationen in den POJO (Plain Old Java Object) Klassen und der JPQL (Java Persistence
Query Language) werden die entsprechenden Objekte mit kleinstmöglichem Aufwand persistiert.
Die Einbindung der Java-DB in unserer Software erfolgt mittels Hibernate und JPA. Ein großer Vorteil
der Java-DB ist es, dass sie nicht explizit installiert werden muss, sondern embedded in der Java-
5 Kernmodul des Angebotsassistenten.
Administration Intelligence AG Seite 12 von 374 Projektkonzept / Zielsetzung
6
Runtime ausgeführt wird. Dies ist ein großer Vorteil gegenüber herkömmlichen DBMS , denn der
Endbenutzer hat keinen administrativen Aufwand. [Unk02]
Ziel dieser Kombination ist es, dem Entwickler eine objektorientierte Sicht auf Tabellen und
Beziehungen in einer relationalen Datenbank zu bieten.
4.3.1 Java-DB
Hinter Java DB verbirgt sich das relationale Datenbank-Managementsystem (RDBMS) Derby. Derby
wird von SUN entwickelt und ist zu 100% in Java implementiert. Es funktioniert ganz nach dem Motto
„Write Once Run Anywhere“ auf jedem Betriebssystem, für das es eine JRE gibt. Außerdem ist die
Java DB sehr klein und schlank. Für die Embedded-Version, die im Projekt verwendet wird, ist keine
Installation der Datenbank notwendig, da diese beim ersten Aufruf der Datenbank automatisch
initialisiert wird.
4.3.2 Hibernate und Java Persistence API
JPA wurde mit dem Ziel entwickelt, die besten Eigenschaften aus verschiedenen Persistenz-
Frameworks zusammenfliessen zu lassen. Die JPA ist eine Schnittstelle von der Anwendung zum
eigentlichen Persistenz Framework (z.B. Hibernate). Der Anwendung ist es also egal, welches
Persistenz-Framework sich hinter der JPA verbirgt. Durch Leichtgewichtigkeit und Schlankheit ist es
besonders für Einzelplatzanwendungen geeignet. [Gal03]
Java-Annotationen in den POJO's vereinfachen es dem Entwickler, Objektrelationen abzubilden. Durch
JPQL (Java Persistence Query Language) muss auch kein Standard-SQL mehr angewandt werden. In
dem Plattform-POJO (PlatformData.java) verwende ich beispielsweise Annotationen, damit die
entsprechende Plattform-Tabelle nicht den Namen der Klasse hat, sondern den annotierten Namen:
@Entity(name = "Platform")
public class PlatformData
{
@Id
@GeneratedValue
private long iID;
private String name;
Die Annotation @ID besagt, dass die Klassen-Attribute 'iID' der PrimaryKey der Tabelle ist. Durch
@GeneratedValue wird automatisch ein zufälliger, eindeutiger Wert erzeugt.
Die JPQL-Abfrage, um alle Plattform Objekte von der Datenbank zu holen, ist dadurch folgende:
select p from Platform p
Es wird also nicht mehr mit den Relationen gearbeitet, sonder mit den Objekten. In der JPQL-Abfrage
könnte man beispielsweise auch auf Felder des Objektes zurückgreifen (z.B.: „WHERE p.name='AI' “).
6 Datenbankmanagementsystem
Administration Intelligence AG Seite 13 von 375 Implementierung
5 Implementierung
5.1 Datenbank
5.1.1 Peristenz NetBeans Modul
Um den Zugriff zur Datenbank zentral zu halten, gibt es ein zentrales Modul, das den Zugriff zur
Datenbank bereitstellt. Der Zugriff aus einem Modul erfolgt über die so genannte DAO-Schicht (Data
7
Access Objects Schicht). Diese kapselt den Zugriff auf die Datenbank. Aus dieser Schicht erfolgen die
JPQL-Anweisungen an den Entity-Manager von JPA.
5.1.2 Datenmodell
Aus der Plattformverwaltung (inkl. des AI-Plattform-Moduls) bildet sich folgendes Datenmodell:
Abbildung 6: ER-Modell
Tabellen Definition:
● Platform (Core-Modul)
z.B.:Vergabeplattform Frankfurt am Main vom Typ 'AIPlatform'
● AIPlatformConnection (Plattform-Modul)
Verbindungsdaten wie Port, Protokoll (http,https etc.) und Host zu einer Vergabeplattform. Pro
Plattform kann es auch immer nur eine Connection geben.
● Login (Plattform-Modul)
Beinhaltet Logindaten für eine Vergabeplattform.
● User (User-Modul)
User aus der lokalen Anwendung; ein User kann auf verschiedenen Plattformen jeweils ein
Login haben.
5.2 Registrierung der TopComponent
„...TopComponent is a JComponent subclass which knows how to work with the NetBeans
window system. If you want to add components to the main window, typically you will
subclass TopComponent, using it the same way you would a JPanel“
Um eigene Fenster in NetBeans zu entwickeln, stellt die Windows System API die Klasse
8
TopComponent zur Verfügung. Top-Komponenten können in verschiedenen 'Modes' installiert werden
und werden automatisch vom Window-Manager verwaltet. Der Window-Manager merkt sich jegliche
Anpassungen an der GUI und stellt sie bei jedem Start wieder her.
7 Trennung der Geschäftslogik von der Datenschicht.
8 Definiert die Position des Fensters.
Administration Intelligence AG Seite 14 von 375 Implementierung
Meine Klasse PlatformOverviewTopComponent ist von org.openide.windows.TopComponent
abgeleitet. Dabei können einige Methoden überschrieben werden, z.B. getName(), um dem Fenster
einen Titel zu geben oder componentOpened(), um eine bestimmte Aktion beim Öffnen des Fensters
auszuführen.
Ansonsten verhält sich das Fenster wie gewohnt, da die Klasse TopComponent wiederum von
JComponent abgeleitet ist.
Damit das Fenster erfolgreich geladen wird, kommt das 'System Filesystem' und die layer.xml zum
Einsatz. In der Layer-Datei wird die Komponente im Window-Manager angemeldet:
Das XML-Element „File“ repräsentiert ein Fenster, wovon es selbstverständlich auch mehrere geben
kann. Im Folder „Components“ wird festgelegt, um welchen Typ es sich bei der Komponente handelt.
Im Folder „Modes“ wird festgelegt, an welcher Position sich das Fenster befinden soll. Im Folder
„explorer“ wird die Komponente links an den Rand eingestellt. Außerdem gibt es noch zahlreiche
andere Modes wie z.B. „editor“, wenn das Fenster im „Hauptfenster“ angezeigt werden soll.
Um eine Top-Komponente zu erstellen, hilft die NetBeans IDE mit einem Wizard, der folgende Dateien
automatisch erstellt:
Datei Zweck
PlatformOverviewAction.java Eine Action, die das Fenster öffnet, wird
automatisch der layer.xml im Folder „Menu“
hinzugefügt. Dadurch wird ein Menüpunkt
angezeigt. Bei einem Klick darauf, wird die
Action-Klasse aufgerufen.
PlatformOverviewTopComponent.java Ist eine Sub-Klasse von der TopComponent und
soll das Plattformübersichts-Fenster beinhalten.
• PlatformOverviewTopComponentSettings.xml Diese beiden Dateien sind dafür da, um die Top-
• PlatformOverviewTopComponentWstcref.xml Komponente richtig zu instanziieren und zu
laden. Sie werden in der layer.xml registriert.
[Unk06]
Administration Intelligence AG Seite 15 von 375 Implementierung
5.3 GUI
Die Benutzeroberfläche wurde bewusst einfach, flexibel und intuitiv gehalten, um dem Benutzer die
Einarbeitungszeit zu verkürzen. Außerdem wurden alle Buttons mit dynamisch konfigurierbaren
Mnemonics (Tastenkürzel) versehen. Des Weiteren sind Informationen, die im Programm angezeigt
9
werden, in Properties-Dateien lokalisiert .
5.4 Darstellung der Vergabeplattformen
Das Übersichtsfenster (PlatformOverviewTopComponent.java) setzt sich aus folgenden Bestandteilen
zusammen:
Typ-Beschreibung (siehe Abbildung 7):
● ContentPane : JPanel
Ein Container für die drei anderen GUI-
Elemente. Als Layout-Manager habe ich das
BorderLayout gewählt, weil es für die
Anforderungen aus der Analyse-Phase am
besten geeignet ist.
● InfoPanel : JPanel
Firmeninterne Klasse zum Anzeigen von
Infopanels.
Position: BorderLayout.NORTH
● OverviewPanel : JScrollPane
Die PlatformTable wird in eine ScrollPane
gelegt, damit es möglich ist zu scrollen, falls
der Platz nicht ausreicht.
Position: BorderLayout.CENTER
Abbildung 7: Screenshot der TopComponent
● ButtonPanel : JPanel (Plattformübersicht)
Container für die Buttons der
Übersichtstabelle.
Position: BorderLayout.SOUTH
9 Locales sind einzelne Sätze oder Wörter, die in der Software in irgendeiner Weise angezeigt werden. Diese
werden ausgelagert, damit die Software auch mehrsprachig ausgeliefert werden kann.
Administration Intelligence AG Seite 16 von 375 Implementierung
5.4.1 PlatformTable
Die PlatformTable ist eine abgeleitete Klasse von XTable (firmeninterne Klasse mit einigen
Hilfsfunktionen), diese erbt wiederum von der Swing-Klasse JTable10.
5.4.1.1 PlatformTableModel
Die JTable benötigt ein Datenmodell, um die gewünschten Daten in der Tabelle anzuzeigen. Die eigene
Klasse PlatformTableModel erbt von der abstrakten Klasse AbstractTableModel. Beispielsweise kann
die Methode getColumnName(aColumn) mit der eigenen überschrieben werden. Dadurch können die
Spaltenüberschriften definiert werden:
(1)@Override
(2)public String getColumnName(int aColumn){
(3) switch (aColumn){
(4) case 0: //icon
(5) return " ";
(6) case 1: //Platformname
(7) return NbBundle.getMessage(PlatformTableModel.class, "Platform");
(8) default:
(9) return "";
(10) }
(11) }
Zeile Aktion
1-2 Annotation und Methodenkopf mit Spalte als Übergabeparameter
3 Switch-Case Anweisung zur Unterscheidung der Spalten.
4-5 Case 0 ist die erste Spalte mit dem Icon. Es wird ein Leerstring zurückgegeben, da keine
Überschrift nötig ist.
6-7 Case 1 soll die Überschrift der Vergabeplattform-Spalte besitzen. Der lokalisierte Wert für
den Key "Platform" wird zuzrückgegeben.
8-9 Dieser Fall sollte nicht auftreten, da es nur 2 Spalten gibt.
Außerdem werden weitere Methoden überschrieben:
Überschriebene Methode / Beschreibung
Definition
getRowCount Dynamischer Wert: Es wird die Anzahl der vorhandenen
PlatformData Objekte zurückgegeben.
- Liefert die Zeilenanzahl.
return iPlatformDataList.size();
getColumnCount Statischer Wert: Anzahl der vorhandenen Spalten wird
zurückgegeben.
- Liefert die Spaltenanzahl.
10 JTable ist eine Komponente von der Swing-Bibliothek, zur Darstellung von Tabellen.
Administration Intelligence AG Seite 17 von 375 Implementierung
return 2;
getValueAt(int rowIndex, int In dieser Methode wird wieder eine Fallunterscheidung der
columnIndex) Spalten (columnIndex) gemacht. Danach wird das PlatformData
Objekt an der Position der Zeile(rowIndex) geholt, und ein Wert
- Liefert den Wert einer Zelle. zurückgegeben.
case 0: //Spalte 1, icon
return iPlatforms.get(rowIndex).getURL();
case 1: //Spalte 2, name
return iPlatforms.get(rowIndex).getName();
5.4.1.2 PlatformTableCellRenderer
Ein TableCellRenderer wird benötigt, um auch andere Elemente (Icons, Textbox etc.) als nur reinen
Text in einer Tabelle darzustellen. Die erste Spalte in der Plattform-Tabelle soll das Icon der jeweiligen
Plattform beinhalten. Im TableModel wird den Zellen der ersten Spalte eine URL des Bildes
zugewiesen. Damit nicht die URL angezeigt wird sondern das Icon, wird folgende Methode von der
Super-Klasse DefaultTableCellRenderer überschrieben:
getTableCellRendererComponent(JTable table, Object value, boolean
aIsSelected, boolean hasFocus, int row, int column)
In der Super Methode wird der Zelle value.toString() zugewiesen, also die URL. Dies soll durch das
Überschreiben der Methode im eigenem CellRenderer verhindert werden. Damit das Icon angezeigt
wird, wird ein JLabel mit dem Icon zurückgegeben:
...
ImageIcon imageIcon = new ImageIcon(new URL(value.toString()));
tLabel.setIcon(imageIcon);
return tLabel;
5.4.1.3 Mögliche Benutzer-Aktionen zum Öffnen des Plattform-Fensters
11
Damit es der User im Bezug auf Usability so einfach wie möglich hat und evtl. auch die vom Benutzer
gewohnten Vorgänge zu ermöglichen, gibt es drei Möglichkeiten, um die Einstellungen der
Vergabeplattform zu öffnen. Als Hilfe zeigt folgendes Klassendiagramm (siehe Abbildung 8) den
Aufbau der Klassen und Interfaces der Tabelle, im Zusammenhang mit den jeweiligen
Benutzerinteraktionen. (siehe auch Abbildung 15: Klassendiagramm - PlatformOverview im Anhang).
11 Usability: Benutzerfreundlichkeit der Software.
Administration Intelligence AG Seite 18 von 375 Implementierung
Abbildung 8: Klassendiagramm PlatformTable
1. Möglichkeit PopUp-Menü (TablePopupMenuProvider)
Die Klasse PlatformTable implementiert das Interface TablePopupMenuProvider . Das
Interface deklariert diese Methode:
JPopupMenu getPopupMenu ( int aRow, int aColumn );
Die Implementation wird beim Initialisieren der Tabelle zugewiesen.
setTablePopupMenuProvider(this);
12
Bei einem Klick mit dem PopupTrigger weiß die Tabelle, an welche Klasse sie das Event
delegieren soll. Da die PlatformTable das Interface implementiert und der Tabelle mit
setTabePopupMenuProvider das aktuelle Objekt zugewiesen wird, wird das Event an die
PlatformTable weitergeleitet, in der es folgendermaßen behandelt wird:
12 Betriebssystem-spezifisches Maus-Event zum Öffnen des Kontextmenüs (Popup)
Administration Intelligence AG Seite 19 von 375 Implementierung
(1) public JPopupMenu getPopupMenu(final int aRow, int aColumn){
(2) JPopupMenu tPopupMenu = new JPopupMenu();
(3) JMenuItem tMenuItem= new
JmenuItem( NbBundle.getMessage(PlatformTable.class , "Details"),
(4) XButton.getDefaultButtonIcon(XButton.BUTTON_DETAILS));
(5) tMenuItem.addActionListener(new AbstractAction()
(6) {
(7) public void actionPerformed(ActionEvent e)
(8) {
(9) openPlatformDetails(iPlatforms.get(aRow));
(10) }
(11) });
(12) tPopupMenu.add(tMenuItem);
(13) return tPopupMenu;
(14) }
Zeile Aktion
1 Methodenkopf Deklaration mit Übergabeparametern(Zeile und Spalte der Tabelle).
2 Ein neues Kontextmenü wird erzeugt.
3-4 Ein Menüitem wird erzeugt und mit einem Locale als Beschriftung und einem Icon
versehen.
Die statische Methode Xbutton.getDefaultButtonIcon(XButton.BUTTON_DETAILS) liefert
das firmeninterne gängige Icon für einen Details-Button.
5-11 Dem Item wird eine Aktion hinzugefügt, welche die Methode openPlatformDetails mit
der gewählten Plattform als Parameter aufruft.
Diese Aktion ist in Form einer anonymen inneren Klasse implementiert. Dies bedeutet,
dass eine Sub-Klasse von AbstractAction erzeugt wird und durch die Methode
actionPerformed erweitert wird. Diese wird aufgerufen, wenn der Benutzer auf das
Popup-Menü-Item klickt.
12-13 Das Item tMenuItem wird dem Kontextmenü tPopupMenu hinzugefügt und
zurückgegeben.
2. Möglichkeit Doppelklick (MouseListener)
Außerdem besteht die Möglichkeit, den Dialog mit Doppelklick auf die gewünschte
Vergabeplattform zu öffnen. Dafür implementiert die Klasse PlatformTable das Interface
MouseListener. Bei jeglichem Klick auf die Tabelle wird die Methode mouseClicked
aufgerufen.
Administration Intelligence AG Seite 20 von 375 Implementierung
(1) public void mouseClicked(MouseEvent aMouseEvent){
(2) if (aMouseEvent.getButton() == MouseEvent.BUTTON1 &&
aMouseEvent.getClickCount() >= 2){
(3) int tClickedIndex = super.rowAtPoint(aMouseEvent.getPoint());
(4) if (tClickedIndex != -1){
(5) openPlatformDetails(iPlatforms.get(tClickedIndex));
(6) }}}
Zeile Aktion
1 Methodenkopf Deklaration mit dem Maus-Event als Parameter.
2 Auf Doppelklick prüfen
3 Die Methode rowAtPoint von der Super-Klasse JTable liefert die Zeilennummer, auf die
geklickt wurde.
4 Prüfe ob Zeile gefunden (liefert -1 wenn keine Zeile gewählt wurde).
5 Methode openPlatformDetails mit der gewählten Plattform als Parameter wird aufgerufen.
3. Möglichkeit Buttonpanel (ActionListener)
Der Dialog kann auch über das ButtonPanel geöffnet werden. Deswegen implementiert die
Klasse PlatformOverviewTopComponent das Interface ActionListener. Dem Button im Panel
wird der ActionCommand „details“ zugewiesen. Des Weiteren muss dem Button der
ActionListener hinzugefügt werden, damit er weiß, wem er das Event schicken soll. In diesem
Fall ist das die gleiche Klasse (this). Folgender Codeabschnitt zeigt die Behandlung des Events.
(1) public void actionPerformed(ActionEvent e){
(2) String tActionCommand = e.getActionCommand();
(3) if ("refresh".equalsIgnoreCase(tActionCommand))
(4) {...}
(5) else if ("details".equalsIgnoreCase(tActionCommand)){
(6) iTable.openPlatformDetails(iTable.getPlatforms().get(iTable.getSel
ectedRow()));
(7) }
Zeile Aktion
1 Methodenkopf Deklaration mit dem Action-Event als Parameter.
2 Variable tActionCommand mit dem als Parameter gegebenen ActionCommand
definieren. Dieser wird beim erstellen des Buttons definiert.
3-5 Abfrage auf verschiedene ActionCommands.
6 Methode openPlatformDetails mit der selektierten Plattform als Parameter wird
aufgerufen.
Administration Intelligence AG Seite 21 von 375 Implementierung
5.5 Auffinden der Modulimplementation
Die Methode openPlatformDetails(PlatformData aPlatformData) in PlatformTable soll das passende
13
Plattformmodul finden und den Dialog dazu öffnen. Dazu war es nötig, eine Singleton Klasse zu
entwickeln, die die Modulimplementation der passenden Plattform liefert. Wie es in Kapitel 4.2.1 auf
der Abbildung 4 ersichtlich ist, implementiert eine Klasse aus dem Plattformmodul das Interface im
Core-Modul.
Das Interface Platform deklariert die Methoden, die jedes Plattform-Modul implementieren muss.
Durch diese Abstraktion ist sichergestellt, dass sich die vorhandenen Plattformen an die Schnittstellen
halten und damit das Core-Modul Funktionen der einzelnen Module verwenden kann, ohne die
Implementierung der einzelnen Module kennen zu müssen. Damit ist eine unabhängige
Implementierung der Plattform-Module möglich.
Abbildung 9: Klassendiagramm Platform-Interface
Mit der Lookup API stellt NetBeans einen Mechanismus bereit, mit dem Anbieter Dienste registrieren
können und Konsumenten diese Dienste wieder finden können. [Jue08]
In diesem Fall ist es notwendig, dass verschiedene Anbieter (z.B AIPlatformImpl) einen Dienst (vom
Platform Interface) anbieten. Dadurch ist es gegeben, dass es für eine Schnittstelle mehrere
Implementationen gibt. Details bzw. die Implementation selbst, bleiben dem Konsumenten (Core-
Module) jedoch verborgen. Das Interface Platform im Core-Modul stellt somit ein Extension-Point dar,
an dem sich beliebig viele Module registrieren können.
Die Service-Provider bzw. die Anbieter (in dem Fall die Plattform-Module) müssen sich registrieren,
damit sie vom Lookup gefunden werden. Dazu wird im Plattform-Modul ein Ordner 'META-
INF/services' angelegt, mit einer Datei, die den kompletten Namen des Interfaces
13 Singleton bedeutet, dass die Klasse seine eigene Instanz hält und mit einer statischen Methode bereitstellt. Der
Konstruktor ist private um sicherzustellen, dass keine externe Klasse eine Instanz erzeugt. Dadurch gibt es
während der Laufzeit immer nur eine Instanz der Singleton-Klasse.
Administration Intelligence AG Seite 22 von 375 Implementierung
(de.sepp.offerassistant.core.api.Platform) hat. Der Inhalt der Datei hat den kompletten Namen der
Implementation (de.sepp.offerassistant.aiplatform.AIPlatformImpl). [Gal03]
Die Singleton-Klasse PlatformModuleFactory stellt die Methode findPlatformInstanceByImplID
bereit. Sie soll die Implementation von einem gegebenen Plattform-Typ zurückgeben. Praktisch heißt
das: Klickt der User auf eine Vergabeplattform, wird der Typ der Plattform (z.B.: „AIPlatform“)
mitgegeben und mit folgendem Algorithmus wird die Implementation gesucht:
(1)public Platform findPlatformInstanceByImplID(String aPlatformTypeID){
(2) Lookup.Template tTmpl = new Lookup.Template
(Platform.class);
(3) Collection5 Implementierung
Mit dem zurückgegebenem Objekt vom Typ Platform kann jetzt der Plattform-spezifische Dialog mit
der Methode showConnectionDetails(...) aufgerufen werden (siehe Kapitel 5.7).
5.6 Webservice
Die Kommunikation zwischen dem Angebotsassistenten und einem zentralem Server der
Administration Intelligence AG erfolgt via Webservice. Als Gründe dafür zählen beispielsweise die
zentrale Datenhaltung allgemeiner Informationen und die Bereitstellung verschiedener Funktionalitäten,
wie das Suchen nach Vergaben/Auschreibungen auf mehreren Vergabeplattformen.
Dadurch ist die Möglichkeit geschaffen, bessere Finanzmodelle einzubringen. Beispielsweise kann der
Benutzer alle Vergabeplattformen synchronisieren. Um diese jedoch benutzen zu können, benötigt er
das passende Plattform-Modul, welches er dann erwerben kann.
Durch die Anforderung des Projektes wurde der Webservice um die Methode 'getAllPlatforms'
erweitert, sie liefert alle Vergabeplattformen (PlatformData) und dessen Verbindungsinformationen
(ConnectionData) als XML.
Da die Synchronisation im Core-Modul stattfindet, können die PlatformData Objekte einfach in der
Datenbank persistiert werden. Die ConnectionData Objekte, die beim Abruf vom Webservice noch aus
reinem XML bestehen, werden an die installierten Plattform-Module weitergegeben. Nur diese wissen,
wie der XML-Content ausgewertet werden kann. Das bedeutet, dass das Core-Modul den XML-Content
einfach an die Plattform-Module weitergibt, ohne sie zu verändern bzw. zu verarbeiten. Im Plattform-
15
Modul wird der XML-Content dann deserialisiert und persistiert.
5.6.1 Implementation serverseitig
Die Vergabeplattformen werden von der Administration Intelligence AG gepflegt und befinden sich in
der Datenbank auf dem Server.
Um an die PlatformData Objekte (repräsentieren jeweils eine Vergabeplattform) zu kommen, wurde in
der DAO-Schicht eine weitere finder-Methode benötigt:
(1) public List findAllPlatforms() throws
DAOFinderException{
(2) try
(3) {
(4) Query tQ = getEntityManager().createQuery("select p from
PlatformData p");
(5) List tPlatforms = tQ.getResultList();
(6) return tPlatforms;
(7) }
(8) catch (Exception aException)
(9) {
(10) String tMessage = "Error in Platform.findAll()...";
(11) throw new DAOFinderException(tMessage, aException);
(12) }}
Sie ähnelt sehr der Methode der Klasse PlatformDAO im Core-Modul. Die Funktionalität ist auch
identisch, nur die Datenschicht ist eine andere.
15 Umwandlung von z.B. XML in ein Objekt.
Administration Intelligence AG Seite 24 von 375 Implementierung
Die Methode in der Webservice-Implementations-Klasse verwendet die Annotion @WebMethod, um
die Methode als eine Webservice-Methode zu kennzeichnen. Diese ruft einfach die DAO-Methode auf
und gibt das Ergebnis zurück:
(1)@WebMethod
(2)public List getAllPlatforms() throws
DAOFinderException
(3){
(4) return iDAO.findAllPlatforms();
(5)}
5.6.2 Implementation clientseitig
16
Durch hilfreiche Tools wie wsdl2java wird es mit Java sehr einfach gemacht, Clients für SOAP-JAX-
Webservices zu erstellen. Dementsprechend war auch die Implementation des Clients kein großer
Aufwand, da durch wsdl2java automatisch Hilfsklassen für den Webservice-Zugriff erstellt werden. In
der Klasse AIWebServiceInformationReceiver werden folgende vier Code-Zeilen ausgeführt, um alle
Vergabeplattformen vom Webservice abzurufen. Des Weiteren werden diese über die DAO-Schicht
persistiert.
(1)...
(2) PlatformServiceServiceLocator tLoc = new PlatformService
ServiceLocator();
(3) PlatformService tServ = tLoc.getPlatformServicePort();
(4) PlatformData[] tList = tServ.getPlatforms();
(5) getPlatformDAO().persistAll(tList);
(6)...
5.7 Plattform Modul
Aus dem Core-Modul wird nach dem Suchen des entsprechenden Plattform-Moduls die Methode
showConnectionDetails mit dem Parameter 'PlatformID' aufgerufen. Diese Methode ist in der Klasse
AIPlatformImpl implementiert. Die Funktionalität der Methode besteht darin, dass nach einem
vorhandenem persistiertem Datensatz anhand der 'PlatformID' gesucht wird und falls einer vorhanden
ist, wird er an die GUI weitergegeben.
Die einzelnen Plattform Module sind komplett unabhängig voneinander, das bedeutet, dass es möglich
ist, dynamisch zur Laufzeit weitere Plattform-Module zu installieren.
16 Generiert aus einem WSDl-Dokument (XML) Java-Sourcecode Klassen.
Administration Intelligence AG Seite 25 von 375 Implementierung
5.7.1 Grafische Oberfläche (GUI)
Das Fenster, in dem die Plattform-Konfiguration angezeigt wird, basiert auf Swing. Der Aufbau bildet
sich wie folgt:
Typ-Beschreibung (siehe Abbildung 10):
● ContentPane : JPanel
Layout: BorderLayout
● InfoPanel : JPanel
Firmeninterne Klasse zum Anzeigen von
Infopanels.
Position: BorderLayout.NORTH
● ConfigurationPane : JTabbedPane
Ist ein Container für verschiedene Seiten
mit mehreren Tabs.
Position: BorderLayout.CENTER
● TabContentPane : JPanel
Abbildung 10: Plattform-Fenster
Panel für den Inhalt der einzelnen Tabs.
● ButtonPane : JPanel
Panel für die Buttons.
Layout: BoxLayout (Vertikal)
Position: BorderLayout.SOUTH
Unter dem Tab 'Erweitert' (siehe Abbildung 11)
befinden sich Informationen über die
Kommunikation mit der Vergabeplattform (Host,
Port, Protokoll etc.).
Abbildung 11: Reiter 'Erweitert'
5.7.2 Persistenz
Die beiden Tabs 'Allgemein' und 'Erweitert' repräsentieren die GUI-Schicht der Java-Objekte
'LoginData' und 'AIPlatformConnectionData'. Diese beiden POJO's werden nach dem Klick auf „OK“
über die DAO-Methode perist(POJO) peristiert.
Da die Verbindungsdaten auch editierbar sind, aber auch wiederherstellbar sein sollen, werden die
Verbindungsdaten redundant gespeichert. Einmal in der Tabelle 'Platform' des Core-Module als XML-
String und einmal im Plattform-Modul als AIConnectionData Objekt. Dadurch kann der User, falls er
die entsprechenden Rechte besitzt, die Verbindungsinformationen 'AIConnectionData' bearbeiten.
Löscht der User versehentlich Daten, können die originalen Daten durch einen Standard-Button aus
dem Core-Modul wiederhergestellt werden.
Administration Intelligence AG Seite 26 von 376 Test
6 Test
6.1 Modul-Auffindung
Wenn das Produkt einmal produktiv wird, kann es bis zu 10 verschiedene Plattform-Module (und bis zu
40 Vergabeplattformen je Modul-Typ) geben, daher habe ich eine zweite „Dummy-Plattform“ erstellt.
Dadurch konnte die Modul-Auffindung usw. getestet werden.
Außerdem habe ich das dynamische Laden von Plattform-Modulen getestet, wodurch ich feststellen
konnte, dass eine entsprechende Fehlermeldung erscheint, wenn ein gesuchtes Modul nicht
aktiviert/installiert ist.
6.2 Persistenz-Test mit JUnit
Die Speicherung der PlatformData Objekte vom Webservice soll ein JUnit-Test automatisch testen.
Dabei werden die JUnit-Klassen und Dateien explizit von dem ausgelieferten Source-Code getrennt.
„»Once«, said Mock Object at last, with
a deep sigh, »I was a real object».“17
Die einzelnen Tests sollen so isoliert wie möglich ablaufen. Um dies zu gewährleisten, werden für die
18
Ausführung der zu testenden Klassen benötigten Infrastruktur-Objekte durch Mock-Objekte (auch
Platzhalter- oder 'Dummy'-Objekte genannt) simuliert. Beim Unit-Test der Persistenz wird die
Webserviceanbindung des Programmes durch solch ein Platzhalterobjekt ersetzt, da ein laufender
Webserver, eine Internetverbindung, sowie korrekte Daten nicht garantiert werden können. Innerhalb
der Tests sollen Objekte, die von dem Platzhalterobjekt kommen, gespeichert und wieder geladen
werden. Sind die Ergebnisse gleich, kann davon ausgegangen werden, dass die Persistenzschicht
korrekt funktioniert.
Einzelne Tests werden in der Test-Klasse TestPlatformPersistence, die von junit.framework.TestCase
abgeleitet ist, implementiert.
17 Zitat aus http://www.dpunkt.de/leseproben/3-89864-325-5/Kapitel_6.pdf
18 Diese werden normalerweise, während der Ausführung der Softwareanwendung, automatisch erstellt.
Administration Intelligence AG Seite 27 von 376 Test
(1)/**
(2) * Test persistence
(3) */
(4) @Test
(5) public void testGetPlatformDataList() {
(6) System.out.println("persistence test with Platform objects");
(7) PlatformDAO.deletePlatformData();
(8) List expResult =
AIWebServiceInformationReceiver.getInstance().getPlatforms();
(9) PlatformDAO.insertPlatformData(expResult);
(10) List result = PlatformDAO.getPlatformDataList();
(11) assertEquals(expResult, result);
(12)}
Zeile Aktion / Beschreibung
1-3 Java-Dokumentation der Methode(Javadoc).
4 JUnit-Annotation, damit die Methoden als Test-Methode deklariert wird.
5 Methodenkopf ( )
7 Alle Plattformen aus der Datenbank löschen.
8 Liste von Platform-POJO's wird vom Webservice geholt und in der temporären Variable
expResult (engl.: expected result) zwischengespeichert.
9 Speichern der PlatformData Objekten in der Datenbank.
10 In dieser Zeile werden die Plattform-Objekte wieder aus der Datenbank geholt und in der
Variable result gespeichert.
11 Mit der Methode assertEquals wird geprüft, ob das Ergebnis (result) dem erwarteten
Ergebnis (expResult) entspricht.
Durch ein gute Einbindung des JUnit-Frameworks in NetBeans können Unit-Tests sehr komfortabel
geschrieben und ausgewertet werden. Weiterhin werden die bestehenden Tests in Test-Suites
organisiert, wodurch die komplette Anwendung in regelmäßigen Abständen automatisch getestet
werden kann.
Abbildung 12: JUnit Testergebnis
Administration Intelligence AG Seite 28 von 377 Projektresumé
7 Projektresumé
7.1 Soll-Ist-Vergleich
Zeit
Projektphasen Aufgaben Soll Ist
Analysephase ● Durchführung einer Soll-Analyse und Besprechung 8 11
der Schnittstellen
● Plug-in Details
● Anforderung an die GUI
● Datenpersistenz
● Analyse der NetBeans Platform
Implementierungsphase ● Plug-in Gerüst anlegen/entwickeln 44 41
● Allgemeine Programmlogik
● Eingabemasken erstellen
● Webservice serverseitig
● Webservice clientseitig
● Persistenz
Testphase ● Testen des separaten Moduls 5 5
● Persistenz-Test
● Webservice-Test
● Testen im Angebotsassistent (White-Box-Test)
Dokumentation ● Erstellen der Projektdokumentation 13 13
70 70
Grund für die Abweichungen der zeitlichen Faktoren in der Analysephase, ist die etwas aufwändige
Einarbeitung in die NetBeans Plattform sowie die teilweise schlecht dokumentierte API. Durch die
relativ einfache Einbindung und Entwicklung des Webservices hat die Implementierungsphase 3 Std.
weniger gedauert.
Administration Intelligence AG Seite 29 von 378 Literaturverzeichnis 8 Literaturverzeichnis • [Wiki08a] Unknown, Fat Client, http://de.wikipedia.org/wiki/Rich-Client • [Wiki08c] Unknown, NetBeans, „The NetBeans Platform allows applications to be developed from a set of modular software components called modules.“ • [Wiki08d] Wikipedia, Java package, http://en.wikipedia.org/wiki/Java_package • [Gal02] Kathrin Hilz, Analyse der Netbeans Rich Client Plattform • [Gal] Bernhard Lahres, Gregor Raýman, Praxisbuch Objektorientierung, http://www.galileocomputing.de/openbook/oo/oo_06_moduleundarchitektur_000.htm • [NBP] Unknown, NetBeans Platform, http://platform.netbeans.org/tutorials/60/nbm- feedreader_background.html • [JPA08] Unknown, Java Persistence API, http://java.sun.com/javaee/technologies/persistence.jsp • [Unk02] Unknown, JavaDB / Derby Grundlagen, http://scherer- it.ch/java/javadb_grundlagen.html • [Gal03] Heiko Böck, NetBeans Platform 6 • [Unk06] Unknown, DeveloperDocumentation, http://wiki.netbeans.org/DeveloperDocumentation • [Jue08] Jürgen Petri, NetBeans RCP - Das Entwicklerheft • [Wap08] Wapedia, Annotation (Java), http://wapedia.mobi/de/Annotation_(Java) • [wiki08] Wikipedia® , JAX-WS, http://de.wikipedia.org/wiki/JAX-WS • [Wiki08b] Unknown, OSGI, http://de.wikipedia.org/wiki/OSGi • [Tor05] Torsten Horn, SOAP, http://www.torsten-horn.de/techdocs/soap.htm Administration Intelligence AG Seite 30 von 37
9 Abbildungsverzeichnis 9 Abbildungsverzeichnis Abbildung 1: RCP-Applikation ohne zusätzlich geladene Module...........................................................8 Abbildung 2: Aufbau des System Filesystem...........................................................................................9 Abbildung 3: Package...............................................................................................................................9 Abbildung 4: Plattform-Module implementieren das Platform Interface................................................11 Abbildung 5: Top-Komponenten Layout................................................................................................12 Abbildung 6: ER-Modell........................................................................................................................14 Abbildung 7: Screenshot der TopComponent (Plattformübersicht)........................................................16 Abbildung 8: Klassendiagramm PlatformTable......................................................................................19 Abbildung 9: Klassendiagramm Platform-Interface...............................................................................22 Abbildung 10: Plattform-Fenster............................................................................................................26 Abbildung 11: Reiter 'Erweitert'.............................................................................................................26 Abbildung 12: JUnit Testergebnis..........................................................................................................28 Abbildung 13: Skizze: Plattformübersichts-Dialog................................................................................34 Abbildung 14: Skizze Plattform-Dialog.................................................................................................35 Abbildung 15: Klassendiagramm - PlatformOverview...........................................................................36 Abbildung 16: Aktivitätsdiagramm - Plattform-Fenster anzeigen..........................................................37 Administration Intelligence AG Seite 31 von 37
9 Abbildungsverzeichnis
A. Glossar
Abstraktion Abstraktion bedeutet die Reduktion eines Problems auf relevante
Informationen und das Weglassen unwichtiger Details.
API(Application Eine Programmierschnittstelle zu anderen Bibliotheken.
Programming Interface)
Annotationen Ein Annotation-Processor ist ein Compiler-Plugin, das
Annotationen (Metainformationen) beim Compilieren auswerten kann,
um damit Warnungen und Fehlermeldungen zu unterdrücken oder
weiteren Quellcode bzw. andere Dateien zu generieren. [Wap08]
BorderLayout Das BorderLayout ist ein Layoutmanager, welcher dazu dient
Komponenten wie Buttons, Eingabefelder, Panels usw. in einer
bestimmten Art und Weise anzuordnen. Mit diesem Layoutmanager ist
es möglich, die Komponenten nach Himmelsrichtungen, wie SOUTH,
WEST, EAST usw., anzuordnen.
Entität Als Entität bezeichnet man in der Informatik ein eindeutig
bestimmbares Objekt. Im Bezug auf Datenbanken repräsentiert dieses
Objekt einen Datensatz, der meist einmalig ist.
GUI Graphical User Interface = grafische Benutzeroberfläche
Interface Ein Interface zu Deutsch: Schnittstelle, definiert Methoden (Name,
Rückgabetyp, Parameter usw.), die aber von anderen Java-Objekten
implementiert werden.
JAX-WS „JAX-WS (Java API for XML - Web Services) wurde in der Java
Platform Enterprise Edition 5 eingeführt und ist eine Java API zum
Erstellen von Web Services. Wie andere Java EE APIs benutzt auch
JAX-WS Annotationen, um die Entwicklung und das Deployment von
Web Service Clients und Service Endpunkten zu
vereinfachen.“[wiki08]
JUnit JUnit ist ein Framework, mit dem es möglich ist, Tests von
Programmeinheiten (Module) zu entwicklen und durchzuführen.
Es wird ein Test mit vordefinierten Werten gestartet, welches ein
bestimmtes Ergebnis erwartet.
Administration Intelligence AG Seite 32 von 37Sie können auch lesen
