Rich-Client-Entwicklung mit Eclipse 3.3 Update auf Eclipse 3 · ii Aktualisierung: Rich-Client-Entwicklung mit Eclipse 3.4 Plugin-Ensembles besser zu kapseln, was besonders für große

Rich-Client-Entwicklung mit Eclipse 3.3

Update auf Eclipse 3.4

Diese Datei enthält Aktualisierungen und Ergänzungen zum Buch »Rich-Client-Entwicklung mit Eclipse 3.3« von Berthold Daum (ISBN 978-3-89864-503-4).

(c) 2008, dpunkt.verlag Heidelberg

Berthold Daum, Rich-Client-Entwicklung mit Eclipse 3.3, dpunkt.verlag, ISBN 978-3-89864-503-4

D3kjd3Di38lk323nnm

i

Aktualisierung: Rich-Client-Entwicklung mit Eclipse 3.4

Vorwort

Anders als bei den letzten 3 Auflagen dieses Buches kamen Verlag undAutor diesmal überein, für Eclipse 3.4 keine Neuauflage von Rich-Cli-ent-Entwicklung mit Eclipse herauszubringen. Statt dessen haben wiralle Änderungen, die sich aus den Neuerungen in Eclipse 3.4 ergeben,in dieser Datei zusammengefasst. Das verlangt zwar vom Leser mehrArbeit, schont aber andererseits Umwelt und Geldbeutel.

Was sind nun die wichtigsten Änderungen für die Rich-Client-Ent-wicklung?

• Die umfangreichste Neuerung in Eclipse 3.4 ist sicher die Einfüh-rung des Equinox p2 Provisioning, das den bisherigen Update-Manager ersetzt und für mehr Flexibilität und Sicherheit bei derInstallation sorgen soll (Kapitel 6). Allerdings lässt sich die p2-Funktionalität noch nicht für die programmgesteuerte Aktualisie-rung von RCP-Anwendungen verwenden – es gibt noch keinöffentliches API. Interessant in diesem Zusammenhang dürfte inZukunft das auf p2 aufsetzende Projekt Maynstall werden.

• Bei der Plugin-Entwicklung erleichtert es der Plug-in Spy, vorhan-dene Workbenchkomponenten zu verorten. Die nun bestehendeMöglichkeit, bei der Definition von Erweiterungspunktenbestimmte Attribute als Identifier zu deklarieren, dürfte Schlussmachen mit dem, was Plugin-Entwickler in der Vergangenheit als»ID-Hölle« bezeichnet haben. Nützlich sind auch die neuen Edito-ren für Hilfe-Inhaltsverzeichnisse und Kontextzuordnungsdateien.Und schließlich gestattet die neue API Analysis, Plugins und

Bitte beachten Sie auch die Errata zu »Rich-Client-Entwicklung mitEclipse 3.3« unter http://www.bdaum.de/eclipse/buchRCP33/Errata.pdf

Aktualisierung: Rich-Client-Entwicklung mit Eclipse 3.4ii

Plugin-Ensembles besser zu kapseln, was besonders für große undgrößte Anwendungen eine Rolle spielt (Kapitel 3).

• Mit der Freigabe von EclipseLink erhalten RCP-Programmierereine leistungsfähige Persistenzlösung, die relationale Datenbanken(über JPA), XML-Dateien (über JAXB) und WebServices als Persis-tenzmedien nutzen kann. Da EclipseLink OSGi-verträglichgemacht wurde, gehören die Klassenladerprobleme von TopLinkder Vergangenheit an (Kapitel 14).

• Neu ist auch Unterstützung JAAS (Java Authentication and Autho-rization Service) in Equinox, wodurch die Einbindung von RCP-Anwendungen in das Java-Sicherheits-Framework deutlich erleich-tert wird.

Juli 2008Berthold [email protected]

Globale Änderungen

Die Menüfunktionen Run>Open Run Dialog... und Debug>OpenDebug Dialog... wurden umbenannt in Run>Run Configurations ...und Debug>Debug Configurations ... .

Ebenso wurde die Menüfunktion Run>External Tools>OpenExternal Tools Dialog ... umbenannt in Run>External Tools>ExternalTools Configurations ... .

Die Nummerierung der Kapitel, Unterkapitel, Abbildungen usw. orientierensich in diesem Text an der Zählung der 3. Auflage von »Rich-Client-Entwick-lung« mit Eclipse. Das heißt, inhaltliche Aktualisierungen und Ergänzungenwerden im Folgenden unter der entsprechenden Gliederungsnummer desBuches vorgestellt.

Wundern Sie sich also nicht, dass einige Kapitel und Unterkapitel garnicht vorkommen -- dort waren die Versionsänderungen nicht relevant.

Die Seitenzählung dieses Updates ist unabhängig von dem zugrunde-liegenden Buch.


iii

Inhalt

Teil IDie Eclipse-Rich-Client-Plattform 1

2 Modelle und Muster 3

2.2 Eine minimale RCP-Anwendung . . . . . . . . . . . . . . . . . . . . . . 3

2.2.3 Ein Plugin-Projekt anlegen . . . . . . . . . . . . . . . . . . . . 3

2.5. Domänenmodell und Kommandos . . . . . . . . . . . . . . . . . . . . . 4

2.5.1 Das Datenmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Plugin-Entwicklung 5

3.2 Die Anatomie eines Plugins . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3.2.1 Das OSGi-Manifest . . . . . . . . . . . . . . . . . . . . . . . . . . 53.2.6 Der Schema-Editor . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3.3 Die Kernklassen der Eclipse-Plattform . . . . . . . . . . . . . . . . . . 7

3.3.3 Nebenläufigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3.4 Die Eclipse-Plattform erweitern . . . . . . . . . . . . . . . . . . . . . . . 7

3.4.2 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3.5 Die Benutzeroberfläche der Eclipse-Plattform . . . . . . . . . . . . . 8

3.5.2 Die Architektur der Workbench . . . . . . . . . . . . . . . . 8

3.6 Benutzerunterstützung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3.6.1 Das Hilfesystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Inhaltsverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Kontextsensitive Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4 RCP-Entwicklung 11

4.3 Die Workbench der Beispielanwendung . . . . . . . . . . . . . . . . 11

4.3.1 Die Workbench konfigurieren . . . . . . . . . . . . . . . . . 114.3.5 Montieren einer RCP-Anwendung . . . . . . . . . . . . . 11

Inhaltiv

5 Produktanpassung 13

5.1 Produktgestaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

5.1.2 Die Produktkonfiguration . . . . . . . . . . . . . . . . . . . 135.1.3 Konfiguration benötigter Plugins . . . . . . . . . . . . . . 13

5.3 Produkte internationalisieren . . . . . . . . . . . . . . . . . . . . . . . 14

5.3.2 Textkonstanten in Manifest-Dateien . . . . . . . . . . . 14

6 Eine RCP-Anwendung installieren 15

6.2 Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

6.2.2 Sprachpakete als Features ausliefern . . . . . . . . . . . 15

6.3 Build-Prozess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

6.4 Die Update-Site . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

7 Eine RCP-Anwendung im Feld aktualisieren 19

7.3 Batch-Update . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Teil IIBenutzeroberflächen für Rich Clients 21

9 SWT, JFace und das Forms API 23

9.1 Das Standard Widget Toolkit . . . . . . . . . . . . . . . . . . . . . . . 23

9.1.3 Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23Die Klasse Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

9.1.11 Datentransfer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Transfertypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

9.2 JFace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

9.2.2 Dialoge und Fenster . . . . . . . . . . . . . . . . . . . . . . . . 25Persistente Dialoge . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

9.2.3 Viewer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26Mehrspaltige Viewer . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

9.4 Ein GUI-Framework für die Beispielanwendung . . . . . . . . . 29

9.4.3 Die View-Komponente . . . . . . . . . . . . . . . . . . . . . . 29

10 Jenseits von SWT 31

10.1 SWT-Erweiterungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31


vInhalt

10.2 Skriptsprachen für Benutzeroberflächen . . . . . . . . . . . . . . . . 31

10.2.2 XML-GUI-Beschreibung in der Beispielanwendung . 3110.2.3 Andere Skriptsprachen . . . . . . . . . . . . . . . . . . . . . . 3210.2.5 Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

10.3 Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Teil IIIPersistenz 35

12 XML 37

13 Relationale Datenbanksysteme für Rich Clients 39

13.1 Die Eclipse Data Tools Platform . . . . . . . . . . . . . . . . . . . . . . 39

Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39Datenbanktreiber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39Datenbankverbindung . . . . . . . . . . . . . . . . . . . . . . . . . 40SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

13.2 DBMS in der Rich-Client-Anwendung . . . . . . . . . . . . . . . . . 41

13.2.2 Ein eigenes Derby-Plugin . . . . . . . . . . . . . . . . . . . . . 41

13.4 Datenbankzugriffe für die Beispielanwendung . . . . . . . . . . . 42

14 Objektrelationale Brücken 43

14.1 JPA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

14.1.1 Die JPA-Architektur . . . . . . . . . . . . . . . . . . . . . . . . 4414.1.2 JPA in einer Rich-Client-Anwendung . . . . . . . . . . . 45

EclipseLink . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

14.2 Ein Plugin zur Ressourcenverwaltung . . . . . . . . . . . . . . . . . . 49

14.2.1 Plugin-Manifest . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

14.3 Das Plugin für die Projektplanung . . . . . . . . . . . . . . . . . . . . 50

14.3.4 Der View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

15 Andere Persistenzoptionen 51

15.1 Objektorientierte Datenbanken . . . . . . . . . . . . . . . . . . . . . . 51

15.1.1 Prototypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

16 Das Graphical Editing Framework 55

16.4 Beispielanwendung: Gantt-Chart mit GEF . . . . . . . . . . . . . . 55

16.4.1 GEF installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

16.4a Ein Graph mit Zest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

16.5 Andere grafische Möglichkeiten . . . . . . . . . . . . . . . . . . . . . . 60

Inhaltvi

17 BIRT 61

17.1 Die Entwufsphase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

17.1.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6117.1.2 Eine Datenquelle . . . . . . . . . . . . . . . . . . . . . . . . . . 62

17.2 BIRT in einer Rich-Client-Anwendung . . . . . . . . . . . . . . . . 62

17.2.2 Berichte in einer RCP-Anwendung generieren und anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

18 Elefantenhochzeit: Office-Komponenten unter Eclipse 65

18.1 OpenOffice einbetten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

18.1.5 Die Infrastruktur bereitstellen . . . . . . . . . . . . . . . . 65Die Klasse OO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

18.2 Ein OpenOffice-View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

18.2.1 Projekt anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

18.3 Office-Dateien generieren . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Die Klasse ExportSpreadsheetAction . . . . . . . . . . . . . . 66

19 Ausgabe von PDF-Dateien 69

19.1 PDF-Dateien erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

19.2 Ein PDF-Dokument anzeigen . . . . . . . . . . . . . . . . . . . . . . . 69

Teil IVAdministration 71

20 Synchronisierung mit dem Server 73

20.2 Proprietäre Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

20.2.5 db4objects dRS Replication System . . . . . . . . . . . . 73

20.4 Lösungen unter Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

20.5 Ein synchronisierter Task-Planer . . . . . . . . . . . . . . . . . . . . . 73

20.5.2 Das Sync-Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . 74Das Sync-Plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

21 Konfiguration und Administration 75

21.1 Benutzerauthentifizierung . . . . . . . . . . . . . . . . . . . . . . . . . . 75

21.4 Fernwartung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Zukunft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

22.4 Schutz intellektuellen Eigentums . . . . . . . . . . . . . . . . . . . . . 76


viiInhalt

22.4 Anhang A: Wichtige Download Adressen 77

22.4 Anhang B: Erste Hilfe 79

22.4 Anhang C: Lösungen zu den Aufgaben 81

Kapitel 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

22.4 Anhang D: Relevante eclipse.org-Projekte 83


