Ticketline RCP

Ticketline RCP – Getting Started Guide
Wolfgang Gruber
Ticketline RCP
Getting Started Guide
Version 1.1
(03. April 2010)
1 / 33
Ticketline RCP – Getting Started Guide
Inhaltsverzeichnis
Einleitung...................................................................................................................................3
Installation.................................................................................................................................4
Voraussetzungen..........................................................................................................................4
Eclipse.........................................................................................................................................4
Subclipse.....................................................................................................................................6
ReviewClipse..............................................................................................................................7
Ticketline RCP............................................................................................................................9
Frameworks & Bibliotheken....................................................................................................11
Struktur von Ticketline RCP....................................................................................................12
Entity-Package.........................................................................................................................13
DAO-Package...........................................................................................................................14
Transaktionsmanagement..........................................................................................................15
Validierung................................................................................................................................16
Query Builder............................................................................................................................17
Log-Package.............................................................................................................................20
log4j-Wrapper...........................................................................................................................20
EclipseRcpLogAppender..........................................................................................................21
Kassa-Package.........................................................................................................................23
Anhang A: Links......................................................................................................................25
Eclipse RCP & SWT/JFace.......................................................................................................25
Java Persistence API (JPA).......................................................................................................26
Anhang B: FindBugs................................................................................................................27
Anhang C: Frequently Asked Questions.................................................................................29
Glossar.....................................................................................................................................32
2 / 33
Ticketline RCP – Getting Started Guide
Einleitung
Ticketline RCP bildet das Grundgerüst für die Gruppenphase von SEPM. Es handelt sich
dabei um ein vorkonfiguriertes Projekt für Eclipse. Dies ermöglicht Ihnen die Entwicklung
sofort mit einer vollständig lauffähigen Applikation zu beginnen, ohne sich mit dem
Projektsetup beschäftigen zu müssen. Darüber hinaus wurden bereits einige Funktionen
implementiert, um Ihnen das Zusammenspiel der einzelnen Komponenten zu
demonstrieren.
Dieser Guide soll Ihnen bei den ersten Schritten mit Ticketline RCP helfen. Er beginnt mit
einer Installationsanleitung und stellt Ihnen im Anschluss die einzelnen Packages von
Ticketline RCP vor, sowie deren Anwendung innerhalb der Applikation vor. Im Anhang
finden Sie eine umfangreiche Linksliste, die Sie bei der Einarbeitung in die Technologien
von Ticketline RCP unterstützen soll.
Wir sind bemüht diesen Guide so gut wie möglich an die Bedürfnisse der Studenten
anzupassen. Dazu benötigen wir jedoch Ihre Hilfe. Wenn Sie Anregungen, Fehler oder
Kritikpunkte gefunden haben, so zögern Sie bitte nicht sie uns mitzuteilen. Entweder über
Ihren Tutor oder per Mail an sepm (at) inso.tuwien.ac.at .
Viel Spaß und gutes Gelingen mit Ticketline RCP
3 / 33
Ticketline RCP – Getting Started Guide
Installation
Voraussetzungen
Voraussetzung für Ticketline RCP ist die Installation des Java 6 SDKs. Sie können sich das
Installationspaket von der Java Website herunterladen.
Eclipse
Laden Sie von http://www.eclipse.org/downloads/ die Eclipse for RCP/Plug-in
Developers IDE herunter und entpacken Sie sie in ein beliebiges Verzeichnis.
In Eclipse müssen Sie nun EclipseLink und Dali nachinstallieren. Gehen Sie dazu in
Eclipse auf Help → Install New Software...
Wählen Sie unter Work with: Galileo - http://download.eclipse.org/releases/galileo
4 / 33
Ticketline RCP – Getting Started Guide
Abbildung 1: Installation zusätzlicher Komponenten
Wählen Sie folgende Punkte aus:
EclipseRT Target Platform Components
EclipseLink JPA
Web, XML, and Java EE Development
Dali Java Persistence Tools
Dali Java Persistence Tools – EclipseLink Support (Optional)
und installieren Sie die gewählten Komponenten.
Nachdem bei Ticketline RCP ausschließlich mit SWT und JFace gearbeitet wird, können in
der Code Completion die Packages java.awt und javax.swing ausgeblendet werden, um
während der Entwicklung nicht zu stören. Dieser Schritt ist optional.
Die Einstellungen finden Sie unter Window → Preferences → Java → Appearance → Type
Filters.
5 / 33
Ticketline RCP – Getting Started Guide
Abbildung 2: AWT- und Swing-Klassen ausblenden
Fügen Sie mittels Add Packages... die Packages java.awt und javax.swing hinzu.
Subclipse
Gehen Sie zur Installation von Subclipse in Eclipse auf Help → Install New Software... und
legen Sie über den Add...-Button eine neue Update Site mit folgenden Daten an:
Name:
Subclipse
Location:
http://subclipse.tigris.org/update_1.6.x
Abbildung 3: Update Site für Subclipse
6 / 33
Ticketline RCP – Getting Started Guide
Wählen Sie die drei angezeigten Punkte aus und installieren Sie Subclipse, in dem Sie den
Next-Button anklicken.
Abbildung 4: Subclipse Installation
ReviewClipse
Legen Sie in Eclipse auf Help → Install New Software... eine neue Update Site mit
folgenden Daten an:
Name:
Location:
ReviewClipse
http://www.inso.tuwien.ac.at/projects/reviewclipse/update-site
Abbildung 5: ReviewClipse Update Site
Wählen Sie unter der Kategorie ReviewClipse die beiden Punkte aus:
7 / 33
Ticketline RCP – Getting Started Guide
ReviewClipse
ReviewClipse Subclipse Adapter
und führen Sie die Installation durch.
Abbildung 6: ReviewClipse Installation
8 / 33
Ticketline RCP – Getting Started Guide
Ticketline RCP
Als ersten Schritt müssen Sie Ticketline RCP unter Eclipse importieren. Wählen Sie dazu
File → Import... → General → Existing Projects into Workspace.
Abbildung 7: Ticketline RCP Projekt importieren
Unter Select archive file wählen Sie die Ticketline RCP Zip-Datei und importieren das
Projekt mit Finish.
Starten Sie nun aus dem Ticketline RCP-Verzeichnis im Workspace die Ticketline
Datenbank über folgenden Befehl:
java -cp lib/hsqldb-1.8.1.1.jar org.hsqldb.Server -database.0 db/ticketline
-dbname.0 ticketline
9 / 33
Ticketline RCP – Getting Started Guide
Die Datenbank wird dabei im Unterverzeichnis db erstellt.
Ticketline RCP kann nun über einen Rechtsklick auf das Projekt und Run As → Eclipse
Application gestartet werden. Wenn Sie unter MacOS X entwickeln, beachten Sie bitte den
zusätzlichen Konfigurationshinweis in den FAQs.
Führen Sie in der „Künstler suchen“-View auf der linken Seite eine Suche durch. Dadurch
werden die Tabellen in der Datenbank automatisch angelegt. Die Suche liefert zu diesem
Zeitpunkt natürlich noch keine Ergebnisse zurück. Beenden Sie nun die Applikation
wieder.
Starten Sie den Datenbankmanager mit dem folgenden Befehl:
java -cp lib/hsqldb-1.8.1.1.jar org.hsqldb.util.DatabaseManager -url
jdbc:hsqldb:hsql://localhost/ticketline -user sa
Im Datenbankmanager muss nun die Datei db-bugfix.sql ausgeführt werden, die eine
Korrektur bei den automatisch erstellten Tabellen vornimmt. Sollten Sie die Tabellen zu
einem späteren Zeitpunkt neu erstellen, so müssen Sie immer diese Datei einspielen, um
Fehler in der Applikation zu vermeiden. Siehe hierzu auch die FAQ im Anhang.
10 / 33
Ticketline RCP – Getting Started Guide
Frameworks & Bibliotheken
Wie jedes größere Projekt in Java setzt auch Ticketline RCP eine Reihe von Frameworks
und Bibliotheken ein. Die nachfolgende Tabelle stellt sie kurz vor:
Eclipse RCP
Framework für die Entwicklung von Desktop Applikationen
Website:
http://wiki.eclipse.org/index.php/Rich_Client_Platform
EclipseLink
Dient zur Speicherung von Entitäten in der Datenbank
Website: http://www.eclipse.org/eclipselink/
Hibernate Validator
Dient zur Validierung der Entitäten
Website: https://www.hibernate.org/412.html
Log4J
Logging Bibliothek
Website: http://logging.apache.org/log4j/1.2/index.html
MigLayout
(optional)
Ein alternativer Layout-Manager
Website: http://www.miglayout.com/
XStream
(optional)
Eine Bibliothek zur De-/Serialisierung von Objekten in bzw aus
XML. Kann für den Im- und Export verwendet werden.
Website: http://xstream.codehaus.org/
11 / 33
Ticketline RCP – Getting Started Guide
Struktur von Ticketline RCP
Die folgende Abbildung zeigt die Packages von Ticketline RCP. Um die Darstellung zu
vereinfachen wurden einige transitive Import-Beziehung weggelassen. So importiert z.B.
at.ticketline.dao auch die Packages at.ticketline.dao.interfaces und at.ticketline.entity.
Abbildung 8: Paket-Diagramm von Ticketline RCP
In den weiteren Kapiteln werden die einzelnen Packages, sowie ihre Verwendung
detailliert dargestellt.
12 / 33
Ticketline RCP – Getting Started Guide
Entity-Package
Das Entity-Package enthält alle Entitäten von Ticketline. Das nachfolgende UMLKlassendiagramm zeigt deren Beziehungen:
Abbildung 9: Entitäten in Ticketline RCP
13 / 33
Ticketline RCP – Getting Started Guide
DAO-Package
Das Dao-Package, sowie alle Subpackages implementieren den Data Access Layer für
Ticketline RCP. Es handelt sich dabei um eine vereinfachte Variante des DAO-Patterns wie
es unter in den Core J2EE Patterns von Sun1 beschrieben ist.
Das folgende vereinfachte UML-Klassendiagramm zeigt die Vererbungshierarchie
innerhalb des Dao-Packages am Beispiel der Entität Artikel:
Abbildung 10: Vererbung innerhalb des Dao-Package
Jedes DAO besteht aus einem Interface aus dem Package at.ticketline.dao.interfaces, das
die Methoden definiert, sowie der zugehörigen Implementierung im Package
at.ticketline.dao.jpa. Als Persistenz-Framework wird dabei EclipseLink eingesetzt.
EclipseLink ist eine die Implementierung der Java Persistence API (JPA), dem offiziellen
Standard für Persistenz in der Java Enterprise Edition (Java EE).
Das DAO-Package enthält außerdem eine Implementierung eines generischen DAOs
(GenericDao und GenericDaoJpa) mit den wichtigsten Zugriffsmethoden. Die
Beschreibung dieser Methoden befindet sich im Javadoc des Interface GenericDao.
1 DAO Pattern: http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html
14 / 33
Ticketline RCP – Getting Started Guide
Um eine DAO verwenden zu können, muss sie mittels der Klasse DaoFactory erzeugt
werden:
ArtikelDao artikelDao =
(ArtikelDao) DaoFactory.findDaoByEntityName(Artikel.class);
Die DaoFactory sorgt dafür, dass das DAO instanziert und richtig initialisiert wird, in dem
die mit @PostConstruct annotierte Methode aufgerufen wird. Außerdem erweitert es das
DAO um Exception Wrapping, deklarative Transaktionen und das Handling des
EntityManagers, so dass dieser automatisch zur Verfügung steht.
DAOs sind nicht thread-safe, d.h. in jedem Thread, in dem eine DAO benötigt
wird, muss diese über die DaoFactory erzeugt werden.
Durch das Exception Wrapping werden von allen Methoden nur Exceptions vom Typ
DaoException zurückgegeben. Dies soll verhindern, dass Exceptions aus unteren Schichten
(zB SQLExceptions) in höheren Schichten auftauchen. Sollte trotzdem die ursprüngliche
Exception benötigt werden, kann diese über die Methode getCause ermittelt werden.
Bei der Entwicklung Ihrer Applikation werden Sie eigene Zugriffsmethoden benötigen.
Diese Methoden müssen im jeweiligen Interface (zB ArtikelDao) definiert und in der
Implementierung (zB ArtikelDaoJpa) implementiert werden.
Transaktionsmanagement
Durch die DaoFactory unterstützen die DAOs deklaratives Transaktionsmanagement. Um
eine Methode der DAO in einer Transaktion auszuführen, genügt es die Annotation
@Transactional auf der jeweiligen Methode im Interface zu setzen. Ein Beispiel hierfür
wäre die Methode persist(E entity) im Interface GenericDao. Bevor diese Methode
aufgerufen wird, wird eine Transaktion gestartet oder falls bereits eine Transaktion aktiv
ist, wird diese weiterbenutzt. Nach Aufruf der Methode wird die Transaktion automatisch
committed oder wenn von der Methode eine Exception geworfen wird, ein Rollback
durchgeführt.
Soll sich eine Transaktion über mehrere Aufrufe von DAO-Methoden erstrecken, muss das
Transaktionsmanagement im Code erfolgen. Dies geschieht mit Hilfe der Klasse
EntityManagerUtil, die die statischen Methoden startTransaction, commitTransaction und
rollbackTransaction anbietet. In diesem Fall werden die Transactional-Annotationen
15 / 33
Ticketline RCP – Getting Started Guide
ignoriert und die Transaktion erst mit commitTransaction abgeschlossen.
ArtikelDao artikelDao =
(ArtikelDao)DaoFactory.findDaoByEntity(Artikel.class);
BestellungDao bestellungDao =
(BestellungDao) DaoFactory.findDaoByEntity(Bestellung.class);
EntityManagerUtil.startTransaction();
artikelDao.persist(artikel);
bestellungDao.persist(bestellung);
EntityManagerUtil.commitTransaction();
Validierung
Die Methoden persist(Entity e) und merge(Entity e) führen vor dem Speichern eine
Validierung der übergebenen Objekte durch. Der DAO-Layer von Ticketline setzt dazu
Hibernate Validator2 als Bibliothek ein, die wiederum den Standard JSR-303 Bean
Validation3 umsetzt.
Die Constraints, die definieren, wann ein Wert als gültig anzusehen ist und wann nicht,
werden in Form von Annotationen in den Entitäten gespeichert. In Ticketline werden nur
die Standardannotationen des JSR-303 verwendet, die alle aus dem Package
javax.validation.constraints stammen.
Sollte ein Objekt ungültig sein, so werfen die Methoden persist und merge eine
ConstraintViolationException. Aus dieser können die einzelnen Fehler ausgelesen werden
wie der nächste Code-Abschnitt zeigt:
try {
artikelDao.persist(artikel);
} catch (ConstraintViolationException e) {
for (ConstraintViolation<?> cv : e.getConstraintViolations()) {
System.out.println(cv.getPropertyPath() + " " +
cv.getMessage());
2 Hibernate Validator: https://www.hibernate.org/412.html
3 JSR-303 Bean Validation: http://www.jcp.org/en/jsr/detail?id=303
16 / 33
Ticketline RCP – Getting Started Guide
}
}
Sollten Sie selbst ein Objekt validieren müssen, so können Sie mittels DaoFactory auf den
Validator zugreifen:
Validator validator = DaoFactory.getValidator();
Set<ConstraintViolation<Artikel>> violations = validator.validate(artikel);
Query Builder
Das Entwickeln von dynamischen Abfragen, wie sie zum Beispiel bei einer Suche nach
mehreren Kriterien erforderlich ist, erweist sich in der Praxis als relativ aufwändig und
gleichzeitig auch als fehleranfällig.
In Ticketline RCP gibt es daher einen Query Builder, der die Entwicklung von
dynamischen Abfragen in JPQL vereinfachen soll. Er bedient sich dabei eines Konzepts
namens Fluent Interface4, bei dem Methodennamen an natürliche Sprache angelehnt sind
und die Methodenaufrufe aneinandergekettet werden, so dass sich einfach zu lesende
Statements ergeben.
Das folgende Beispiel stammt aus KuenstlerJpaDao und zeigt den Aufbau einer Query:
QueryBuilder qb = QueryBuilder.build()
.select("k")
.from("Kuenstler k")
.whereAnd(nachname, vorname, geschlecht)
.orderBy("k.nachname ASC");
Die Methoden select, from, groupBy und groupBy erhalten als String die jeweiligen Teile
des Statements übergeben. Mit dem nachfolgenden Aufruf wird die eigentliche JPQLQuery erzeugt. Dabei werden alle Parameter automatisch gesetzt (wie weiter unten noch
genauer beschrieben wird):
4 Fluent Interface: http://www.martinfowler.com/bliki/FluentInterface.html
17 / 33
Ticketline RCP – Getting Started Guide
Query query = qb.createQuery(this.entityManager);
List<Kuenstler> kuenstler = (List<Kuenstler>)query.getResultList();
Mittels Aufruf von qb.createQueryString() kann die erstellte Query auch als String
zurückgegeben werden. Dies kann beim Debugging oder Logging genutzt werden.
Der sicherlich interessanteste Teil am Query Builder sind jedoch die Expressions, mit
deren Hilfe sich auf einfache Art und Weise die WHERE-Clauses erstellen lassen. Es gibt
vier Expression-Typen wie das nachfolgende Klassendiagramm zeigt:
Abbildung 11: Expression-Typen
Die String-Expression nimmt einen einfachen String auf:
Expression nachname = new StringExp("nachname = 'Leisch'");
Die Parameter-Expression kann einen Parameter enthalten, der mit einem Wert ersetzt
wird. Sollte der Parameter null sein, so wird die Expression nicht angezeigt:
Expression nachname = new ParameterExp("nachname = :nachname","Leisch");
Die MultiParameterExp kann mehrere Parameter enthalten, wobei die Parameter in einer
Map übergeben werden müssen:
18 / 33
Ticketline RCP – Getting Started Guide
Map<String,Object> parameters = new HashMap<String,Object>();
parameters.put("min",0);
parameters.put("max",20);
Expression mp = MultiParameterExp("k.value BETWEEN
:max",parameters);
:min
AND
Die ComplexExp stellt schliesslich eine Verknüpfung aus beliebig vielen Expressions dar.
Diese können entweder mittels AND oder OR verbunden sein:
Expression ce = new ComplexExpression(ComplexType.AND,nachname,vorname);
Complex-Expressions lassen sich natürlich auch in anderen Complex-Expressions
verwenden, so dass sich damit selbst komplizierte Ausdrücke erstellen lassen.
Wie die folgende Tabelle zeigt bietet der Query Builder eine Reihe von Methoden an, mit
denen die WHERE-Clause gesetzt werden kann:
where(Expression e)
fügt eine beliebige Expression ein
where(String exp)
entspricht einer StringExp
where(String exp, Object parameter)
entspricht einer ParameterExp
where(String exp, Map<String, Object>
parameters)
entspricht einer MultiParameterExp
whereAnd(Expression... e)
entspricht einer ComplexExp, bei der die
Expressions mit AND verknüpft werden
whereOr(Expression... e)
entspricht einer ComplexExp, bei der die
Expressions mit OR verknüpft werden
19 / 33
Ticketline RCP – Getting Started Guide
Log-Package
Ticketline RCP enthält ein eigenes Log-Package, dass zwei Funktionen erfüllt:
•
einen Wrapper, um die Arbeit mit log4j zu erleichtern
•
einen speziellen LogAppender für log4j innerhalb von Eclipse
Diese Funktionen werden in den beiden nachfolgenden Abschnitten beschrieben
log4j-Wrapper
Nach den best practices für log4j sollte eine Log-Ausgabe folgendermaßen aussehen:
if (log.isTraceEnabled()) {
log.trace("Bei Artikel " + id + " wurde der Preis von " + oldValue + " auf " +
newValue + " erhöht");
}
Eine Guard-Funktion checkt, ob der Log Level aktiviert ist und erst dann wird die Log
Nachricht ausgegeben, da die String-Verkettung in Java relativ ineffizient ist und daher
nach Möglichkeit vermieden werden sollte.
Um den Source Code zu vereinfachen, bietet der von Ticketline RCP bereitgestellte
Wrapper die Log-Methoden mit einer variablen Anzahl von Parametern an, so dass sich
die Log Ausgabe auf folgende Zeile reduziert:
log.trace("Bei Artikel #0 wurde der Preis von #1 auf #2 erhöht", id, oldValue,
newValue);
Es werden dabei maximal 10 Parameter unterstützt (#0 - #9). Werden mehr als 10
Parameter angegeben, so werden diese ignoriert.
Ein komplettes Beispiel sieht folgendermaßen aus:
20 / 33
Ticketline RCP – Getting Started Guide
public class Beispiel {
protected static Logger log = LogFactory.getLogger(Beispiel.class);
public void doSomething() {
Beispiel.log.info("Hello #0","World");
}
}
Bitte achten Sie darauf, dass Sie in eigenen Klassen auch wirklich die Klasse
at.ticketline.log.Logger importieren, da es im Classpath noch weitere Klassen mit dem
Namen Logger geben kann.
EclipseRcpLogAppender
Die Rich Client Platform von Eclipse bringt bereits ein Logging-System mit. Die LogNachrichten werden dabei innerhalb des Workspace der RCP-Applikation in der Datei .log
im Verzeichnis .metadata abgespeichert.
Der EclipseRcpLogAppender dient als Brücke zwischen log4j und dem Logging-System
von Eclipse, so dass die Log-Nachrichten, die mit log4j geloggt werden, in die Log-Datei
von Eclipse geschrieben werden. Weiters können die Log-Nachrichten auch in einer
eigenen Log View ausgegeben werden.
In Ticketline RCP wird der EclipseRcpLogAppender bereits verwendet, so dass die
nachfolgend beschriebenen Schritte nicht mehr durchgeführt werden müssen und lediglich
als Referenz dienen.
Die Konfiguration erfolgt über die Datei log4j.properties im Classpath der Applikation:
log4j.appender.eclipse = at.ticketline.log.EclipseRcpLogAppender
log4j.appender.eclipse.layout = org.apache.log4j.PatternLayout
log4j.appender.eclipse.layout.ConversionPattern = %d %-5p %c - %m%n
log4j.appender.eclipse.consoleView = true
Der EclipeRcpLogAppender muss im Bundle-Activator mit dem Eclipse Logger initialisiert
werden:
21 / 33
Ticketline RCP – Getting Started Guide
EclipseRcpLogAppender.logger = Activator.getDefault().getLog();
EclipseRcpLogAppender.pluginId = Activator.PLUGIN_ID;
Um die Log View anzuzeigen muss das Property consoleView in log4j.properties auf true
gesetzt werden und die Console in der Perspektive angezeigt werden. Der nachfolgende
Befehl fügt die Console der Perspektive hinzu:
layout.addView(IConsoleConstants.ID_CONSOLE_VIEW, IPageLayout.BOTTOM,
0.70f, layout.getEditorArea());
Nachdem die Workbench nicht direkt ab Programmstart zur Verfügung steht, sondern erst
erzeugt wird, werden die ersten Meldungen nur in die Log-Datei geschrieben, nicht jedoch
in der Log Console ausgegeben.
Abbildung 12: Log Console
22 / 33
Ticketline RCP – Getting Started Guide
Kassa-Package
Das Kassa-Package, sowie dessen Subpackages enthält die Klassen für die RCPAnwendung. Nachdem das Zusammenspiel der Klassen anfangs etwas verwirrend sein
kann, wird in diesem Abschnitt ein kurzer Überblick über die Klassen gegeben.
Activator:
Diese Klasse wird als erste Klasse instanziert und ausgeführt, wenn das Plugin bzw die
RCP-Anwendung gestartet wird, sowie als letzte, wenn das Plugin beendet wird. Dabei
werden die Lifecycle-Methoden start(BundleContext) bzw stop(BundleContext)
aufgerufen, die zum Initialisieren bzw Aufräumen verwendet werden können.
Über die Klasse können auf die Preferences des Plugins, sowie Dialog-Einstellungen und
die ImageRegistry zugegriffen werden. Da es vorgesehen ist diese Klasse als Singleton zu
verwenden, kann mittels statischer Methode getDefault() von überall aus der Anwendung
auf die aktuelle Instanz zugegriffen werden.
TicketlineApplication:
Die TicketlineApplication bildet die Hauptklasse der Applikation. Sie wird automatisch
gestartet und die start-Methode aufgerufen. Darin wird die Workbench der RCPApplikation gestartet.
ApplicationWorkbenchAdvisor:
Die ApplicationWorkbenchAdvisor-Klasse dient zum Konfigurieren der Workbench. Sie
definiert eine Reihe von Methoden, die zu bestimmten Zeitpunkten im Lifecycle der
Workbench aufgerufen werden, zB initialize() oder preStartup(). Sie wird in der Klasse
TicketlineApplication verwendet, um die Workbench zu erzeugen.
ApplicationWorkbenchWindowAdvisor:
Die
ApplicationWorkbenchWindowAdvisor-Klasse
wird
vom
ApplicationWorkbenchAdvisor erzeugt und dient zum Konfigurieren des Fensters der
Workbench, in dem sie eine Reihe von Methoden definiert, die zu bestimmten Zeitpunkten
im Lifecycle des Fensters der Workbench aufgerufen werden.
ApplicationActionBarAdvisor:
Die ApplicationActionBarAdvisor-Klasse wird vom ApplicationWorkbenchWindowAdvisor
erzeugt und dient zum Erzeugen und Konfigurieren der Menüleiste, der Cool Bar und der
Statuszeile.
KassaPerspective:
23 / 33
Ticketline RCP – Getting Started Guide
Die KassaPerspective wird defaultmässig von Ticketline RCP angezeigt und konfiguriert
die Oberfläche der Applikation, dh welche Views und Editoren dargestellt werden.
Die Subpackages sind nach ihrem Verwendungszweck eingeteilt. So sollten Views im
ui.views-Package angelegt werden, Editors im ui.editors-Package, usw.
Abbildung 13: Ticketline RCP Applikation
Folgende Funktionen stellt die Ticketline RCP bereit:
•
Künstler importieren
•
Neuen Künstler anlegen
•
Künstler suchen
•
Künstler bearbeiten
•
Künstler löschen
Machen Sie sich mit dem zur Verfügung gestelltem Source Code vertraut, da er bereits sehr
viel der Funktionalität enthält, die Sie auch für die weitere Implementierung benötigen.
24 / 33
Ticketline RCP – Getting Started Guide
Anhang A: Links
Eclipse RCP & SWT/JFace
Eclipse Hilfe
http://help.eclipse.org/
oder direkt in Eclipse unter
Help -> Help Contents -> Platform Plug-in Developer Guide
Artikel auf eclipse.org
http://www.eclipse.org/articles/
SWT Hauptseite
http://www.eclipse.org/swt/
SWT FAQ
(enthält Hinweise wie Eclipse unter verschiedenen Betriebssystemen läuft)
http://www.eclipse.org/swt/faq.php
SWT - Widget Übersicht
http://www.eclipse.org/swt/widgets/
Understanding Layouts in SWT
http://www.eclipse.org/articles/article.php?file=Article-UnderstandingLayouts/index.html
Eclipse RCP FAQ
http://wiki.eclipse.org/RCP_FAQ
Eclipse RCP HowTos
http://wiki.eclipse.org/Eclipse_RCP_How-to
Plug-in development 101, Part 2: Introducing rich-client applications
http://www.ibm.com/developerworks/opensource/library/os-eclipse-plugindev2/
25 / 33
Ticketline RCP – Getting Started Guide
Eclipse RCP Tutorial
http://eclipse.org/articles/Article-RCP-1/tutorial1.html
Sammlung von Artikeln zu Eclipe
http://www.vogella.de/eclipse.html
RCP Buch
http://www.ralfebert.de/rcpbuch/
Eclipse Forms
http://www.eclipse.org/articles/Article-Forms/article.html
Java Persistence API (JPA)
Introduction to the Java Persistence API (aus The Java EE 5 Tutorial)
http://java.sun.com/javaee/5/docs/tutorial/doc/bnbpz.html
Master the New Persistence Paradigm with JPA
http://www.devx.com/Java/Article/33650/1954
Understanding JPA, Part 1: The object-oriented paradigm of data persistence
http://www.javaworld.com/javaworld/jw-01-2008/jw-01-jpa1.html
Java Persistence API (JPA) with EclipseLink-Tutorial
http://www.vogella.de/articles/JavaPersistenceAPI/article.html
EclipseLink User Guide
http://wiki.eclipse.org/EclipseLink/UserGuide/Developing_JPA_Projects_%28ELUG
%29
Java Persistence API Javadoc
http://java.sun.com/javaee/5/docs/api/index.html?javax/persistence/packagesummary.html
JPA Annotation Referenz
http://www.oracle.com/technology/products/ias/toplink/jpa/resources/toplink-jpaannotations.html
26 / 33
Ticketline RCP – Getting Started Guide
Anhang B: FindBugs
Bei FindBugs handelt es sich ein Tool zur statischen Source Code Analyse, dh der Source
Code wird auf mögliche Probleme oder Fehler untersucht, ohne ihn dabei auszuführen. Zu
FindBugs gibt es ein Eclipse-Plugin, dessen Installation und Anwendung in diesem Kapitel
gezeigt wird.
Gehen Sie in Eclipse auf Help → Install New Software und fügen Sie mittels Add... eine
neue
Installationsseite
hinzu.
Geben
Sie
als
Location
http://findbugs.cs.umd.edu/eclipse ein.
Abbildung 14: FindBugs Site
Wählen Sie nun FindBugs auf der Installationsseite und setzen Sie die Installation im
Wizard fort. Nach der Installation sollten Sie Eclipse wie empfohlen neu starten.
Über Window → Show View → Other kann nun der Bug Explorer geöffnet werden.
Nachdem mittels Rechtsklick auf das Projekt und dann Find Bugs → Find Bugs der ScanVorgang durchgeführt wurde, werden die potentiellen Probleme wie in der nachfolgenden
Abbildung zu sehen im Bug Explorer angezeigt.
Achtung:
FindBugs findet natürlich nicht jeden Fehler und nicht jedes der angezeigten
potentiellen Probleme muss auch zwangsläufig ein Fehler sein!
27 / 33
Ticketline RCP – Getting Started Guide
Abbildung 15: FindBugs Explorer
28 / 33
Ticketline RCP – Getting Started Guide
Anhang C: Frequently Asked Questions
Wo finde ich Informationen zu SWT und RCP?
Im Hilfesystem unter Help → Help Contents gibt es eine eigene Kategorie Platform Plug-in
Developer Guide, der eine Einführung für RCP bietet.
Im Unterpunkt Reference → API Reference befindet sich das Javadoc von RCP.
Wie kann ich Subversion in Eclipse benutzen?
Es gibt zwei Plugins für Eclipse:
Subclipse: http://subclipse.tigris.org/
Subversive: http://www.polarion.org/index.php?page=overview&project=subversive
Nach dem Import des Projekts werden in einigen Dateien fehlende Klassen
angezeigt
Bei unterschiedlichen Eclipse-Versionen kann es sein, dass Abhängigkeiten zu anderen
Plugins nicht aufgelöst werden können, da sich die Versionsnummern der Plugins
unterscheiden. Öffnen Sie mit Doppelklick die plugin.xml-Datei und wechseln Sie auf den
Reiter Dependencies. Unter Required Plug-ins werden die Abhängigkeiten aufgelistet.
Entfernen Sie das Plugin, aus dem die fehlende Klasse stammt, und fügen Sie es über den
Add...-Button mit der richtigen Version wieder hinzu.
Wie entwickle ich am Besten einen Login-Dialog?
Es gibt hierfür den Extension Point org.eclipse.ui.splashHandlers, sowie die Klassen im
Package org.eclipse.ui.splash für die Implementierung.
Wie kann ich das Javadoc für Ticketline RCP erstellen?
Unter File → Export... → Java → Javadoc können Sie das Javadoc für das aktuelle Projekt
generieren lassen.
Wie kann ich eine Java Bibliothek (JAR-Datei) in das Projekt hinzufügen?
Kopieren Sie die JAR-Datei ins lib-Verzeichnis und aktualisieren Sie das Projekt (F5 oder
Rechtsklick auf das Projekt und Refresh)
Anschließend muss die Jar-Datei zum Build Path hinzugefügt werden. Rechtsklicken Sie
hierzu auf das Projekt und wählen Sie Properties. Unter Java Build Path → Libraries
können Sie die Datei über Add JARs...
29 / 33
Ticketline RCP – Getting Started Guide
Als letzter Schritt muss die Jar-Datei in die RCP-Applikation eingebunden werden.
Doppelklicken Sie die plugin.xml-Datei im Projekt und wählen Sie Runtime aus. In der
rechten unteren Ecke unter Classpath können Sie die Bibliothek mit Add... hinzufügen.
Speichern Sie danach plugin.xml.
Was muss ich tun, um Ticketline RCP unabhängig von Eclipse starten zu
können?
Sie müssen dazu Ticketline RCP exportieren. Rechtsklicken Sie auf das Projekt oder öffnen
Sie das Menü für File und wählen Sie jeweils den Punkt Export... Im Fenster wählen Sie
nun Plug-in Development → Eclipse product, um den Export-Wizard zu starten.
Was muss ich bei der Installation unter MacOS beachten?
Von SWT gibt es bisher nur eine 32-Bit-Variante. Wenn ihr Computer daher einen 64-BitProzessor besitzt, müssen Sie die Java Virtual Machine so konfigurieren, dass sie im 32Bit-Modus läuft.
Rechtsklicken Sie hierzu auf ihr Projekt und wählen Sie dann Run As → Run
Configurations. Wählen Sie unter Eclipse Application die Konfiguration für Ticketline RCP
(falls diese noch nicht vorhanden ist, starten Sie Ticketline RCP wie bei der Installation
angegeben) und tragen Sie im zweiten Reiter Arguments unter VM arguments -d32 ein.
Abbildung 16: Run Konfiguration für MacOS 64-Bit
Warum muss die Datei db-bugfix.sql in die Datenbank eingespielt werden?
Wenn Sie mittels EclipseLink eine neue Entität in die Datenbank einfügen, wird dessen ID
automatisch gesetzt. Dies erfolgt in Ticketline RCP durch die IDENTITY-Definition der
Datenbanktabelle. Das Problem dabei ist, dass die IDENTITY den ersten Datensatz mit der
30 / 33
Ticketline RCP – Getting Started Guide
ID 0 einfügt. Die ID 0 wird von EclipseLink jedoch als null interpretiert und liefert daher
die Exception EclipseLink-7197: Null primary key encountered in unit of work
clone
Bug-Report: https://bugs.eclipse.org/bugs/show_bug.cgi?id=297198
Wenn die Applikation beendet wird, wird eine eine SWTException (Device is
disposed) angezeigt? Was läuft da schief?
Gar nichts. Ab einem bestimmten Zeitpunkt kann der EclipseRcpLogAppender die Log
Messages nicht mehr auf die Log Console ausgeben, da sie bereits geschlossen wurde.
Daher wird eine Exception geworfen und ausgegeben.
Wenn ich eine Datenbankabfrage starte, bekomme ich immer folgende
Exception:
Internal Exception: java.sql.SQLException: No suitable driver found for
jdbc:hsqldb:hsql://localhost/ticketline
Diese Exception hat nicht zwangsläufig etwas mit einem fehlenden JDBC-Treiber zu tun.
Sie wird immer geworfen, wenn es Probleme mit der Datenbankverbindung gibt. Stellen
Sie daher sicher, dass die Datenbank wirklich läuft und prüfen Sie, ob Sie sich mit dem
DatabaseManager verbinden können.
Welche Version der Java Persistence API wird verwendet?
In Ticketline RCP wird JPA 1.0 verwendet. Es gibt inzwischen eine Version 2.0 von JPA,
die eine Weiterentwicklung von JPA 1.0 darstellt und diese um neue Features erweitert.
Zum Beispiel enthält JPA 2.0 standardmäßig die Bean Validation, die in Ticketline RCP
noch manuell eingebaut wurde.
31 / 33
Ticketline RCP – Getting Started Guide
Glossar
Bundle
Ein Modul bzw eine Komponente für OSGi
Data Access Object (DAO)
Design-Pattern, bei dem alle Datenbankzugriffe in einem
Interface und einer Implementierung gekapselt werden.
EclipseLink
Implementierung der JPA-Spezifikation von Eclipse
Equinox
Implementierung der OSGi-Spezifikation von Eclipse,
bildet den Kern von Eclipse
Extension
Eine Erweiterung der Funktionalität, eines bestimmten
Extension Points. Erweitert zumeist eine Klasse oder ein
Interface, das vom Extension Point definiert wird.
Extension Point
Definierter Punkt, der durch eine Extension mit
zusätzlicher Funktionalität erweitert werden kann (zB
einfügen eines Menüpunkts in ein Menü)
Factory
Design-Pattern, bei dem eine Factory-Klasse für das
Erzeugen und Konfigurieren von Objekten dient.
Feature
Sammlung von Plugins
JFace
Erweiterung von SWT, um höherwertige Funktionen
Java Persistence API (JPA)
Offizielle Java-Spezifikation (JSR 220) für das Mapping
von Objekten auf das relationale Datenmodell von
Datenbanken (ORM)
Lifecycle
Lebenszyklus von Service-Objekte, die über einen längeren
Zeitraum existieren (zB vom Starten bis zum Beenden
einer Applikation). Diese bieten zumeist spezielle
Methoden, die im Laufe des Lebenszyklus aufgerufen
werden (zB init oder close)
OSGi
Ein dynamisches Modulsystem für Java
32 / 33
Ticketline RCP – Getting Started Guide
Perspektive
Definiert das Aussehen der Workbench, dh welche Views
und Editoren angezeigt werden, sowie deren Position und
Größe.
Plugin
Ein Modul bzw eine Komponente in Eclipse, Erweiterung
von OSGi-Bundles
Rich Client Platform (RCP)
Framework für
Applikationen.
Singleton
Pattern, bei dem es in einer Applikation von einem Objekt
nur eine einzige Instanz gibt.
Standard Widget Toolkit
(SWT)
Das Low-Level User Interface Toolkit von Eclipse, das die
Elemente der grafischen Oberfläche beinhaltet. Alternative
zu AWT/Swing
Workbench
Bildet die Basis für das User Interface von RCPApplikationen
Workspace
Verzeichnis, in welchem die Workbench Informationen
ablegt. In Eclipse enthält es die Projektverzeichnisse.
33 / 33
die
Entwicklung
von
Desktop-