Modul-Entwicklung auf der NetBeans Rich-Client Plattform

Die Seite wird erstellt Sam Gottschalk
 
WEITER LESEN
Modul-Entwicklung auf der NetBeans Rich-Client Plattform
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
Modul-Entwicklung auf der NetBeans Rich-Client Plattform
Administration Intelligence AG   Seite 2 von 37
Modul-Entwicklung auf der NetBeans Rich-Client Plattform
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
Modul-Entwicklung auf der NetBeans Rich-Client Plattform
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
Modul-Entwicklung auf der NetBeans Rich-Client Plattform
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
Modul-Entwicklung auf der NetBeans Rich-Client Plattform
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
Modul-Entwicklung auf der NetBeans Rich-Client Plattform
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 37
3 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 37
3 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 37
3 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 37
4 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 37
4 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 37
4 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 37
5 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 37
5 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 37
5 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 37
5 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 37
5 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 37
5 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 37
5 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 37
5 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 37
5 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 37
5 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) Collection
5 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 37
5 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 37
5 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 37
6 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 37
6 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 37
7 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 37
8 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 37
Sie können auch lesen