1

Teil IDie Eclipse-Rich-Client-Plattform

2


3

2 Modelle und Muster

2.2 Eine minimale RCP-Anwendung

2.2.3 Ein Plugin-Projekt anlegen

Die Eingabe eines Classpath-JAR entfällt.

Abb. 2–1

Nach einem Druck auf den

Shortcut New Plug-in

Project und der Eingabe

des Projektnamens auf der

ersten Seite des Wizards

erfolgt auf der nächsten

Wizard-Seite die

eigentliche Plugin-

Konfiguration. Mit einem

Druck auf die Next-Taste

gelangt man dann zur

Auswahl der Templates.

2 Modelle und Muster4

2.5. Domänenmodell und Kommandos

Die Eingabe eines Classpath-JAR entfällt.

2.5.1 Das Datenmodell1

1. Das Eclipse Modeling Framework (EMF) ist in der Lage, solche Datenmodelle zugenerieren. Das Subprojekt Teneo ist in der Lage, solche Modelle auf relationaleDatenbanken abzubilden.

Abb. 2–3

Das Plugin

com.bdaum.planner.co

re tritt nicht an der

Benutzeroberfläche in

Erscheinung. So ist es

später leicht möglich, bei

Bedarf die in separaten

Plugins implementierte

Benutzeroberfläche gegen

eine anders gestaltete

Oberfläche

auszuwechseln.


5

3 Plugin-Entwicklung

3.2 Die Anatomie eines Plugins

3.2.1 Das OSGi-Manifest

Der OSGi-Manifesteintrag

Eclipse-LazyStart: true

wurde ersetzt durch

Bundle-ActivationPolicy: lazy.

Diese Möglichkeit, Bundles erst bei Bedarf zu starten, wurde inzwi-schen in den OSGi-Standard übernommen.

Manifest-Version: 1.0Bundle-ManifestVersion: 2Manifest-Version: 1.0Bundle-ManifestVersion: 2Bundle-Name: Core Plug-inBundle-SymbolicName: com.bdaum.planner.core;singleton:=trueBundle-Version: 1.0.0Bundle-Activator: com.bdaum.planner.core.CoreActivatorBundle-Vendor: bdaum industrial communicationsRequire-Bundle: org.eclipse.core.runtime, org.eclipse.core.commands;bundle-version="3.4.0", org.eclipse.core.databinding;bundle-version="1.1.0";visibility:=reexport, org.eclipse.core.databinding.beans;bundle-version="1.1.0";visibility:=reexport, org.eclipse.jface;bundle-version="3.4.0"Bundle-RequiredExecutionEnvironment: J2SE-1.5Bundle-ActivationPolicy: lazy

3 Plugin-Entwicklung6

Klassenpfad Der Abschnitt Classpath ist noch leer, da seit Eclipse 3.4 beim Anlegeneines Projekts keine Angabe eines Classpath-JARs mehr möglich ist. Indiesen Abschnitt können jedoch zusätzlich auszuliefernde JAR-Dateien angegeben werden, die in den Klassenpfad des Plugins aufge-nommen werden sollen. Die direkt zum Projekt gehörigen Binärda-teien (die in den Ordner bin/ kompiliert werden) gehören automatischzum Klassenpfad des Plugins.

3.2.6 Der Schema-Editor

Attribute

• Neu ist der Attributtyp »identifier«. Damit besteht die Mög-lichkeit, Identifikationen zu deklarieren (ohne Angabe im FeldReferences) oder aber auf anderes, eine Identifikation deklarie-rendes Attribut zu verweisen. Dazu muss im Feld Referenceseine XPath-Angabe zum diesem Attribut angegeben werden.

Die Attribute id der Elemente plugin und perspective erhalten beideden Typ identifier. Im letzteren Falle können wir den Wertebereich ein-schränken, indem wir im Feld References den XPath-Ausdruckorg.eclipse.ui.perspectives/perspective/@id angeben. Am bestenbetätigen Sie die Taste Browse..., tippen dann »*perspective« ein undwählen »id – perspective (Perspectives)« aus. Damit wird dieses Attri-but nur Werte enthalten können, die im Erweiterungspunktorg.eclipse.ui.perspectives im Attribut id des Konfigurationsele-ments perspective deklariert wurden, also Identifikationen von gülti-gen Perspektiven sind. Auf diese Weise können die gefürchteten Tipp-fehler in den Plugin-Manifesten weitgehend vermieden werden.

This plug-in is a singleton

Neu hinzugekommen ist die Option This plug-in is a singleton. Bei der Entwicklung von Plugins für Serverapplikationen kann es aus Skalie-rungsgründen sinnvoll werden, mehrere Instanzen des gleichen Plug-ins gleichzeitig ablaufen zu lassen. In diesem Fall wäre das Häkchen von der Option zu entfernen. Allerdings darf das Plugin dann den Ex-tension-Point-Mechanismus nicht verwenden. Auch müsste der Akti-vator, der von seiner Logik her auf Singleton-Betrieb ausgelegt ist, geeignet abgeändert werden.


73.3 Die Kernklassen der Eclipse-Plattform

3.3 Die Kernklassen der Eclipse-Plattform

3.3.3 Nebenläufigkeit

Um alle Jobs des Typs OperationJob einheitlich ansprechen und vonanderen Jobs – z.B. von internen Jobs der Eclipse-Workbench – unter-scheiden zu können, definieren wir eine Job-Familie. Dazu überschrei-ben wir in Klasse OperationJob die Methode belongsTo():

public static final String OPERATIONJOBFAMILY = "com.bdaum.planner.operation"; @Override public boolean belongsTo(Object family) { return OPERATIONJOBFAMILY.equals(family); }

3.4 Die Eclipse-Plattform erweitern

3.4.2 Beispiel

• Die Eingabe eines Classpath-JAR entfällt.• Auf der nächsten Seite wird der View konfiguriert. Unter View

Class Name tragen Sie UserView ein, unter View Name (das istdie Beschriftung auf dem Reiter) nur »Users«, denn der Admi-nistrator ist für die Benutzerverwaltung zuständig. Unter ViewCategory ID tragen Sie com.bdaum.planner.viewCategory ein,unter View Category Name den Wert »Project Planner«. DieseAngaben werden benutzt, um den View im Menüpunkt Win-dow>Show View in die Gruppe Project Planner einzuordnen.Entfernen Sie außerdem das Häkchen von Add the view to theresource perspective, denn in der geplanten Rich-Client-Anwendung haben wir keine Ressourcenperspektive. Ebenfallsentfernt wird das Häkchen von Add context help to view – umdie Hilfefunktionen werden wir uns später kümmern. Miteinem Druck auf die Finish-Taste wird das neue Plugin gene-riert.

Rolle• Selektieren Sie erneut das role-Element. Nach einem rechtenMausklick wählen Sie new>perspective.

• Im Abschnitt Extension Element Details tragen Sie nun im Feldid die ID der oben definierten Administrator-Perspektive ein(com.bdaum.planner.admin.perspective). Am besten benutzen Siedazu die Browse...-Taste. Das Feld initial setzen Sie auf true.

3 Plugin-Entwicklung8

3.5 Die Benutzeroberfläche der Eclipse-Plattform

3.5.2 Die Architektur der Workbench

Beispiel Die ID und das implementierende Plugin des Error-Log Views findenSie ganz einfach, indem Sie in der Entwicklungsplattform den Fokus inden Error-Log View setzen und dann Alt+Shift+F1 drücken. Der dannerscheinende Plug-in Spy informiert Sie erschöpfend über die Eigen-schaften dieses Views.

Abb. 3–3a

Der Plugin Spy. Wie Sie

sehen, ist der Error-Log-

View inzwischen in das

Plugin

org.eclipse.ui.views.log

gewandert.

Abb. 3–4

Der vorläufige Ausbau

Administrator-

Perspektive. Insbesondere

der Error-Log ist später

beim Betrieb in einer Rich-

Client-Anwendung sehr

nützlich, denn er gestattet

die komfortable

Beobachtung von

auftretenden Fehlern.1

1 Tipp: Zur Analyse eines Eintrags doppelklicken Sie den Eintrag. Im folgenden Dialogbetätigen Sie die Taste Copy Event Details to Clipboard. Dann fügen Sie diekopierten Daten im Console-View Ihrer Entwicklungsplattform ein. Nun könnenSie mit einem Klick auf einen Hyperlink direkt zur betreffenden Stelle im Quelltextnavigieren.


93.6 Benutzerunterstützung

3.6 Benutzerunterstützung

3.6.1 Das Hilfesystem

Inhaltsverzeichnis

Neu eingeführt in Eclipse 3.4 wurde ein Wizard zum Anlegen neuerInhaltsverzeichnisse (File>New>Other...>User Assistance>Help Tableof Contents). Nach dem Anlegen wird das Inhaltsverzeichnis gleich imneuen formularorientierten TOC-Editor geöffnet. Mit einem Klick aufden Hyperlink Register this table of contents kann der Editor gleichdie passende Erweiterung für den Erweiterungspunktorg.eclipse.help.toc anlegen.

Kontextsensitive Hilfe

Ganz ähnlich wie beim Inhaltsverzeichnisse wurde mit Eclipse 3.4auch ein Wizard zum Anlegen einer Zuordnungsdatei(File>New>Other...>User Assistance>Context Help) und der dazupassende Editor eingeführt. Auch hier lassen sich wieder über denHyperlink Register this context help file die entsprechenden Einträgein der Manifestdatei vornehmen.

Abb. 3–5a

Der TOC-Editor erlaubt die

Konstruktion und

Gestaltung von Hilfe-

Inhaltsverzeichnissen

ohne Kenntnisse in der

TOC-XML-Syntax. Deutlich

zu sehen ist der

Ankerpunkt für das

Andocken sekundärer

Inhaltsverzeichnisse.


11

4 RCP-Entwicklung

4.3 Die Workbench der Beispielanwendung

4.3.1 Die Workbench konfigurieren

Außerdem können die folgenden Methoden überschrieben werden, umdas Verhalten der Workbench zu modifizieren:

4.3.5 Montieren einer RCP-Anwendung

Statt dem Plugin org.eclipse.pde.runtime wird nun das Pluginorg.eclipse.ui.views.log benötigt, da der Error-Log-View in diesesPlugin gewandert ist.

Für die Hilfefunktionen müssen die Plugins der Hilfegruppe ange-kreuzt werden, also org.eclipse.help, org.eclipse.help.appserver,org.eclipse.help.base, org.eclipse.help.ui und org.eclipse.help.webapp. Außerdem ist es jetzt nötig geworden, org.eclipse.equinox.ht-tp.jetty explizit anzukreuzen. Anschließend muss natürlich noch dieTaste Add Required Plug-ins betätigt werden, um die indirekt abhän-gigen Plug-ins zur Konfiguration hinzuzufügen.

getComparatorFor Legt Ordnungskriterien für Workbench-Elemente fest, z.B. für Property- oder Präferenzenseiten.

getWorkbenchErrorHandler Regelt das Verhalten im Fehlerfall.

openWindows Öffnet die Workbenchfenster.


13

5 Produktanpassung

5.1 Produktgestaltung

5.1.2 Die Produktkonfiguration

Der Erweiterungspunkt org.eclipse.ui.splashHandlers ist inzwischendokumentiert.

5.1.3 Konfiguration benötigter Plugins

Die Präferenzenschlüssel und benutzerdefinierten Präferenzenwertekönnen auch unter Help>About Eclipse SDK>Configuration Detailsim Abschnitt User Preferences eingesehen werden.

Abb. 5–5

Der Wizard zum Export

eines Produkts. Das

Ergebnis ist entweder eine

lauffähige Installation des

Produkts oder eine

installationsfähige ZIP-

Datei. Die neue Option

Generate metadata repository dient dem

Anlegen eines p2-

Repositoriums (siehe

Abschnitt 6.4), aus dem

heraus Aktualisierungen

des Produkts stattfinden

können.

5 Produktanpassung14

5.3 Produkte internationalisieren

5.3.2 Textkonstanten in Manifest-Dateien

Der Externalize-Strings-Wizard legt gleichzeitig im OSGi-Manifestden Eintrag

Bundle-Localization: plugin

an. Mit dieser Anweisung wird die Locale-abhängige Interpretationvon Manifest-Daten aktiviert. Fehlt der Eintrag, erscheinen statt dergewünschten Texte die Schlüssel mit vorangestelltem Prozentzeichen.


15

6 Eine RCP-Anwendung installieren

6.2 Features

6.2.2 Sprachpakete als Features ausliefern

6.3 Build-Prozess

Da beim Anlegen von Plugin-Projekten in Eclipse 3.4 kein Classpath-JAR mehr angegeben wird, entfällt natürlich auch dessen Eintrag inder Sektion Runtime Information der Build Configuration. Statt des-sen finden wir an dieser Stelle nun einen ».«-Eintrag, der den kompi-lierten Inhalt des src/-Ordnera repräsentiert. Der bin/-Ordner brauchtauch in diesem Falle nicht angekreuzt zu werder.

Abb. 6–2

Beim Anlegen eines

Fragment-Projekts muss

die ID des Ziel-Plugins

spezifiziert werden.

Zusätzlich kann auf

spezifische Versionen des

Plugins Bezug genommen

werden.

6 Eine RCP-Anwendung installieren16

6.4 Die Update-Site

Seit Eclipse 3.4 generiert der Build-Prozess der Update-Site zusätzlichdie Dateien content.xml und artifacts.xml. Diese Dateien dienen derSteuerung von Installationsprozessen unter dem Equinox p2 Provisio-ning. Die Update-Site erfüllt damit nun auch die Funktion eines p2-Repositoriums.

Im Unterschied zur klassischen Eclipse-Update-Site kann ein p2-Repositorium nicht nur Features enthalten, sondern beliebige Artenvon Installationsobjekten. Damit kommt ein p2-Repositorium auchfür Anwendungen in Frage, die nicht auf der Eclipse-Plattform basie-ren, sondern lediglich auf der Equinox-OSGi-Plattform. Außerdembesteht die Möglichkeit, eine komplette RCP-Anwendung aus einemp2-Repositorium heraus zu installieren, und nicht nur eine bestehendeAnwendung zu aktualisieren.

Beispiel

Das Feature com.bdaum.planner.nl kann ebenfalls der Kategorie plan-ner hinzugefügt werden.

Abb. 6–3

Die ausgewählten

Entwicklungsartefakte des

Plugins

com.bdaum.planner in

der Datei

build.properties.

Beim binären Build

wurden insbesondere

noch Bilder, Schemata, die

Initialisierungsdatei für

Plugin-Präferenzen und

die Dateien für den

Willkommensschrim

hinzugefügt. Beim

Quellcode-Build wird nur

der Inhalt des src/-

Ordners exportiert.


176.4 Die Update-Site

Nach Änderungen an Plugins und Features sollten Sie vor einem neuenBuild die Versionsnummern der betreffenden Plugins und Features erhö-hen, weil sonst Ihre Änderungen wirkungslos bleiben können. Haben Sienoch nicht ausgeliefert, können Sie auch ersatzweise im Update-Site-Projekt die generierten Ordner plugins/ und features/ und außerdemdie generierten Dateien content.xml und artifacts.xml vor einemneuen Build löschen.


19

7 Eine RCP-Anwendung im Feld aktualisieren

7.3 Batch-Update

Seit Eclipse 3.4 gibt es außerdem die Möglichkeit, Eclipse-basierte Pro-dukte mit Hilfe des p2-Direktors zu aktualisieren. Anders als beimBatch-Update, bei dem das Zielsystem selbst den Batch-Lauf durch-führen muss, ist es hier möglich, ein System auch von außerhalb zuaktualisieren. Der p2-Direktor benötigt dazu als Quelle ein p2-Reposi-torium, z.B. eine Update-Site in der auch die Dateien artifacts.xmlund content.xml generiert wurden (siehe Abschnitt 6.4). Eine Beschrei-bung der nötigen Kommandozeilenparameter finden Sie unterHelp>HelpContents>Platform Plug-in Developer Guide>Program-mers Guide>Packaging and delivering Eclipse based products>Provi-sioning platform (p2)>Installing software using the p2 director appli-cation.


21

Teil IIBenutzeroberflächen für Rich Clients

22


23

9 SWT, JFace und das Forms API

9.1 Das Standard Widget Toolkit

9.1.3 Widgets

Widget

DropTarget MenuDragSource

Item

MenuItem TabItem CTabItem

TableColumn TableItem TrayItem TreeItemToolItem

CoolItem

ExpandItem

ScrollBarCaret Tracker Tray

ToolTip

Control

Scrollable

Composite

TextList

Scale Slider ProgressBar Sash Button Label

Canvas

Group ViewFormCBanner Toolbar

ScrolledCompositeTabFolder CTabFolder

BrowserExpandBar

TableSpinner

DateTime

TreeCoolBarComboCCombo

Shell

GLCanvas

DecorationsCLabelLink StyledText TableCursor

IME

TreeColumn

Abb. 9–1

Die Widget-Hierarchy im

SWT. Von besonderer

Bedeutung sind die

Klassen Widget,

Control, Composite

und Shell, auf die wir

ausführlicher eingehen.

9 SWT, JFace und das Forms API24

Die Klasse Control

Seit Eclipse 3.4 kann man mit setRegion() einer Control-Instanz eineRegion-Instanz, um dem Bedienelement eine nicht-rechteckige Form zugeben.

Beispiel

Entsprechend muss in Methode createUITextUserName() auch eineCombo-Instanz anstelle einer Text-Instanz erzeugt werden. Außerdemfügen wir noch einen ModifyListener hinzu, der bei Änderungen imNamensfeld die OK-Taste aktiviert bzw. sperrt:

private void createUITextUserName() { // Create the text widget// fTextUsername = new Text(fCompositeLogin, SWT.BORDER); fTextUsername = new Combo(fCompositeLogin, SWT.BORDER); fTextUsername.addModifyListener(new ModifyListener() { public void modifyText(ModifyEvent e) { updateButtons(); } }); // Configure layout data... } private void updateButtons() { fButtonOK.setEnabled(fTextUsername.getText().length() > 0); }

Und schließlich fügen wir in der Methode init() noch das Setzen desFokus und die Logik für die Standardtaste ein:

public void init(final Shell splash) {... // Force the splash screen to layout splash.layout(true); // Fokus auf Namensfeld zwingen fTextUsername.setFocus(); // Standardtaste setzen splash.setDefaultButton(fButtonOK); updateButtons(); // Keep the splash screen visible and prevent the RCP // application from loading until the close button is clicked. doEventLoop(); }


259.2 JFace

9.1.11 Datentransfer

Transfertypen

Hinzugekommen ist mit Eclipse 3.4 der Transfertyp ImageTransfer, mitdem nun auch Bilder mit der Zwischenablage ausgetauscht werdenkönnen.

9.2 JFace

9.2.2 Dialoge und Fenster

Persistente Dialoge

Das Laden und Abspeichern der Werte erfolgt in den Methoden init-Fields() und persistFields(), die in die Methode init() der KlasseInteractiveSplashHandler eingefügt werden. Das Abspeichern erfolgtallerdings nur bei erfolgreicher Anmeldung. Außerdem achten wir dar-auf, dass die Liste nicht unbeschränkt wächst und dass keine Dublet-ten auftreten.

@Override public void init(final Shell splash) { // Store the shell super.init(splash); // Configure the shell layout configureUISplash(); // Create UI createUI(); // Create UI listeners createUIListeners(); // Felder initialisieren initFields(); // Force the splash screen to layout splash.layout(true); // Fokus auf Namensfeld setzen fTextUsername.setFocus(); // Standardtaste setzen splash.setDefaultButton(fButtonOK); // Tastenzustand aktualisieren updateButtons(); // Keep the splash screen visible and prevent the RCP // application from loading until the close button is clicked. doEventLoop(); // Persistente Werte speichern if (fAuthenticated) persistFields();

}


9.2.3 Viewer

Vie

wer

on

ICon

tent

Pro

vide

rIB

aseL

abel

Pro

vide

r

ITab

leLa

belP

rovi

der

ITre

ePat

hLab

elP

rovi

der

ctur

edC

onte

ntP

rovi

der

ITre

ePat

hCon

tent

Pro

vide

r

Sou

rceV

ie

Tabl

eVie

wer

List

Vie

wer

Com

boV

iew

er

Che

ckbo

xTab

leV

iew

erC

heck

boxT

reeV

iew

er

wer

ITV

iew

erLa

belP

rovi

der

Cel

lLab

elP

Ow

nerD

raw

Labe

lPro

vide

r

Sty

ledC

ellL

abel

Pro

vide

r

Del

egat

ingS

tyle

dCel

lLab

elP

rovi

der

Dec

orat

ingS

tyle

dCel

lLab

elP

rovi

der

RTUALC

olum

nLab

elP

rovi

der

Abb. 9–2

Die Viewer-Hierarchie. Die

unterbrochenen Pfeile

zeigen an, welche Label-

und ContentProvider

mit welchem Viewer

verwendet werden. Sind

für einen Viewer keine

Angaben vorhanden,

gelten die Pfeile der

Superklasse.


279.2 JFace

Mehrspaltige Viewer

Neu hinzugekommen mit Eclipse 3.4 ist eine ganze Hierarchie vonStyledCellLabelProvider-Klassen, mit denen auf einfache Weise Tabel-len- und Baumelemente angelegt werden können, deren Textebereichsweise unterschiedlich formatiert sein können. Anders als beiden bisherigen LabelProvidern, von denen unter Angabe des in derZelle repräsentierten Modellelements ein Text oder Icon abgefordertwird, wird hier die Tabellen- oder Baumzelle direkt angesprochen – siewird in Methode update() übergeben. Abhängig vom Modellelementder Zelle, das man mit getElement() erhält, kann dann die Zelle sehrweitgehend gestaltet werden.

BeispielIch zeige hier schon eine konkrete Implementierung eines Styled-CellLabelProvider, die später im Kapitel 14 zum Einsatz kommenwird. Dabei wird abhängig vom Typ des Modellelements entweder nureine spezielle Textfarbe mit setForeground() gesetzt, oder aber es wirddurch Aufruf der Methode createStyledText() ein komplexere Forma-tierung durchgeführt. Dort wird der Text aus seinen Bestandteilen(preposition und name) zusammengesetzt und den einzelnen Textberei-chen eine jeweils unterschiedliche Formatierung mittels einer StyleR-ange zugeordnet. Zu beachten ist, dass Einstellungen der Schriftart(Font) in Tabellen- bzw. Baumzellen ignoriert werden – man hat mitHilfe der StyleRange lediglich die Möglichkeit, Text- und Hinter-grundfarbe zu wählen.

Es folgt dann noch eine Reihe von Methoden, die in der Super-klasse CellLabelProvider definiert sind und hier überschrieben werden,um bestimmten Zellen mit einem Tooltip auszurüsten.

Außerdem lassen wir den ViewLabelProvider noch das InterfaceILabelProvider implementieren. Dies ist dann erforderlich, wenn imView Standardsortierer bzw. Standardkomparatoren verwendet wer-den, welche die getText()-Methode des ILabelProvider abfragen, umdie Textrepräsentation eines Elements zu erfahren.

class ViewLabelProvider extends StyledCellLabelProvider implements ILabelProvider { @Override public void update(ViewerCell cell) { Display display = cell.getControl().getDisplay(); Object obj = cell.getElement(); if (obj instanceof Project) cell.setText(((Project) obj).getName()); else if (obj instanceof Task) { Task t = (Task) obj;


Color taskColor = display.getSystemColor( (t.getEarlyStart().equals(t.getLateStart())) ? SWT.COLOR_RED : SWT.COLOR_DARK_GREEN); cell.setForeground(taskColor); cell.setText(((Task) obj).getName()); } else if (obj instanceof Requires) { Requires req = (Requires) obj; String name = req.getPrerequisite().getName(); Color reqColor = display.getSystemColor(SWT.COLOR_BLUE); createStyledText(cell, "after ", name, reqColor); } else if (obj instanceof Utilizes) { Utilizes uti = (Utilizes) obj; String name = uti.getUses().getName(); Color utiColor = display.getSystemColor(SWT.COLOR_DARK_YELLOW); createStyledText(cell, "uses ", name, utiColor); } else cell.setText(String.valueOf(obj)); super.update(cell); }

private void createStyledText(ViewerCell cell, String preposition,String name, Color main) {

Display display = cell.getControl().getDisplay(); Color gray = display.getSystemColor(SWT.COLOR_DARK_GRAY); Color background = cell.getBackground(); int l = preposition.length(); StyleRange weak = new StyleRange(0, l, gray, background); StyleRange bold = new StyleRange(l, name.length(), main, background); StyleRange[] styleRanges = new StyleRange[] { weak, bold }; cell.setStyleRanges(styleRanges); cell.setText(preposition + name); }

@Override public String getToolTipText(Object element) { if (element instanceof Task) { // Task erläutern Task t = (Task) element; long slack = t.getLateStart().getTime() - t.getEarlyStart().getTime(); return (slack == 0) ? NLS.bind("Task {0} is critical", t.getName()) : NLS.bind("Task {0} has a slack of {1} min", t.getName(), (slack / MILLISEC_PER_MINUTE)); } return null; } @Override


299.4 Ein GUI-Framework für die Beispielanwendung

public int getToolTipTimeDisplayed(Object object) { return 4000; } @Override public int getToolTipDisplayDelayTime(Object object) { return 500; } @Override public int getToolTipStyle(Object object) { return SWT.SHADOW_ETCHED_OUT; }

/* ILabelProvider-Methoden */

public String getText(Object obj) { // Textaufbereitung if (obj instanceof Project) return ((Project) obj).getName(); if (obj instanceof Task) return ((Task) obj).getName(); if (obj instanceof Requires) return "after " + ((Requires) obj).getPrerequisite().getName(); if (obj instanceof Utilizes) return "uses " + ((Utilizes) obj).getUses().getName(); return obj.toString(); } public Image getImage(Object element) { return null; } }

9.4 Ein GUI-Framework für die Beispielanwendung

9.4.3 Die View-Komponente

In der Methode commit() wird über die ManagedForm ein commit() für dieDetailseiten angestoßen. Da es im Rahmen dieser Operationen zumStart von asynchronen Jobs kommen kann, wird anschließend in der

Abb. 9–2

TreeViewer mit

StyledCellLabelPro-

vider, der formatierten

Text in den Baumknoten

erzeugt.


join()-Methode des JobManager gewartet, bis alle Jobs ausgeführt oderabgebrochen wurden. Dabei beschränken wir uns ausdrücklich aufJobs der Familie com.bdaum.planner.operation.

Aufräumen ... public void commit(boolean onSave) { if (form != null) form.commit(onSave); try { Job.getJobManager().join(OperationJob.OPERATIONJOBFAMILY, null); } catch (Exception e) { // Ignorieren } }


31

10 Jenseits von SWT

10.1 SWT-Erweiterungen

Nebula bietet jetzt auch ein Gantt-Chart-Widget an.

10.2 Skriptsprachen für Benutzeroberflächen

10.2.2 XML-GUI-Beschreibung in der Beispielanwendung

Zustandsdaten public Combo fTextUsername; public Text fTextPassword; public Button fButtonOK; // private Button fButtonCancel; private boolean fAuthenticated; /* GUI-Skript */ static { // Internationalisierung ResourceBundle bundle = ResourceBundle.getBundle( "com.bdaum.planner.splashHandlers.messages"); CookSwt.setSystemResourceBundle(bundle); } // CookSWT-Instanz // "this" wird als das Objekt übergeben, in dem alle // Variablen deklariert sind private CookSwt cookSwt = new CookSwt(this); // Im Skript verwendete Listener public ModifyListener modifyAction = new ModifyListener() { public void modifyText(ModifyEvent e) { updateButtons(); } }; public SelectionListener selectionAction = new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) {

10 Jenseits von SWT32

if (e.widget == fButtonOK) handleButtonOKWidgetSelected(); else handleButtonCancelWidgetSelected(); } };

In der init()-Methode wurden die Methoden createUI() und crea-teUIListeners() auskommentiert und stattdessen die Methode render-Script() eingefügt. Selbstverständlich können nun auch die von crea-teUI() und createUIListeners() aufgerufenen und nun überflüssiggewordenen Methoden auskommentiert werden.

@Override public void init(final Shell splash) { // Store the shell super.init(splash); // Configure the shell layout configureUISplash(); // Create UI //createUI(); // Create UI listeners // createUIListeners(); renderScript(); // Felder initialisieren initFields(); // Force the splash screen to layout splash.layout(true); // Fokus auf Namensfeld setzen fTextUsername.setFocus(); // Standardtaste setzen splash.setDefaultButton(fButtonOK); // Tastenzustand aktualisieren updateButtons(); // Keep the splash screen visible and prevent the RCP // application from loading until the close button is clicked. doEventLoop(); // Persistente Werte speichern if (fAuthenticated)

persistFields(); }

10.2.3 Andere Skriptsprachen

Aus der Groovy-Distribution benötigen Sie das Archiv groovy-all-1.5.6-jar (aus dem Ordner embeddable/) und aus der SwtBuilder-Distri-bution das Archiv groovy-swt-0.3.jar.


3310.2 Skriptsprachen für Benutzeroberflächen

Als Plug-in Version für das Plugin com.bdaum.groovyWrapper tragen Sieam besten »1.5.6« ein.

...

Zum Schluss wird noch der Fokus auf das Namensfeld gesetzt, dieStandardtaste gesetzt und deren Zustand anhand des Inhalts desNamensfeldes bestimmt.

import org.eclipse.swt.SWTimport org.eclipse.swt.widgets.*

def i = {bundle.getString(it)}def comp = guiBuilder.composite(parent) { gridLayout(numColumns:3) composite { gridData(style:"fill_both",horizontalSpan:3) } label(text:i('username')) { gridData(horizontalIndent:175) } namefield = combo(style:'border',text:username,items:items) { gridData(widthHint:175,horizontalSpan:2) onEvent(type:"Modify", closure:{ updateButtons() }) } label(text:i('password')) { gridData(horizontalIndent:175) } passwordfield = text(style:'border,password',text:password) { gridData(widthHint:175,horizontalSpan:2) } label(visible:false) okbutton = button(style:'push',text:i('ok')){ gridData(widthHint:80,verticalIndent:10) onEvent(type:"Selection", closure:{username = namefield.text; password = passwordfield.text; ok.widgetSelected()} ) } button(style:'push',text:i('cancel')){ gridData(widthHint:80,verticalIndent:10) onEvent(type:"Selection", closure:{cancel.widgetSelected()} ) }}namefield.setFocus()parent.setDefaultButton(okbutton)updateButtons()

def updateButtons() {okbutton.enabled = (namefield.text != '')}

Die Methode initFields() wird nun vor der Methode renderScript()aufgerufen und reduziert sich auf:

10 Jenseits von SWT34

private void initFields() { try { // DialogSetting laden settings.load(stateLocation); // Namensliste aus DialogSetting entnehmen previousNames = settings.getArray(NAMES); } catch (IOException e) { // Noch keine Daten vorhanden } if (previousNames == null) previousNames = new String[0]; if (previousNames.length > 0) name = previousNames[0]; }

10.2.5 Aufgabe

Der Groovy SwtBuilder ist in der Version 0.3 auf dem Stand vonEclipse 3.3. Das heißt, dass neuere und natürlich auch eigene Widgetsergänzt werden müssen. Untersuchen Sie, wie der SwtBuilder erweitertwerden kann, und fügen Sie die Unterstützung für das im Buch erstellteWidget DateInput hinzu.

10.3 Animation

Standardmäßig bietet das SWT kein API für Animationen. Allerdingsgibt es eine Reihe von Projekten zum Thema SWT-Animation, die auchschon etwas zu zeigen haben. So z. B. das SWT Animation Toolkit(http://nricheton.homeip.net), das timingframework-swt (https://ti-mingframework-swt.dev.java.net/) und die Standard Widget Graphicsfor Eclipse (http://www.alphaworks.ibm.com/tech/graphics). Für dieImplementierung eigener animierter Widgets steht die Display-Metho-de timerExec() zur Verfügung.


35

Teil IIIPersistenz

36


37

12 XML

Das eclipse.org-Produkt EclipseLink (früher Oracle TopLink) ist alseinheitliche Persistenzlösung für Java-Objekte konzipiert. Dabei kom-men als Speichermedium nicht nur relationale Datenbanken (sieheKapitel 14), sondern auch XML-Dateien in Frage, die über JAXBangesprochen werden.


39

13 Relationale Datenbanksysteme für Rich Clients

13.1 Die Eclipse Data Tools Platform

Derby ist als Plugin für Eclipse verfügbar und wird im Rahmen derGanymede-Distribution in der Version 10.3.1.4 ausgeliefert.

Installation

Für die Installation rufen Sie einfach die Funktion Help>SoftwareUpdates auf und gehen zur Seite Available Software. Dort expandierenSie den Knoten Ganymede Update Site und markieren unter DatabaseDevelopment den Knoten Data Tools Platform Enablement und unterEnabling Features den Knoten Apache Derby Core Feature. Anschlie-ßend betätigen Sie die Taste Install... . Nach der Installation muss neugestartet werden.

Datenbanktreiber

Nach dem Neustart der Plattform muss zunächst der Datenbanktreibereingerichtet werden. Dazu ruft man Window>Preferences>DataManagement>Connectivity>Driver Definitions auf. Hier sehen wir be-reits Einträge für die verschiedenen Treiber-Versionen. Wir werden dieTreiberversion 10.2 verwenden.

VerbindungsparameterBetätigen Sie hier zunächst die Taste Edit... . Unter dem Reiter Pro-perties tragen Sie als Connection URL den Wert»jdbc:derby:www.bdaum.de/rcp/planner« ein und als Database Nameden Wert »PLANNER«.

13 Relationale Datenbanksysteme für Rich Clients40

Datenbankverbindung

Wir benutzen nun die Werkzeuge des DTP, um eine Datenbankverbin-dung und eine Datenbank einzurichten und dann mit Hilfe von SQL inder Datenbank Tabellen aufzubauen und in die Tabellen Werte einzu-tragen. Dazu öffnen Sie zunächst die Database-Development-Perspek-tive. Auf der linken Seite der Workbench, dort, wo sonst der PackageExplorer zu finden war, sehen Sie nun den Datasource Explorer. Dortwählen Sie den Knoten Databases aus und rufen die KontextfunktionNew auf. Aus der nun erscheinenden Liste von Verbindungsprofilenwählen Sie Derby aus. Als Namen der neuen Datenbankverbindungtragen Sie »Planner« ein und betätigen dann die Taste Next.

Im folgenden Schritt tragen Sie unter Database location den Wert»www.bdaum.de/rcp/planner« ein. Die Datenbank wird dann imgleichnamigen Ordner im Eclipse-Installationsverzeichnis angelegtund die erzeugte URL ist identisch mit der, die wir bei der Installationder Datenbank angegeben hatten. Mit einem Klick auf die Taste TestConnection können Sie nun die Verbindung zur Datenbank überprü-fen. Ist dies erfolgreich, markieren Sie am besten noch die Option Con-nect every time the workbench is started. Dann können Sie mit Finishdas Einrichten der neuen Datenbank abschließen. Im Data SourceExplorer sollte nun die Baumstruktur der neuen Datenbank erschei-nen.

Abb. 13–1

Der Datenbanktreiber für

Derby ist fertig

eingerichtet. Passwort

und

Benutzeridentifikation

werden für den

eingebetteten Betrieb

nicht benötigt.


4113.2 DBMS in der Rich-Client-Anwendung

SQL

Im nächsten Schritt erstellen wir zwei SQL-Dateien mit den auszufüh-renden Kommandos. Dazu rufen Sie File>New>Other...>SQL Deve-lopment>SQL File auf. Als Projekt wählen Sie com.bdaum.planner,alsAbbildung 13-2: Definition einer neuen Datenbankverbindung(zweiter Schirm).

Als Dateinamen tragen Sie createUsers.sql ein. Als Database ser-ver type wählen Sie Derby_10.x, als Connection profile name Plannerund als Database name www.bdaum.de/rcp/planner.

13.2 DBMS in der Rich-Client-Anwendung

13.2.2 Ein eigenes Derby-Plugin

Die Angabe eines Classpath-JAR entfällt.

Das OSGi-Manifest des neuen Plugins müsste dann so aussehen:

Manifest-Version: 1.0Bundle-ManifestVersion: 2Bundle-Name: DerbyWrapper Plug-inBundle-SymbolicName: com.bdaum.derbyWrapperBundle-Version: 1.0.0Bundle-Activator: com.bdaum.derbywrapper.DerbyActivatorBundle-Vendor: bdaum industrial communications

Abb. 13–2

Definition einer neuen

Datenbankverbindung

(zweiter Schirm).

13 Relationale Datenbanksysteme für Rich Clients42

Require-Bundle: org.eclipse.core.runtime, org.apache.derby.core;bundle-version="[10.3.1,11.0.0)"Bundle-RequiredExecutionEnvironment: J2SE-1.5Bundle-ActivationPolicy: lazyExport-Package: com.bdaum.derbywrapper

13.4 Datenbankzugriffe für die Beispielanwendung

Die Angabe der Versionsnummer für das Plugins org.apa-che.derby.core kann entfallen, da wir nur noch eine einzige Version imEinsatz haben.


43

14 Objektrelationale Brücken

14.1 JPA

ImplementierungenDas Java Persistence API (JPA) [Ghadir2007] definiert allerdings nurdie Programmierschnittstelle für persistente Objekte und beinhaltetper definitionem keine Implementierung. Inzwischen gibt es einigeImplementierungen von JPA, darunter auch einige Open-Source-Imp-lementierungen:

• Die Referenzimplementierung von JPA ist im Rahmen der JEE-Referenzimplementierung GlassFish (https://glassfish.dev.java.net/) entstanden. Die beruht auf Oracles Community-ProduktTopLink Essentials. Im März 2007 hatte Oracle auch das volleTopLink-Produkt als Open-Source-Software an eclipse.orggespendet, wo es unter dem Namen EclipseLinkhttp://www.eclipse.org/eclipselink/ weiterentwickelt wurde. Dieerste offizielle Version von EclipseLink erschien zwei Wochennach der Freigabe von Eclipse 3.4. EclipseLink wurde auf OSGiumgestellt und dürfte sich deshalb gut in RCP-Anwendungeneinbinden lassen. Die Klassenladertricks, die noch bei TopLinknötig waren, gehören der Vergangenheit an. Damit stehtEclipse-Entwicklern eine leistungsfähige JPA-Implementierungmit Erweiterungen zur Verfügung. Insbesondere wurden zusätz-liche Datenquellen angeschlossen wie XML-Daten, nichtrelati-onale Datenbanken und WebServices. EclipseLink wird inZukunft die Rolle einer JPA-Referenzimplementierung im Pro-jekt GlassFish einnehmen.

• Auch Hibernate (http://www.hibernate.org) unterstützt JPA mitdem Hibernate EntityManager. Die Hibernate-Entwickler hat-ten maßgeblich an der Spezifikation von JPA mitgewirkt.

• Apache bietet unter dem Namen OpenJPA (http://openjpa.apa-che.org/) ebenfalls eine JPA-Implementierung an. Dieses Pro-

14 Objektrelationale Brücken44

dukt beruht auf BEAs Kodo, das an Apache gespendet wurde.Inzwischen wird OpenJPA von IBMs WebSphere ApplicationServer als Persistenz-Framework eingesetzt.

Dali Für die Entwicklung von JPA-basierten Anwendungen bieteteclipse.org mit dem Java Persistence API Tools, die ursprünglich unterdem Projektnamen Dali entwickelt wurden, einige nützliche Werk-zeuge an (http://www.eclipse.org/webtools/dali/main.php). Sie könnensich diese Werkzeuge direkt aus der Ganymede Update Site zu IhrerPlattform dazuinstallieren (in der Kategorie Java Development oderWeb and JEE Development). Zusätzlich benötigen Sie eine JPA Run-time, wie sie z.B. EclipseLink enthält. Diese muss über Window>Prefe-rences>JPA als Default JPA Implementation Library eingetragen wer-den. Dazu muss sie allerdings als User Library definiert worden sein.Ist das noch nicht der Fall, betätigt man den Hyperlink Configure userlibraries und definiert dann auf der Präferenzenseite User Librarieseine neue Bibliothek, welche die entsprechenden JARs enthält.

Anschließend ist man in der Lage, neue JPA-Projekte anzulegenund mit Hilfe der Views JPA Structure und JPA Details in der JPA-Per-spektive, vorhandenen oder neuen Java-Klassen JPA-Annotationenwie @entity oder @id hinzuzufügen. Wurde beim Anlegen des ProjektsVerbindung zu einer Datenbank aufgenommen und sind die Daten-bankschemata bereits definiert, so ist Dali in der Lage, die Persistenz-definitionen in den Java-Klassen mit den Datenbankschemata abzu-gleichen.

14.1.1 Die JPA-Architektur

...

In der Datei javax.persistence können <persistence-unit>-Elementemehrere Persistenzeinheiten definieren. Der Name der jeweiligen Per-sistenzeinheit wird beim Erzeugen einer EntityManagerFactory angege-ben. So repräsentiert jede EntityManagerFactory eine Persistenzeinheit.Dabei kann jede Persistenzeinheit individuell festlegen, mit welcherDatenbank und welcher JPA-Implementierung sie arbeitet.

...

Grundsätzlich müssen alle persistenzfähigen Klassen instrumentiert –oder im JPA-Lingo »enhanced« – werden. So müssen z.B. beim Ändernvon Objektfeldern automatisch SQL-Anweisungen an die Datenbankabgesetzt werden. Dazu wird in der Regel der Binärcode der jeweiligenKlasse modifiziert, ein Prozess, der auch Weaving genannt wird und


4514.1 JPA

sich aus der aspektorientierten Programmierung ableitet. Das kanndynamisch vor der ersten Ausführung geschehen oder aber statischz.B. direkt nach dem Übersetzen der Klasse. Wie genau, hängt von derjeweiligen Implementierung ab. Will man statisch arbeiten, ist es sinn-voll, den Enhancer in einen Ant-Job einzubauen und dem Projekt (inden Projekteigenschaften) als zusätzlichen (und letzten) Builder zuzu-ordnen. So wird automatisch nach dem Kompilieren von Klassen desProjekts auch ein Enhancer-Lauf durchgeführt.

Bei der dynamischen Instrumentierung arbeiten einige Implemen-tierungen mit der in Java 5.0 eingeführten Java-Agent-Technologie.Beim Start der Java Virtual Machine kann mit dem Kommandozeilen-parameter -javaagent eine JAR angegeben werden. Beim Start wirddann vor allem anderen die premain()-Methode der im JAR-Manifestspezifizierten Pre-Main-Klasse ausgeführt. OpenJPA verwendet dieseTechnologie, um vor dem Start einer Anwendung gegebenenfalls einenEnhancer-Lauf durchzuführen.

Auch EclipseLink verwendet diese Technologie, allerdings nur fürSpezialfälle. Normalerweise verwendet TopLink für 1:n-Beziehungendas Lazy Loading (d.h., abhängige Objekte werden nur dann von derDatenbank geladen, wenn sie tatsächlich benötigt werden) und für1:1- und n:1-Beziehungen das Eager Loading. Soll auch in diesen Fäl-len das Lazy Loading verwendet werden, so muss auch hier mit Wea-ving nachgebessert werden. Das kann statisch geschehen (EclipseLinkliefert den passenden Ant-Job gleich mit) oder aber dynamisch. Beinicht-OSGi-Anwendungen kann das wie bei OpenJPA mit Hilfe desKommandozeilenparameter -javaagent geschehen. In OSGi-Anwen-dungen ist das auf Grund der spezifischen Klassenladerarchitekturnicht möglich. In EclipseLink kann jedoch in diesen Fällen der jeweili-gen Persistenzeinheit die Eigenschaft

<property name="eclipselink.weaving" value="true" >

zugewiesen werden, um das dynamische Weaving zu aktivieren.

14.1.2 JPA in einer Rich-Client-Anwendung

EclipseLink

Um EclipseLink in unsere Anwendung einzubetten, erzeugen wir keinneues Plugin. Statt dessen werden die EclipseLink- und JPA-JARs di-rekt in das Datenmodell-Plugin eingebettet. Zunächst besorgen wiruns EclipseLink von der eclipse.org-Website http://www.eclip-se.org/eclipselink/. Nach dem Download entnehmen Sie den Ordnern


jlib/ und jlib/jpa/ die JARs eclipselink.jar und ja-vax.persistence_1.0.0.jar. Diese JARs importieren Sie in denProjektordner des Projekts com.bdaum.planner.core. Anschließend ge-hen Sie im Manifesteditor auf die Seite Runtime und fügen imAbschnitt Classpath die importierten JARs hinzu. Damit liegt nun Ec-lipseLink im Klassenpfad des Plugins. Außerdem fügen Sie noch derListe der Exported Packages das Package javax.persistence hinzu. Da-mit besteht dann später Zugriff auf die öffentlicheProgrammierschnittstelle des JPA von allen Klienten des Pluginscom.bdaum.planner.core aus.

Auf der Seite Dependencies fügen Sie noch das Plugincom.bdaum.derbyWrapper hinzu, denn EclipseLink benötigt Zugriff aufden Datenbanktreiber. Das OSGi-Manifest des Pluginscom.bdaum.planner.core müsste dann so aussehen:

Manifest-Version: 1.0Bundle-ManifestVersion: 2Bundle-Name: Core Plug-inBundle-SymbolicName: com.bdaum.planner.core;singleton:=trueBundle-Version: 1.0.0Bundle-Activator: com.bdaum.planner.core.CoreActivatorBundle-Vendor: bdaum industrial communicationsRequire-Bundle: org.eclipse.core.runtime, org.eclipse.core.commands;bundle-version="3.4.0", org.eclipse.core.databinding;bundle-version="1.1.0";visibility:=reexport, org.eclipse.core.databinding.beans;bundle-version="1.1.0";visibility:=reexport, org.eclipse.jface;bundle-version="3.4.0", com.bdaum.derbyWrapper;bundle-version="1.0.0"Bundle-RequiredExecutionEnvironment: J2SE-1.5Bundle-ActivationPolicy: lazyBundle-ClassPath: ., javax.persistence_1.0.0.jar, eclipselink.jarExport-Package: com.bdaum.planner.core, com.bdaum.planner.core.model, com.bdaum.planner.core.operations, javax.persistence

Aktivator Damit sind wir dann auch schon beim CoreActivator. Hier implemen-tieren wir die Methode getEntityManager(), die beim ersten Aufruf denwährend der gesamten Lebensdauer der Anwendung hinweg verwen-deten EntityManager erzeugt. Das erfolgt durch eine EntityManager-Factory, die seinerseits vom Bootstrap-Loader Persistence erzeugtwird. Die mitgegebene Map mit EclipseLink-spezifischen Eigenschaf-ten generieren wir aus den vom Derby-Plugin veröffentlichten Einträ-


4714.1 JPA

gen (siehe Abschnitt 13.2.2). Diese Eigenschaften ergänzen bzw. über-schreiben die Eigenschaften, die in der Datei persistence.xml definiertsind. Diese Datei wird während der Ausführung der Persistence-Methode createEntityManagerFactory() gelesen und analysiert.

private EntityManagerFactory entityManagerFactory; private EntityManager entityManager; public EntityManager getEntityManager() { if (entityManager == null) { // Von Derby vererbte Eigenschaften zur // Konfiguration der Persistenzeinheit Map<String, String> properties = new HashMap<String, String>(); properties.put("eclipselink.jdbc.driver", System.getProperty("com.bdaum.dbmsWrapper.dbDriver")); properties.put("eclipselink.jdbc.url", System.getProperty("com.bdaum.dbmsWrapper.dbUrl")

+ ";create=true"); properties.put("eclipselink.jdbc.user", System.getProperty("com.bdaum.dbmsWrapper.dbUser")); properties.put("eclipselink.jdbc.password", System.getProperty("com.bdaum.dbmsWrapper.password")); // EntityManager erzeugen entityManagerFactory = Persistence.createEntityManagerFactory(

"plannerUnit", properties); entityManager = entityManagerFactory.createEntityManager(); } return entityManager; }

In der stop()-Methode des Aktivators schließen wir wieder alleEntityManager über die close()-Methode der EntityManagerFactory.

@Override public void stop(BundleContext context) throws Exception { //JPA if (entityManagerFactory != null) entityManagerFactory.close(); // OSGi-Services if (registration != null) registration.unregister(); // Plugin plugin = null; super.stop(context); }


Kommen wir zur Definition der Datei persistence.xml. Diese wird imOrdner META-INF/ abgelegt. Nach der Festlegung des Persistenz-Provi-ders werden alle Klassen aus dem Datenmodell aufgezählt, die persis-tent gemacht werden sollen. Auch die abstrakte Klasse PlannerItemmuss angegeben werden, denn sie vererbt Eigenschaften auf die ande-ren Klassen. Anschließend erfolgt die Definition einiger EclipseLink-spezifischer Eigenschaften. In der Eigenschaft eclipselink.ddl-genera-tion wird festgelegt, dass EclipseLink Datenbanktabellen erzeugensoll, wenn sie noch nicht existieren, und die erforderlichen SQL-Anweisungen aus der Struktur der Java-Klassen ableiten soll. Damitersparen wir uns die manuelle Erstellung der Tabellen. In der Eigen-schaft eclipselink.logging.level wird der Detaillierungsgrad des Pro-tokolls festgelegt. Bei der Entwicklung eignen sich FINE, FINER undFINEST, später beim Einsatz sollte man auf SEVERE zurückschalten, denneine feiner Protokollierung wirkt sich bremsend aus. Eine vollständigeAuflistung dieser Eigenschaften finden Sie unterhttp://wiki.eclipse.org/Using_EclipseLink_JPA_Extensions_(ELUG)#Using_EclipseLink_JPA_Extensions_for_Customization_and_Optimization.

<?xml version="1.0" encoding="UTF-8"?><persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0"> <persistence-unit name="plannerUnit"> <class>com.bdaum.planner.core.model.PlannerItem</class> <class>com.bdaum.planner.core.model.Planner</class> <class>com.bdaum.planner.core.model.Resource</class> <class>com.bdaum.planner.core.model.Project</class> <class>com.bdaum.planner.core.model.Task</class> <class>com.bdaum.planner.core.model.Requires</class> <class>com.bdaum.planner.core.model.Utilizes</class> <properties> <property name="eclipselink.ddl-generation" value="create-tables" /> <property name="eclipselink.logging.level" value="FINE" /> </properties> </persistence-unit></persistence>


4914.2 Ein Plugin zur Ressourcenverwaltung

14.2 Ein Plugin zur Ressourcenverwaltung

14.2.1 Plugin-Manifest

Die Angabe eines Classpath-JAR entfällt.Das OSGi-Manifest müsste nun so aussehen:

OSGi-ManifestManifest-Version: 1.0Bundle-ManifestVersion: 2Bundle-Name: Supervisor Plug-inBundle-SymbolicName: com.bdaum.planner.supervisor; singleton:=trueBundle-Version: 1.0.0Bundle-Activator: com.bdaum.planner.supervisor.SupervisorActivatorBundle-Vendor: bdaum industrial communicationsRequire-Bundle: org.eclipse.ui, org.eclipse.core.runtime, com.bdaum.planner;bundle-version="1.0.0", com.bdaum.planner.core;bundle-version="1.0.0"Bundle-RequiredExecutionEnvironment: J2SE-1.5Bundle-ActivationPolicy: lazy

14.3 Das Plugin für die Projektplanung

14.3.4 Der View

Abb. 14–2

Die Tasks-Perspektive.

Zunächst wird ein Projekt

definiert, zum Projekt

dann Tasks und

schließlich zu jedem Task

Prärequisiten und

Ressourcenallokation.


51

15 Andere Persistenzoptionen

15.1 Objektorientierte Datenbanken

Die inzwischen verfügbare Version 7.2 von db4o enthält auch eineUnterstützung für OSGi, die allerdings derzeit für eine RCP-Konfigu-ration nicht geeignet ist. Am besten importieren Sie das JAR db4o-7.2.xx.yyyyy-java5.jar. auch dem lib/-Ordner der db4o-Distributionin das Projekt com.bdaum.planner. Im Manifest dieses Projekts fügen Sieauf der Seite Runtime das JAR dem Abschnitt Classpath hinzu.

In der Klasse PlannerActivator, die den Lebenszyklus der Anwen-dung verwaltet, erzeugt man sich dann eine Instanz des Datenbanksys-tems, wie im nächsten Abschnitt in der Methode initDb4o() gezeigt.(Die Methode kann von der start()-Methode des Plugins aufgerufenwerden.) Anschließend kann gleich die Datenbank auf vorhandeneUser-Einträge abgefragt werden. Falls keiner existiert, wird ein neuerBenutzer mit dem Namen admin angelegt und mit der Methodestore() gespeichert. Das Ende einer Transaktion wird mit derMethode commit() gekennzeichnet, erfolgt aber auch beim Schließender Datenbank mit close(). In einer RCP-Umgebung würde man dieDatenbank in der stop()-Methode des Anwendungs-Plugins wiederschließen.

15.1.1 Prototypen

Bei der Abfrage verwendet db4o eine Prototyp-Technik. Dabei wirdeine Instanz des gewünschten Datensatzes erzeugt, wobei nur dieWerte spezifiziert werden, welche die Suche einschränken sollen.

15 Andere Persistenzoptionen52

Abfrage private ObjectContainer db;

private void initDb4o(String file) { db=Db4o.openFile(file); User u = new User(null, null, null); if (!db.queryByExample(u).hasNext()) { ArrayList<String> roles = new ArrayList<String>(1); roles.add("Administrator"); User user = new User("admin", "password", roles); db.store(user); db.commit(); } }public void stop(BundleContext context) throws Exception { if (db != null) { db.close(); db = null; } super.stop(context); plugin = null;}

Um db4o zur Prüfung der Zugangsdaten zu verwenden, implementie-ren wir die Methode loginOnDb4o(), die wir von der Methode login()aus aufrufen. Auch hier wird für die Abfrage erst ein Prototyp aufge-baut, wobei allerdings Name und Passwort spezifiziert werden. Danach dem Log-in die Datenbank nicht mehr benötigt wird, wird siegleich wieder geschlossen.

Qualifizierte Abfrage public User loginOnDb4o(String username, String password) { try { User p = new User(username, password, null); ObjectSet<?> result = db.queryByExample(p); if (result.hasNext()) user = (User) result.next(); return user; } finally { db.close(); db = null; } }

Abfragen Statt mit Prototypen kann auch mit Querys gearbeitet werden. Queryssind Java-Objekte, die Schritt für Schritt aufgebaut werden müssen.Das ist zwar etwas mehr Tipparbeit, auf der anderen Seite aber gibt esbei dieser Methode keine Syntaxfehler, die erst zur Laufzeit bemerktwerden (wie bei SQL, JPA oder Hibernate). Hier haben wir als Beispieldie Methode loginOnDb4o() mit Hilfe der Query-Technik realisiert:


5315.1 Objektorientierte Datenbanken

Komplexe Abfrage public User loginOnDb4o(String username, String password) { try { Query query=db.query(); query.constrain(User.class); query.descend("name").constrain(username); query.descend("password").constrain(password); ObjectSet<?> result=query.execute(); if (result.hasNext()) user = (User) result.next(); return user; } finally { db.close(); db = null; } }


55

16 Das Graphical Editing Framework

Seit GEF 3.4 enthält GEF mit Zest eine weitere Komponente. Zest isteine Programmbibliothek, mit der auf einfache Weise Graphen visuali-siert werden können (siehe Abschnitt 16.4a).

16.4 Beispielanwendung: Gantt-Chart mit GEF

16.4.1 GEF installieren

GEF ist möglicherweise bereits in Ihrer Eclipse-Installation enthalten.Allerdings benötigen wir hier das GEF-SDK und nicht nur die Run-time-Version. Sie können sich dieses SDK von der GEF-Website(http://www.eclipse.org/gef/) herunterladen. Nehmen Sie am bestendas All-in-one-Paket. Die GEF-Versionsnummer muss immer zur Ver-sionsnummer Ihrer Eclipse-Installation passen, also 3.4.0 zu 3.4.0,3.4.1 zu 3.4.1 oder 3.4.2 zu 3.4.2.

Entpacken Sie dann die ZIP-Datei in einen Unterordner GEF/, denSie im dropins/-Ordner Ihrer Eclipse-Installation anlegen. Nach einemNeustart können Sie dann mit GEF arbeiten.

16.4a Ein Graph mit Zest

Zest gehört seit Eclipse 3.4 zum GEF-Paket dazu. Vorher wurde esintern innerhalb von Mylin eingesetzt.

Zest-Klassen können ähnlich wie SWT-Widgets (siehe Abschnitt9.1) verwendet werden. Dabei ist die Anzahl der Zest-Widgets erfreu-lich gering:

16 Das Graphical Editing Framework56

Dazu kommen noch verschiedene Layout-Algorithmen und auf höhe-rer Ebene auch noch Zest-Viewer, welche die »V«-Komponente imMVC-Entwurfsmuster (Model-Viewer-Controller) implementieren.

Beispiel Ich möchte hier einige Grundfunktionen von Zest an einem klei-nen Beispiel erläutern. In einem weitere View, den wir als Fast Viewgestalten, bilden wir das jeweils ausgewählte Projekt als Graph ab.Dazu müssen zunächst die Plugins org.eclipse.zest.core undorg.eclipse.zest.layouts zu den Dependencies des Projektscom.bdaum.planner.taskplanner hinzugefügt werden, und auch zur Listeder Plugins im Project Planner Platform Feature.

Im Manifest des Projekts com.bdaum.planner.taskplanner legen wir eineweitere Erweiterung zum Erweiterungspunkt org.eclipse.ui.views an:den View com.bdaum.planner.taskplanner.views.GraphView mit dergleichnamigen Klasse als Implementierung.

<view class="com.bdaum.planner.taskplanner.views.GraphView" fastViewWidthRatio="0.6" icon="icons/graph.gif" id="com.bdaum.planner.taskplanner.views.GraphView" name="Graph" restorable="true"/>

Den View fügen wir mit einer Erweiterung zum Erweiterungspunktorg.eclipse.ui.perspectiveExtensions zur Taskplanner-Perspektivehinzu:

<extension point="org.eclipse.ui.perspectiveExtensions"> <perspectiveExtension targetID="com.bdaum.planner.taskplanner.perspective"> <view id="com.bdaum.planner.taskplanner.views.GraphView" minimized="false" ratio="0.6" relationship="fast"

relative="com.bdaum.planner.taskplanner.views.TaskView" visible="true"/> </perspectiveExtension> </extension>

In der Klasse GraphView wird zunächst in der Methode createPartCon-trol() als Behälter für den Graphen ein Graph-Objekt angelegt. Dieseswird mit setConnectionStyle() so konfiguriert, dass alle Verbindungen

Graph enthält den gesamten Graph.

GraphContainer wird für geschachtelte Grafen verwendet und kann GraphNodes und andere GraphContainers enthalten.

GraphNode repräsentiert einen Knoten im Graph.

GraphConnection repräsentiert eine Verbindung zwischen zwei Knoten.



zwischen Knoten als gerichtet interpretiert werden, sofern es die ein-zelne Verbindung nicht anders bestimmt.

Vom zentralen Selektionsservice holen wir uns dann die aktuelleSelektion im TaskView, registrieren uns aber gleichzeitig als ISelec-tionListener, um über Selektionsänderungen informiert zu werden. Jenach Selektion wird dann das aktuelle Projekt als Graph aufgebaut.

package com.bdaum.planner.taskplanner.views;import java.util.HashMap;import java.util.Map;import org.eclipse.jface.viewers.ISelection;import org.eclipse.jface.viewers.IStructuredSelection;import org.eclipse.swt.SWT;import org.eclipse.swt.graphics.Color;import org.eclipse.swt.widgets.Composite;import org.eclipse.swt.widgets.Display;import org.eclipse.ui.ISelectionListener;import org.eclipse.ui.ISelectionService;import org.eclipse.ui.IWorkbenchPart;import org.eclipse.ui.part.ViewPart;import org.eclipse.zest.core.widgets.Graph;import org.eclipse.zest.core.widgets.GraphConnection;import org.eclipse.zest.core.widgets.GraphNode;import org.eclipse.zest.core.widgets.ZestStyles;import org.eclipse.zest.layouts.LayoutStyles;import org.eclipse.zest.layouts.algorithms.SpringLayoutAlgorithm;import com.bdaum.planner.core.model.Project;import com.bdaum.planner.core.model.Requires;import com.bdaum.planner.core.model.Task;import com.bdaum.planner.core.model.Utilizes;

public class GraphView extends ViewPart { // Der gesamte Graph private Graph g; // Zuordnung von Graphknoten zu Modellelementen (Tasks) private Map<Object, GraphNode> nodeMap = new HashMap<Object, GraphNode>(); @Override public void createPartControl(Composite parent) { // Graph als Behälter anlegen g = new Graph(parent, SWT.NONE); g.setConnectionStyle(ZestStyles.CONNECTIONS_DIRECTED); // Beim zentralen Selektionsservice anmelden ISelectionService selectionService = getSite().getWorkbenchWindow().getSelectionService(); // Auf Selektionsänderungen reagieren selectionService.addSelectionListener(new ISelectionListener() { public void selectionChanged(IWorkbenchPart part, ISelection selection) {


if (part != GraphView.this) setSelection(selection); } }); // Aktuelle Selektion holen ISelection selection = selectionService.getSelection(TaskView.ID); setSelection(selection); }

@Override public void setFocus() { g.setFocus(); }

private void setSelection(ISelection selection) { if (selection instanceof IStructuredSelection) { Object selected = ((IStructuredSelection) selection) .getFirstElement(); // Graph leeren disposeNodes(); // Selektion auf Projekt abbilden if (selected instanceof Requires) selected = ((Requires) selected).getParent(); if (selected instanceof Utilizes) selected = ((Utilizes) selected).getParent(); if (selected instanceof Task) selected = ((Task) selected).getParent(); if (selected instanceof Project) fillGraph((Project) selected); } }

Für jeden Task legen wir ein GraphNode-Objekt an, das wir mit Hinter-grund- und Vordergrundfarbe entsprechend konfigurieren. Im Kon-struktor wird – ganz wie im SWT – das Elternobjekt (in unserem Fallder Graph) mitgegeben. Nachdem alle Knoten angelegt sind, könnendann die Verbindungen zwischen den Knoten in Form von GraphCon-nection-Instanzen erzeugt werden. Zum Schluss erhält der gesamteGraph einen SpringLayoutAlgorithm für das automatische Layout.Wichtig ist, dass dies – im Unterschied zum SWT – erst dann erfolgt,wenn alle Knoten und Verbindungen erzeugt wurden.

// Graph füllen private void fillGraph(Project project) { Display display = g.getDisplay(); Color white = display.getSystemColor(SWT.COLOR_WHITE); Color red = display.getSystemColor(SWT.COLOR_RED); Color darkGreen = display.getSystemColor(SWT.COLOR_DARK_GREEN); // Für jeden Task einen Knoten anlegen



for (Task task : project.getTasks()) { GraphNode n = new GraphNode(g, SWT.NONE, task.getName()); // Kritische Task rot, andere grün if (task.getEarlyStart().getTime() >= task.getLateStart().getTime()) n.setBackgroundColor(red); else n.setBackgroundColor(darkGreen); // Text weiss n.setForegroundColor(white); nodeMap.put(task, n); } // Verbindungen anlegen for (Task task : project.getTasks()) { GraphNode source = nodeMap.get(task); for (Requires req : task.getRequires()) new GraphConnection(g, SWT.NONE, source, nodeMap.get(req.getPrerequisite())); } g.setLayoutAlgorithm(new SpringLayoutAlgorithm( LayoutStyles.NO_LAYOUT_NODE_RESIZING), true); }

private void disposeNodes() { for (GraphNode node : nodeMap.values()) node.dispose(); nodeMap.clear(); }}

Abb. 16–6a

Fast View mit einem Zest-

Graph. Der View wird mit

einem Klick auf das zweite

Icon unten links geöffnet.

Der erzeugte Graph ist

interaktiv: Endbenutzer

können Knoten

auswählen und

verschieben.


16.5 Andere grafische Möglichkeiten

Für die Visualisierung von Projektplänen steht im Eclipse-Nebula-Pro-jekt (http://www.eclipse.org/nebula/) ein schickes GANTT-Chart-Wid-get zur Verfügung.


61

17 BIRT

17.1 Die Entwufsphase

17.1.1 Installation

BIRT benötigt eine Reihe weiterer Features wie z.B. GEF und EMF.Damit alles richtig zusammenpasst, installiert man BIRT 2.3.x am bes-ten von der Ganymede Update Site aus (Help>SoftwareUpdates>Available Software). Nach Expandieren der GanymedeUpdate Site markiert man die Charting and Reporting und betätigtdann die Taste Install... . Download und Installation wird eine Weiledauern.

Für eine Einbettung in eine Rich-Client-Umgebung ist allerdingsdieses Deployment nicht ausreichend. Laden Sie sich deshalb zusätz-lich noch von der BIRT-Website (http://www.eclipse.org/birt/phoenix/)die BIRT-Runtime (BIRT-Report-Engine) herunter. Zur Installationentpacken Sie die ZIP-Datei und bringen den Inhalt des OrdnersReportEngine/plugins/ in den neu anzulegenden Ordner dro-pins/BIRT/eclipse/plugins/ in Ihr Eclipse-Installationsverzeichnis. DasDerby-Plugin, das wir bereits installiert haben, können Sie weglassen.Nach einem Neustart sind die so installierten Plugins aktiv.

Anschließend sollten Sie das kurze Tutorial Help>Help Contents>BIRT Report Developer Guide>Field Guide to BIRT>Learning theBasics>Tutorial 1 durcharbeiten. Unter Help>Cheat Sheets…>BusinessIntelligence and Reporting Tools stehen einige interaktive Tutorialszur Verfügung.

17 BIRT62

17.1.2 Eine Datenquelle

...

Im nächsten Dialog wählen Sie aus der Liste Driver Class den EintragApache Derby Embedded Driver aus. Als Driver URL geben Sie denWert »jdbc:derby:.../runtime-planner.product/derbyDB«. Dabei istruntime-planner.product/ der Workspace-Ordner (Instance Location)Ihrer Test-RCP-Plattform (die drei Punkte sind durch den Pfad desübergeordneten Verzeichnisses zu ersetzen), der normalerweise direktneben dem normalen Workspace-Ordner liegt. Mit der Taste Test Con-nection... kann dann sofort getestet werden, ob ein Verbindungsauf-bau zur Datenbank möglich ist.

17.2 BIRT in einer Rich-Client-Anwendung

17.2.2 Berichte in einer RCP-Anwendung generieren und anzeigen

Die Angabe eines Classpath-JAR entfällt.Feature Um zu bestimmen, welche BIRT-Plugins und weitere zusätzliche

Plugins zu diesem Feature hinzugefügt werden müssen, schauen Siesich am besten den Inhalt des Ordners dropins/BIRT/eclipse/plugins/an. Mit Ausnahme des Plugins org.eclipse.birt.api, das wir nichtbenötigen, sollten Sie alle diese Runtime-Plugins im Feature auf derSeite Plug-ins aufzulisten. Natürlich können Sie auf alle die Pluginsverzichten, die bereits im Project Planner Platform Feature oder einemseiner Subfeatures enthalten sind. Allerdings ist eine doppelte Nen-nung auch nicht schädlich.

Außerdem müssen wir zum Feature die Pluginsorg.eclipse.core.resources und org.eclipse.core.filesystem hinzufü-gen, da die BIRT-Runtime von diesen Plugins abhängt. Damit diesePlugins auch zur Ablaufzeit aktiviert werden, müssen Sie außerdemdas Plugin org.eclipse.core.resource zu Dependencies des Plugincom.bdaum.planner.taskplanner.reports hinzufügen.

Damit haben wir mit Sicherheit mehr installiert, als wir brauchen,sind aber damit auch für spätere Änderungen gewappnet. Betätigen Sienun noch auf der Seite Dependencies des Feature-Manifest die TasteCompute. Hier dürften nun keine Plugins auftauchen, die nicht ineinem der Features unter Plug-ins and Fragments aufgelistet sind.

Anschließend führen Sie die Anwendung vom Produkteditor ausmit Synchronize und Run an Eclipse Application aus. Prüfen Sie danndas Error-Log in der Administrator-Perspektive auf fehlende Pluginsund überprüfen Sie unter Help>About>Plug-in Details, ob das Plugin


6317.2 BIRT in einer Rich-Client-Anwendung

com.bdaum.planner.taskplanner.reports installiert wurde. UnterHelp>About>Configuration Details bekommt man im Abschnitt Plug-in Registry genauere Information über den Zustand der verschiedenenBundles. So fehlen einem Bundle, das lediglich als INSTALLED markiertist, einige der benötigten anderen Bundles oder Packages, um aktiviertwerden zu können.

Die Installation eines solch komplexen Features wie BIRT benötigtetwas Geduld und Hartnäckigkeit. Haben Sie es eilig oder gar keinenErfolg, können Sie sich das Feature-Manifest auch von der Buch-Webseite herunterladen.


65

18 Elefantenhochzeit: Office-Komponenten unter Eclipse

18.1 OpenOffice einbetten

Die hier gezeigte Integration von OpenOffice beruht auf Open Office2.4.0.

18.1.5 Die Infrastruktur bereitstellen

Die Angabe eines Classpath-JAR entfällt. Das OSGi-Manifest wirddann etwa so aussehen:

Manifest-Version: 1.0Bundle-ManifestVersion: 2Bundle-Name: OOWrapper Plug-inBundle-SymbolicName: com.bdaum.OOWrapperBundle-Version: 2.4.0Bundle-Activator: com.bdaum.oowrapper.OOActivatorBundle-Vendor: bdaum industrial communicationsRequire-Bundle: org.eclipse.ui, org.eclipse.core.runtimeBundle-RequiredExecutionEnvironment: J2SE-1.5Bundle-ActivationPolicy: lazyBundle-ClassPath: classes/agenda.jar, classes/aportisdoc.jar, classes/bsh.jar, ... classes/xml-apis.jar, classes/XSLTFilter.jar, classes/XSLTValidate.jar, .Export-Package: com.bdaum.oowrapper

18 Elefantenhochzeit: Office-Komponenten unter Eclipse66

Die Klasse OO

.../** * Sichert das aktuell geladene Dokument * @return – true, wenn das neue Dokument geladen werden * kann */public boolean saveDocument() {

OfficeDocument doc = getDocument();if (doc == null)

return true;// Dateinamen holenString url;try {

url = doc.getURL();} catch (DisposedException e) {

// Nichts zu sichernreturn true;

}String filename = url.substring(OOFILEPROTOCOL.length());FileOutputStream fileOutput = null;...

18.2 Ein OpenOffice-View

18.2.1 Projekt anlegen


18.3 Office-Dateien generieren

Die Klasse ExportSpreadsheetAction

Zusätzlich zum Aufruf der ExportSpreadsheetOperation schalten wirhier auch noch auf die Controller-Perspektive um, sofern das für denaktuellen Benutzer erlaubt ist. Dazu holen wir uns zunächst von derPerspectiveRegistry der Workbench unter Angabe der Perspective-IDeinen PerspectiveDescriptor. Diesen setzen wir dann auf der aktivenWorkbenchseite als aktuelle Perspektive.

... public void run(IAction action) { ExportSpreadsheetOperation op = new ExportSpreadsheetOperation(projects); OperationJob.executeOperation(op, view, false);


6718.3 Office-Dateien generieren

// Auf Controller-Perspektive umschalten, falls für diesen Benutzer // erlaubt User user = PlannerActivator.getDefault().getUser(); if (user.getRoles().contains("Controller")) { IPerspectiveRegistry perspectiveRegistry = view.getSite() .getWorkbenchWindow().getWorkbench().getPerspectiveRegistry(); IPerspectiveDescriptor perspective = perspectiveRegistry .findPerspectiveWithId("com.bdaum.planner.calc.perspective"); view.getSite().getPage().setPerspective(perspective); } }


69

19 Ausgabe von PDF-Dateien

19.1 PDF-Dateien erzeugen


19.2 Ein PDF-Dokument anzeigen

<extension point="org.eclipse.ui.views"> <view category="com.bdaum.planner.viewCategory" class="com.bdaum.planner.taskplanner.pdf.PdfView" icon="icons/pdf.gif" id="com.bdaum.planner.taskplanner.pdf.PdfView" name="PDF" restorable="true"> </view> </extension>


71

Teil IVAdministration


73

20 Synchronisierung mit dem Server

20.2 Proprietäre Lösungen

20.2.5 db4objects dRS Replication System

Kommt auf dem Klienten das objektorientierte Datenbanksystemdb4o (siehe Abschnitt 15.1) zum Einsatz, so können die in diesemDatenbanksystem gespeicherten Objekte mit Hilfe des Produkts dRSReplication System mit einer Serverdatenbank synchronisiert werden.Voraussetzung ist, dass auf dem Server entweder auch db4o zum Ein-satz kommt, oder aber ein relationales Datenbanksystem zusammenmit der objektrelationalen Brücke Hibernate. Das System kann aufJava-5-Plattformen und .NET-Plattformen (diese nur mit db4o) einge-setzt werden. dRS verfügt die Möglichkeit, eigene Konfliktlösungsstra-tegien auf Objektebene einzubetten.

20.4 Lösungen unter Java

Das Funambol PIM & Email Bundle steht jetzt in der Version 6.5.14zur Verfügung.

20.5 Ein synchronisierter Task-Planer

Der SyncClient API Java J2SE steht nun in der Version 6.5.6 zur Ver-fügung. Die Quelldateien sind nicht mehr im Download enthalten,sondern stehen online in einem CVS (SourceTree) bereit.

20 Synchronisierung mit dem Server74

20.5.2 Das Sync-Projekt

Das Sync-Plugin

Die Angabe des Classpath-JAR entfällt.


7521 Konfiguration und Administration

21 Konfiguration und Administration

21.1 Benutzerauthentifizierung

Single Sign-OnEclipse 3.4 bietet nun im Rahmen des Plugins org.eclipse.equinox.se-curity eine Einbindung das Java Authentication and AuthorizationService (JAAS) an. Damit entfallen die bisherigen Klassenlader-Proble-me im Zusammenhang mit dem JAAS. Die Erweiterungspunktgruppeorg.eclipse.equinox.security.* erlaubt die Einbettung der entspre-chenden javax.security-Klassen.

~.loginConfigurationProvider Erlaubt die Angabe einer Unterklasse von javax.security.auth.login.Configu-ration, welche für eine gegebene Anwen-dung alle Login-Module in der auszuführen-den Reihenfolge auflistet.

~.loginModule Dieser Erweiterungspunkt dient der Registrie-rung der einzelnen Login-Module.

~.callbackHandler Erlaubt die Registrierung von Callback-Han-dlern vom Typ javax.secu-rity.auth.callback.CallbackHandler.

~.callbackHandlerMapping Ordnet die registrierten Callback-Handler be-stimmten Konfigurationen zu, so dass die Lo-gin-Module dieser Konfiguration mit Hilfe die-ser Handler auf Anwendungslogik zugreifen können.

~.secureStorage Hier kann eine Unterklasse von org.eclip-se.equinox.security.storage.provi-der.PasswordProvider angegeben wer-den. Diese Klasse liefert Passwörter, welche als Schlüssel für den gesicherten Equinox-Speicherbereich verwendet werden.

21 Konfiguration und Administration76

21.4 Fernwartung

Zukunft

Das Projekt Maya heißt jetzt Maynstall (http://www.eclipse.org/mayn-stall/).

22.4 Schutz intellektuellen Eigentums

Inzwischen ist ein erstes für die Plugin-Entwicklung geeigneter Obfus-cator erschienen. Das Produkt Obfuscate4e (http://obfuscate4e.part-master.de/) basiert auf proGuard and kann Features, Plugins oderganze RCP-Anwendungen verschleiern. Der Prozess kann automati-siert werden, indem der Verschleierungsschritt mit in den Build-Pro-zess der jeweiligen Projekte mit aufgenommen wird.


77

Anhang A: Wichtige Download-Adressen

Die Beispieldateien für dieses Buch finden Sie auf der Buch-Websiteunter http://www.bdaum.de/eclipse/buchRCP34.

Derby

AWL-Datenbank

Derby brauchen Sie nicht mehr separat von der Apache-Website herunterladen. Statt dessen können Sie die Gany-mede-Version verwenden.

JPA

Objektorientierte Persistenz

Als JPA-Lösung verwenden wir jetzt EclipseLink, das Sie un-ter folgendem URL erhalten: http://www.eclipse.org/eclipselink/

OpenOffice SDK http://download.openoffice.org/2.4.0/sdk.html


79

Anhang B: Erste Hilfe

Symptom: Wird die Anwendung von Eclipse aus gestartet, läuft alleswunderbar. Wird die Anwendung dagegen exportiert und separatgestartet, so treten Fehlfunktionen auf.

...

Ursache 2: entfällt.

------------------------------------------------------------------------------------------

Symptom: Bei feature-basierter Produktkonfiguration startet dieexportierte RCP-Anwendung nicht. Statt dessen erhalten Sie die Feh-lermeldung. »The Planner executable was unable to locate its compa-nian shared library «.

Ursache: Vermutlich wurde das plattformspezifische Fragment desEquinox-Launchers nicht installiert.

Therapie: Sie vermeiden diesen Fehler am sichersten, indem Sie dasFeature org.eclipse.rcp Ihrer Produktkonfiguration hinzufügen, syn-chronisieren und dann neu exportieren.


81

Anhang C: Lösungen zu den Aufgaben

Kapitel 10

Frage: Der Groovy SwtBuilder ist in der Version 0.3 auf dem Standvon Eclipse 3.3. Das heißt, dass neuere und natürlich auch eigene Wid-gets ergänzt werden müssen. Untersuchen Sie, wie der SwtBuildererweitert werden kann, und fügen Sie die Unterstützung für das imBuch erstellte Widget DateInput hinzu.

Antwort: Durch Anlegen einer entsprechenden Unterklasse von Swt-Builder können neue Sprachelemente in die Skriptsprache eingeführtund mit den Widget-Klassen verbunden werden:

package com.bdaum.planner.widgets;import groovy.swt.SwtBuilder;

public class ExtendedSetBuilder extends SwtBuilder { @Override protected void registerWidgets() { super.registerWidgets(); registerBeanFactory("dateInput", DateInput.class); }}


83

Anhang D: Relevante eclipse.orgProjekte

Das Projekt Maya heißt jetzt Maynstall.

Riena Platform Project

Riena ist ein Programmrahmen für die Realisierung von Client-Server-Anwendungen. Insbesondere erweitert es das OSGI-Service-Konzept, indem es auch entfernte Services transparent unterstützt. So können server- und client basierte Services leicht gegeneinander ausgetauscht werden. Zusätzlich wird auf der GUI-Seite eine Alternative zur generischen Workbench der Eclipse-RCP eingeführt. Riena ist zusammen mit EclipseLink teil der Eclipse Runtime Platform.


1

Index

A

Animationim SWT 34

artifacts.xml 16, 17, 19

B

BEA Kodo 44BIRT-Report-Engine 61BIRT-Runtime 61Bundle-Localization 14

C

Callback-Handlerin Java-Security 75

CellLabelProvider 27Classpath-JAR 3

Plugin als ~ 6content.xml 16, 17, 19Control 24

D

Dali 44Datasource Explorer 40Datenbanktreiber

einrichten 39Datenquelle

für BIRT 62db4o 51Derby 39dRS 73

E

Eager Loadingin JPA 45

Eclipse Modeling Framework 4

EclipseLink 37, 43, 44, 45EntityManager 46EntityManagerFactory 44EntityManagerFactory 46Equinox p2 Provisioning 16Extension Point 6

F

Funambol PIM & Email Bundle 73

G

Gantt-Chart-Widget 31GlassFish 43Graph 56GraphConnection 56GraphContainer 56GraphNode 56

H

Hibernate 43, 73

I

Identifikationenin Plugin-Manifesten 6

ILabelProvider 27ImageTransfer 25Inhaltsverzeichnis

Hilfe~ erstellen 9InteractiveSplashHandler 25

J

JAAS 75Java Authentication and Authorization Service 75Java Persistence API 43Java Persistence API Tools 44

Index2

-javaagentin JPA 45

javax.persistence 44Job-Familie 7, 30JobManager 30JPA 43

L

Lazy Loadingin JPA 45

M

ManagedForm 29MVC-Entwurfsmuster 56

N

Nebula 31

O

Obfuscate4e 76Obfuscator 76OpenJPA 43

P

p2-Direktor 19p2-Repositorium 16, 19Passwort

in Java-Security 75Persistence 46persistence.xml 48Persistenzeinheit

in JPA 44PerspectiveDescriptor 66PerspectiveRegistry 66Plug-in Spy 8Präferenzenschlüssel 13proGuard 76Protokoll

in EclipseLink 48Provisioning 16

Q

Querysin db4o 52

R

Region 24Replication System 73

S

SingletonPlugin als ~ 6

SQL-Dateienerstellen 41

StyledCellLabelProvider 27StyleRange 27SyncClient API Java J2SE 73

T

Teneo 4TOC-Editor 9TopLink 37, 43TopLink Essentials 43

U

Update-Site 16, 19

W

Weavingin JPA 44, 45

Z

Zest 55Zuordnungsdatei

Hilfe~ erstellen 9


Documents

Rich-Client-Entwicklung mit Eclipse 3.3 Update auf Eclipse 3 · ii Aktualisierung: Rich-Client-Entwicklung mit Eclipse 3.4 Plugin-Ensembles besser zu kapseln, was besonders für große