Eclipse Die-Plattform

eclipse_v01.book Seite 1 Montag, 30. Januar 2006 12:02 12

Kai Brssau (Hrsg.) Oliver Widder (Hrsg.) Herbert Brckner Martin Lippert Matthias Lbken Birgit Schwartz-Reinken Lars Wunderlich

Eclipse die Plattform



Kai Brssau (Hrsg.) Oliver Widder (Hrsg.) Herbert Brckner Martin Lippert Matthias Lbken Birgit Schwartz-Reinken Lars Wunderlich

die PlattformEnterprise-Java mit Eclipse 3.1


Kai Bssau / Oliver Widder (Hrsg.): Eclipse die Plattform Enterprise-Java mit Eclipse 3.1 Frankfurt, 2006 ISBN 3-935042-82-5

2006 entwickler.press, ein Imprint der Software & Support Verlag GmbH

http://www.entwickler-press.de http://www.software-support.biz

Ihr Kontakt zum Lektorat und dem Verlag: [email protected] Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet ber http://dnb.ddb.de abrufbar.

Korrektorat: Petra Kienle Satz: text & form GbR, Carsten Kienle Umschlaggestaltung: Melanie Hahn Belichtung, Druck und Bindung: M.P. Media-Print Informationstechnologie GmbH, Paderborn. Alle Rechte, auch fr bersetzungen, sind vorbehalten. Reproduktion jeglicher Art (Fotokopie, Nachdruck, Mikrofilm, Erfassung auf elektronischen Datentrgern oder andere Verfahren) nur mit schriftlicher Genehmigung des Verlags. Jegliche Haftung fr die Richtigkeit des gesamten Werks kann, trotz sorgfltiger Prfung durch Autor und Verlag, nicht bernommen werden. Die im Buch genannten Produkte, Warenzeichen und Firmennamen sind in der Regel durch deren Inhaber geschtzt.


Inhaltsverzeichnis1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 1.2 1.3 1.4 1.5 1.6 1.7 2 2.1 Was ist Eclipse? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Warum ein Buch ber Eclipse?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . An wen richtet sich dieses Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Was erwartet Sie in diesem Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Was bentigen Sie?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anforderungen an eine moderne IDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . Open Source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Perspektiven und Views von Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.1 Perspektiven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.2 Perspektiven auswhlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.3 Die Java-Perspektive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.4 Neues Java-Projekt erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.5 Package Explorer und View-Funktionen . . . . . . . . . . . . . . . . . . 2.1.6 Das Eclipse-Editorfenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.7 Outline View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.8 Tasks/Problems View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1.9 To be done Arbeiten mit Tasks. . . . . . . . . . . . . . . . . . . . . . . . . 2.1.10 Eigene Tasks definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hilfe in Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eclipse-Projekte individuell konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Vorhandenen Sourcecode ins Projekt Link to Source . . . . . . . . . 2.3.2 Projekteigenschaften definieren . . . . . . . . . . . . . . . . . . . . . . . . . Sourcecode-Editor-Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.1 Quick Fix auf Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.2 Automatische Getter/Setter-Erzeugung . . . . . . . . . . . . . . . . . . . 2.4.3 Sourcecode-Vervollstndigung (Code completion) . . . . . . . . . . 2.4.4 Try-Catch-Block-Generierung . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.5 Sourcecode-Templates verwenden . . . . . . . . . . . . . . . . . . . . . . . 2.4.6 Gimmicks des Editors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.7 Immer ein Undo fr die Vergangenheit. . . . . . . . . . . . . . . . . . . . Refactoring mit Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.1 berschreiben/Implementieren von Methoden. . . . . . . . . . . . . . 2.5.2 Auslagern von Zeichenketten/Mehrsprachigkeit . . . . . . . . . . . . Erstellung eines JUnit-Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 13 13 14 14 15 15 16 19 19 19 19 20 21 21 23 23 24 25 26 27 31 35 36 40 43 43 44 46 48 50 51 51 56 57 59

Wegweiser durch Eclipse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.2 2.3

2.4

2.5

2.6

5


Inhaltsverzeichnis

2.7

2.8

2.9

2.10

2.11

2.12 3 3.1 3.2

Debuggen in Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 2.7.1 Breakpoints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 2.7.2 Aufsetzen einer Launch configuration . . . . . . . . . . . . . . . . . . . . 64 2.7.3 Die Debug-Perspektive im berblick . . . . . . . . . . . . . . . . . . . . 67 2.7.4 Grundfunktionen des Debuggens . . . . . . . . . . . . . . . . . . . . . . . . 68 2.7.5 Allgemeine Hinweise zum Debuggen in Eclipse. . . . . . . . . . . . 69 2.7.6 Debug View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 2.7.7 Breakpoints, Watchpoints und Exceptioncatching. . . . . . . . . . . 75 2.7.8 Hot Code Replacement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Navigation im Sourcecode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 2.8.1 Javadoc View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 2.8.2 Navigation ber die Toolbar. . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 2.8.3 Suchfunktionen in Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 2.8.4 Open-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 Weitere Views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 2.9.1 Hierarchy View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 2.9.2 Call Hierarchy View. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 2.9.3 Declaration View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 2.9.4 Navigator View. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 2.9.5 Progress View. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Java 5 Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 2.10.1 Java 5 on board. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 2.10.2 Migration Java 1.4 nach 5.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 Customizing Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 2.11.1 Customizing perspective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 2.11.2 Eclipse individuell starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 Eclipse Preferences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 Einleitung ins Thema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . OMONDO EclipseUML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 Versionen von EclipseUML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.2 Download und Installation von Omondo EclipseUML . . . . . . . 3.2.3 Klassendiagramme erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . EMF/GEF und UML2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.1 Eclipse Modeling Framework (EMF) . . . . . . . . . . . . . . . . . . . . 3.3.2 Graphical Editing Framework (GEF). . . . . . . . . . . . . . . . . . . . . 3.3.3 UML2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 110 110 111 111 118 118 119 120

Eclipse als Modellierungswerkzeug. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

3.3

4

Qualittssicherung in Eclipse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 4.1 Einfhrung ins Thema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

6


Inhaltsverzeichnis

4.2

4.3

Wie uert sich ein Mangel an Qualitt? . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.1 Mangelnde Sourcecodetests . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.2 Mangelnde Tests der fachlichen Funktionalitt . . . . . . . . . . . . . 4.2.3 Eingeschrnkte Funktionalitt. . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.4 Begrenzte Sourcecode-Qualitt. . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.5 Reviews und Softwareuntersttzung. . . . . . . . . . . . . . . . . . . . . . Eclipse zur Qualittssicherung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.1 Testen mit JUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.2 Audits mit Checkstyle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.3 Sourcecode-Metrics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.4 Metrics 1.3.6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.5 Metrikreports und Graphen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.6 Ant-Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.7 Bleiben Sie kritisch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Aufgaben des Build Managements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vom Quellcode zum Programm: Build. . . . . . . . . . . . . . . . . . . . . . . . . . . Einstellungen des Eclipse-Build . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.1 Build Path-Einstellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.2 Compiler und JavaDoc-Einstellungen. . . . . . . . . . . . . . . . . . . . . 5.3.3 Automatische und manuelle Builds . . . . . . . . . . . . . . . . . . . . . . 5.3.4 Weitere Konfigurationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.5 Erzeugung anderer Ausgabetypen . . . . . . . . . . . . . . . . . . . . . . . Build Management und Versionierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4.1 Exkurs: Versionierung mit CVS in Eclipse. . . . . . . . . . . . . . . . . 5.4.2 Versionierung und Build Management . . . . . . . . . . . . . . . . . . . . Exkurs: Build Management mit Ant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5.1 Ant Projects, Targets und Tasks . . . . . . . . . . . . . . . . . . . . . . . . . 5.5.2 Typische Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5.3 Ein Ant-Beispielskript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5.4 Ant in Eclipse: externe Builds . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Visual Editor fr Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.1 Installation und Aufruf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.2 Hinzufgen von Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.3 Entfernen von Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.4 ndern von Eigenschaften einer Komponente . . . . . . . . . . . . . .

121 121 122 122 123 123 124 124 125 128 129 133 135 135 137 138 139 139 142 143 144 146 147 148 158 159 161 163 164 169 173 175 176 176 178 179 179

5

Build Management mit Eclipse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 5.1 5.2 5.3

5.4

5.5

5.6 6 6.1 6.2

GUI-Design mit Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

7


Inhaltsverzeichnis

6.3

6.4

6.5

6.6

6.2.5 Layouteinstellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.6 Ereignisverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Besonderheiten bei der Erstellung eines GUI mit Swing-Komponenten 6.3.1 Untersttzte Komponenten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3.2 Layoutmanager. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3.3 Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3.4 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das SWT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.1 Aufbau einer SWT-Applikation . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.2 SWT-Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.3 Layoutmanager. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.4 Ereignisverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Besonderheiten bei der Erstellung eines GUI mit SWT-Komponenten . 6.5.1 Untersttzte Komponenten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5.2 Layoutmanager. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5.3 Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5.4 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der WindowBuilder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.1 Installation und Aufruf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.2 Hinzufgen von Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.3 Entfernen von Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.4 ndern von Eigenschaften einer Komponente. . . . . . . . . . . . . . 6.6.5 Layouteinstellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.6 Ereignisverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.7 Codegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6.8 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1.1 Einfhrung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1.2 Bestandteile eines XML-Dokuments . . . . . . . . . . . . . . . . . . . . . 7.1.3 Plug-Ins fr das Bearbeiten von XML-Dokumenten . . . . . . . . . Webanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.1 Grundlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.2 Beispiel einer Webanwendung mit Servlets. . . . . . . . . . . . . . . . 7.2.3 Beispiel einer Webanwendung mit Java Server Pages . . . . . . . . Eclipse-Projekt Web Tools Platform (WTP) . . . . . . . . . . . . . . . . . . . . . . 7.3.1 Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3.2 Editoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3.3 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3.4 Einstellungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

180 181 182 183 183 184 187 206 206 208 222 232 235 235 235 237 239 242 242 244 245 245 245 247 248 251 264 264 265 270 275 275 276 281 283 283 284 285 286

7

Eclipse und J2EE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 7.1

7.2

7.3

8


Inhaltsverzeichnis

7.4

7.5

7.6

7.7

7.8

7.9

7.10

7.11

7.12

7.3.5 Entwicklung einer Webanwendung. . . . . . . . . . . . . . . . . . . . . . . 7.3.6 Beispielanwendung Kreditkartenprfer . . . . . . . . . . . . . . . . . . . 7.3.7 Server Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3.8 Lomboz Plug-In und WTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . J2EE-Anwendungen mit Enterprise Java Beans. . . . . . . . . . . . . . . . . . . . 7.4.1 Grundlegende Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4.2 Enterprise Java Bean (EJB). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4.3 Zugriff eines Clients auf eine EJB . . . . . . . . . . . . . . . . . . . . . . . Session Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.1 Bean-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.2 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5.3 Deployment-Deskriptor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konfiguration der WTP fr einen neuen Server . . . . . . . . . . . . . . . . . . . . 7.6.1 Server-Definitionsdatei jboss4.serverdef . . . . . . . . . . . . . . . . . . 7.6.2 7.6.2 Konfiguration der plugin.xml . . . . . . . . . . . . . . . . . . . . . . . 7.6.3 Konfiguration der plugin.properties . . . . . . . . . . . . . . . . . . . . . . Erstellung eines EJB-Projekts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7.1 Anlegen des Projekts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7.2 Erzeugen des EJB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7.3 Bean-Klasse und XDoclet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7.4 Einfgen einer neuen Methode in die Bean-Klasse . . . . . . . . . . Client fr den Remote-Zugriff auf eine EJB . . . . . . . . . . . . . . . . . . . . . . 7.8.1 Herstellung einer Verbindung zum JBoss-Namensdienst . . . . . . 7.8.2 Beispiel eines Java-Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.8.3 WTP zur Erstellung eines Java-Clients. . . . . . . . . . . . . . . . . . . . Webclient fr den Zugriff auf eine EJB . . . . . . . . . . . . . . . . . . . . . . . . . . 7.9.1 Lokaler Zugriff innerhalb derselben virtuellen Maschine . . . . . 7.9.2 Zugriff bei unterschiedlichen virtuellen Maschinen . . . . . . . . . . Datenbankzugriff aus einer EJB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.10.1 Einstellungen fr den Zugriff auf die MySQL-Datenbank . . . . . 7.10.2 Beispiel Onlineshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Entity Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.11.1 Grundlagen und Persistenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.11.2 Finder-Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.11.3 Entity Bean (Container Managed Persistence) . . . . . . . . . . . . . . 7.11.4 Entity Bean (BMP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Java Messaging Service und Message Driven Beans . . . . . . . . . . . . . . . . 7.12.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.12.2 Message Driven Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.12.3 Senden einer Nachricht an eine Message Driven Bean . . . . . . .

287 292 298 299 299 299 302 304 306 306 308 310 312 313 321 325 326 326 327 328 328 332 332 334 336 336 338 344 345 345 347 352 352 353 354 370 379 379 381 383

9


Inhaltsverzeichnis

8

Web Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 8.1 8.2 Grundlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.1 SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.2 WSDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.3 JAX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Entwicklung eines Web Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.1 Aufbau eines WSDL-Dokuments . . . . . . . . . . . . . . . . . . . . . . . 8.3.2 Erzeugen eines Web Service aus einem WSDL-Dokument. . . . 8.3.3 Entwicklung eines Clients fr den Web Service . . . . . . . . . . . . 8.3.4 Erzeugen eines WSDL-Dokuments aus einer Java-Klasse . . . . Everything is a plug-in. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . In die Tiefen der Oberflche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Outline View fr den Texteditor . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.3.1 Adapter: Dynamische Erweiterung von Klassen . . . . . . . . . . . . 9.3.2 Ein eigener Adapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.3.3 Alternative 1: berschreiben der Methode getAdapter . . . . . . . 9.3.4 Alternative 2: der Adapter Manager. . . . . . . . . . . . . . . . . . . . . . 9.3.5 Ein Extension Point wird geboren . . . . . . . . . . . . . . . . . . . . . . . 9.3.6 Schritt 1: Definition des Interface fr den Extension Point . . . . 9.3.7 Schritt 2: Definition des Extension Point. . . . . . . . . . . . . . . . . . 9.3.8 Schritt 3: Implementierung des Extension Point . . . . . . . . . . . . 9.3.9 Eine Extension fr den neuen Extension Point . . . . . . . . . . . . . Der eigene Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4.1 Nichts einfacher als ein eigener Texteditor . . . . . . . . . . . . . . . . 9.4.2 Wir erweitern den Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Und Action ...: Actions in der Eclipse Workbench (Teil 1). . . . . . . . . . . ... Einschub: Aufbau der Eclipse-Oberflche . . . . . . . . . . . . . . . . . . . . . Und Action ...: Actions in der Eclipse Workbench (Teil 2). . . . . . . . . . . 9.7.1 Ein Button mit persistentem Status . . . . . . . . . . . . . . . . . . . . . . Page Book View: ein Buch mit sieben Seiten . . . . . . . . . . . . . . . . . . . . . 9.8.1 Action Delegates oder Wie kommt man von auen in das Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Markers und Annotations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.9.1 Marker fr Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . OSGi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.10.1 Bundles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.10.2 Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.10.3 Die Benutzung eines Service . . . . . . . . . . . . . . . . . . . . . . . . . . . Fazit und Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 390 390 391 391 392 392 397 404 405 411 411 412 413 415 423 425 441 442 442 448 450 452 452 458 464 469 487 488 495 497 511 518 537 538 545 550 555

8.3

9

Plug-In-Entwicklung fr die Eclipse Workbench . . . . . . . . . . . . . . . . . . . . . 411 9.1 9.2 9.3

9.4

9.5 9.6 9.7 9.8

9.9 9.10

9.11

10


Inhaltsverzeichnis

10

Plug-In-Entwicklung fr das JDT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557 10.1 10.2 Soap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Apache Axis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2.1 Installation von Tomcat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2.2 Installation von Axis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Web Service Deployment Plug-In . . . . . . . . . . . . . . . . . . . . . . . . . . . Den Rahmen erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Funktionalitt implementieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eingabe der Konfigurationsparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.6.1 Speichern und Laden der Konfigurationsparameter . . . . . . . . . . Generierung von service.xml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Generierung eines Ant-Skripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ausfhren des Ant-Skripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das fertige Plug-In . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein Extension Point fr die Generierung von Clients . . . . . . . . . . . . . . . Einschub: Code-Analyse ber AST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine View zur Anzeige des Syntaxbaums . . . . . . . . . . . . . . . . . . . . . . . . Die Erzeugung von Java-Code ber AST. . . . . . . . . . . . . . . . . . . . . . . . . Ein Extension Point fr die Generierung von Clients (Fortsetzung) . . . . Die Implementierung des Extension Point . . . . . . . . . . . . . . . . . . . . . . . . Ein Generator fr SWT Clients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das SWT-Client-Generator-Plug-In . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Erzeugung von Java Code ber das Java Element API . . . . . . . . . . . So ganz nebenbei zum Schluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kapitelberblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.1.1 Themenberblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.1.2 Kapitelstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.1.3 Ziele des Kapitels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendungen auf Basis der Plug-In-Technologie . . . . . . . . . . . . . . . . . . 11.2.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2.2 Sidebar: Bundles versus Plug-Ins . . . . . . . . . . . . . . . . . . . . . . . . 11.2.3 Hello World. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2.4 Strukturierung von Anwendungen . . . . . . . . . . . . . . . . . . . . . . . 11.2.5 Tipps, Tricks und mgliche Fallen . . . . . . . . . . . . . . . . . . . . . . . Die Eclipse Rich Client Platform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3.2 Hello World. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3.3 Workbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3.4 Mens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3.5 Views und Editors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557 559 559 561 562 563 569 574 583 586 589 592 592 596 597 598 608 611 613 621 629 629 633 635 635 635 635 636 636 637 637 641 642 645 645 645 649 650 653

10.3 10.4 10.5 10.6 10.7 10.8 10.9 10.10 10.11 10.12 10.13 10.14 10.15 10.16 10.17 10.18 10.19 10.20 11 11.1

Eclipse als Rich Client Platform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635

11.2

11.3

11


Inhaltsverzeichnis

11.4

11.5 12 12.1

Weitere Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4.1 Swing und/oder SWT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4.2 Eclipse im Client-Server-Umfeld. . . . . . . . . . . . . . . . . . . . . . . . 11.4.3 Eclipse in der Projektpraxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4.4 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kapitelberblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1.1 Themenberblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1.2 Kapitelstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Refactorings im berblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Refactoring: Konvertiere Standalone-Anwendung in eine Single-Plug-In-Eclipse-Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3.2 Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3.3 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Refactoring: Extrahiere Bibliotheks-Plug-In . . . . . . . . . . . . . . . . . . . . . . 12.4.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.2 Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.3 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Refactoring: Extrahiere Erweiterungs-Plug-In . . . . . . . . . . . . . . . . . . . . 12.5.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.5.2 Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.5.3 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Refactoring: Verallgemeinere Extension-Point . . . . . . . . . . . . . . . . . . . . 12.6.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.6.2 Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.6.3 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Refactoring: Konvertiere Anwendung in RCP-Anwendung . . . . . . . . . . 12.7.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.7.2 Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.7.3 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Refactoring: Ersetze Swing-Fenster durch RCP-View . . . . . . . . . . . . . . 12.8.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.8.2 Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.8.3 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

655 655 656 657 659 659 661 661 661 662 662 663 663 663 666 666 666 667 667 668 668 668 671 671 672 672 673 673 673 674 675 676 676 676 677

Refactoring to Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661

12.2 12.3

12.4

12.5

12.6

12.7

12.8

12.9

Die Autoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679 Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683

12


1

Einleitung

von Lars Wunderlich

1.1

Was ist Eclipse?

Die Antwort auf die Frage, was Eclipse ist, lsst sich je nach Blickwinkel des Benutzers unterschiedlich beantworten. An dieser Stelle wollen wir die Eclipse-Grnder zitieren: Eclipse ist eine Open Source Community, deren Projekte sich auf die Bereitstellung einer erweiterbaren Entwicklungsplattform und die Erstellung von Applikationsframeworks zur Softwareentwicklung konzentrieren.1 Diese Beschreibung zeigt deutlich, dass man unter dem Begriff Eclipse mehr als eine IDE und Plattform versteht. Mittlerweile haben sich unter dem Label Eclipse eine ganze Reihe namhafter Softwarefirmen zusammengeschlossen, um auf einer gemeinsamen Basis sowohl Entwicklungsumgebungen als auch Richclient-Anwendungen und Plug-Ins fr die unterschiedlichsten Aufgabengebiete zu entwickeln. Sie werden untersttzt von einer inzwischen riesigen Community, die Eclipse fr eigene Zwecke erweitert, anpasst und in neue Produkte integriert.

1.2

Warum ein Buch ber Eclipse?

Eclipse hat in den letzten Jahren das Nischendasein einer einfachen Open Source-Entwicklungsumgebung verlassen. Immer mehr Entwickler in Unternehmen oder hobbymig zu Hause entdeckten Eclipse und mit Eclipse teilweise auch erstmalig die Programmiersprache Java. Als im Januar 2005 die erste Auflage dieses Buchs mit groem Erfolg eine interessierte Leserschaft fand, bewog uns das, dieses Buch schnell einem grndlichen Update zu unterziehen. Eclipse und Java entwickeln sich so schnell weiter, dass nur aktuell bleiben kann, wer sich mit bewegt. Gleiches gilt natrlich auch fr Eclipse selbst, dessen erste 3.2 Milestones Ende 2005 das Licht der Welt erblickten. Wir mchten Eclipse in diesem Buch sowohl als flexible Oberflche fr die Entwicklung von Unternehmensanwendungen als auch als Plattform fr eigene Erweiterungen vorstellen (Rich Client Platform). Erweiterungen sind dabei Plug-Ins oder selbst erstellte IDEs. Dieses Buch deckt dabei den objektorientierten Softwareentwicklungszyklus vom Design und der Modellierung in Eclipse, ber die Implementierung (Java, EJB, XML, JSP...) bis hin zum Testen, Debuggen und dem endgltigen Deployment der Anwendung ab. Dabei werden dediziert Tools und Frameworks vorgestellt, die auch eine Nutzung im professionellen Umfeld erlauben. Eines der herausragendsten Merkmale der Version 3.1 ist zweifelsohne die Untersttzung fr JDK 5.0, die wir auch in diesem Buch behandeln werden. Eclipse als Open Source-Produkt unterscheidet sich nicht nur im Preis von einer Reihe anderer kommerzieller Produkte, sondern in vielen Fllen auch im Leistungsumfang. In Unternehmen werden oftmals Enterprise-Produkte verwendet, die der Normalnutzer aus1. Einleitungssatz auf der Eclipse-Homepage http://www.eclipse.org

13


An wen richtet sich dieses Buch?

Kostengesichtspunkten nicht nutzen kann. In diesem Buch liegt der Fokus auf Tools und Plug-Ins, die als Open Source-Produkte sowohl beruflich als auch privat genutzt werden knnen. Viele dieser Werkzeuge lassen sich im Bereich der Evaluation, als reine Entwicklungsplattform, aber auch im produktiven Umfeld einsetzen. Manchmal werden auch kommerzielle Produkte vorgestellt. In diesen Fllen muss entschieden werden, ob der zustzliche Nutzen die entsprechenden Kosten rechtfertigt.

1.3

An wen richtet sich dieses Buch?

Das vorliegende Buch richtet sich an Leserinnen und Leser, die Eclipse 3.1 im Wesentlichen in greren Projekten, d.h. zumeist im Unternehmen, einsetzen oder darber nachdenken, dies zu tun. Wir gehen davon aus, dass bereits eine grobe Vorstellung von Eclipse vorhanden ist, also z.B. bekannt ist, wie ber die Eclipse-Webseite die IDE heruntergeladen werden kann, wie sie zu installieren ist und wie man einfache Aufgaben (Erstellung von Java-Projekten, Compile und Debugging) damit durchfhren kann. Implizit bedeutet dies auch, dass entsprechende Java-Kenntnisse (gegebenenfalls auch in den Java 5-Spracherweiterungen) vorausgesetzt werden, so dass beispielsweise der Unterschied zwischen einer abstrakten Klasse, einem Interface und einer Instanzvariablen keine Schwierigkeiten bereitet. Gleichzeitig kann dieses Buch aber auch als Entscheidungshilfe bei der Frage verstanden werden, unter welcher Oberflche zuknftig implementiert werden soll. Jenem Entwicklerkreis, dem Eclipse noch nicht bekannt ist, sei ein Blick auf die Homepage des Eclipse-Projekts1 empfohlen, um diese Umgebung, seine Community und die angebotenen Frameworks kennen zu lernen und sich mit den Basisfeatures vertraut zu machen. Fr jene, die sich leicht in neuen Softwareumgebungen zurechtfinden, aber noch nie Eclipse benutzt und keine Berhrungsngste beim Testen und Herumprobieren haben, ist dieses Buch gleichzeitig eine Art Jump Start. Es streift die einfachen Entwicklungsfeatures im ersten Kapitel, um sich mit Fragen professioneller Softwareentwicklung zu beschftigen. Im Gegensatz zu einer technischen Referenz, die den Anspruch erhebt, jede Checkbox in jedem Dialog detailliert zu dokumentieren, mchten wir die recht gute Online-Hilfe, die bei Eclipse als Dokumentation mitgeliefert wird, nicht noch einmal abschreiben. Vielmehr wollen wir interessante Punkte vertiefen oder die Mglichkeiten beim Einsatz von Plug-Ins bei der Entwicklung beschreiben. In jedem Fall empfiehlt sich ein Blick auf den aktuellen Stand von Eclipse auf der EclipseWebseite.

1.4

Was erwartet Sie in diesem Buch?

Dieses Buch ist in intensiver Zusammenarbeit einer Reihe von Autoren entstanden. Jeder von ihnen hat sein jeweiliges Know-how eingebracht und dabei Eclipse von unterschiedlichen Blickwinkeln aus prsentiert.1. http://www.eclipse.org

14


1 Einleitung

Teil 1 fhrt in die grundstzliche Verwendung von Eclipse ein. Es wird die IDE vorgestellt. Dies ist erforderlich, um sich die Untersttzung von Eclipse fr ein bestimmtes Themengebiet in den nachfolgenden Kapiteln genauer erarbeiten zu knnen. Teil 2 geht speziell auf Aufgabenstellungen in verschiedenen Arbeitsfeldern wie UMLModellierung, Model Driven Architecture, Versionsverwaltung, Konfigurations- und Buildmanagement, GUI-Design oder J2EE-Features ein. Teil 3 rundet das Buch ab, indem wir von der Entwicklung mit Eclipse zur Eigenentwicklung an Eclipse kommen. Wir untersuchen, wie man Eclipse als Startframework fr eigene Clients benutzen kann oder eigene Plug-Ins fr Eclipse zur Verfgung stellt.

1.5

Was bentigen Sie?

Zum Zeitpunkt der Erstellung dieses Buchs existiert Eclipse in Version 3.1.1 und in einer Milestone-Version 3.2. Da sich bei Milestones allerdings noch viel im Verlaufe der Entwicklung bis zum endgltigen Release ndern kann, konzentrieren wir uns in diesem Buch schwerpunktmig auf die 3.1.x-Version. Fr die Durchfhrung und den Test der Beispiele in diesem Buch ist Version 3.1.1 (bzw. hher wenn Sie selbst dies wnschen) der Eclipse-Entwicklungsumgebung erforderlich. Der Einsatz eines J2SE Entwicklungskits (JDK) in Version 1.4.2 oder hher ist sowohl fr die IDE selbst als auch fr die meisten Beispiele dabei ebenfalls empfehlenswert, wobei Eclipse mit der lteren 1.3-Version auch meist den Start verweigert. Wir werden in diesem Buch allerdings auch immer wieder auf die speziellen Java 5.0-Sprachfeatures eingehen, weshalb wir fr den Einsatz von Eclipse 3.1.1 auch ein entsprechendes JDK empfehlen. Weitere Tools und Plug-Ins werden in den folgenden Kapiteln verwendet und an der Stelle jeweils angegeben. Wir haben die englische Version von Eclipse genutzt, auf der auch die Beispiele und die Dokumentation aufbauen. Die Verwendung von Translation Packages zur Arbeit mit Eclipse z.B. in Deutsch steht dem Leser frei. Allerdings erschweren Oberflchen und Bcher, die englische Begriffe ins Deutsche bersetzen, oft das Verstndnis.

1.6

Anforderungen an eine moderne IDE

Die Frage, welche Anforderungen es bei der Auswahl einer Entwicklungsumgebung gibt, orientiert sich idealerweise an einer Liste von Features. Abhngig vom Budget wird so jedoch hufig die Freiheit erkauft, die Zahl der Features derart zu vergrern, dass eine teure Entwicklungsumgebung zur Verfgung steht, von der aber nur ein Bruchteil genutzt wird. Viele Entwickler haben bei der Auswahl einer Entwicklungsumgebung die Abb. des kompletten Entwicklungszyklus vor Augen. Dazu zhlen die Analysephase und die Dokumentation (soweit dies das Tool untersttzen kann), das objektorientierte Design bis hin zur Programmierung sowie die Themen Qualittssicherung oder Deployment. Am besten positionieren sich bei dieser Aufgabe zumeist jene Entwicklungsumgebungen, die in einem konkreten Produkt all diese Anforderungen abdecken oder um den Wnschen des Nutzers noch nher zu kommen sich diesbezglich beliebig erweitern lassen. Der Markt der Ent-

15


Open Source

wicklungsumgebungen ist recht gro, angefangen von kommerziellen Produkten bis hin zu reinen Open Source-Produkten wie Eclipse. Den Ansatz der individuellen Anpassbarkeit fr die Bedrfnisse (z.B. durch ein Plug-InKonzept) hat vermutlich Eclipse bisher als einziges Produkt vervollstndigt. Viele Produkte lassen sich mehr oder minder durch Plug-Ins erweitern. Im Vordergrund stehen aber oft Produktlinien wie Personal-, Professional- und Enterprise-Versionen. Jemand, der beispielsweise bei der Entwicklung einer Java EE-Anwendung Untersttzung sucht, soll mehr bezahlen als derjenige, der ausschlielich Standalone-Anwendungen erstellt. Open Source-Produkte verwenden diese Form der Marktsegmentierung in der Regel nicht. Der Ansatz bei der Entwicklung von Eclipse durch OTI/IBM im Gegensatz zu anderen IDEs war, das Gesamtprodukt als Bausteinsystem zu konzipieren, in das sich alle Funktionen als Komponenten integrieren lassen (siehe Kapitel Eclipse-Architektur). Wer eine Entscheidung ber die Auswahl der zuknftigen Entwicklungsumgebung treffen mchte, sollte stets die Wahl der Architektur und der Werkzeuge, die er dafr bentigt, bercksichtigen. Eclipse wandelte sich mit der Zeit auch immer mehr zur IDE fr weitere Sprachen wie C/C++, COBOL, Fortran, Groovy, Nice, LISP, C#, Jython/Python usw., um nur einige zu nennen. Die am besten untersttzte Sprache bleibt derzeit aber noch Java. Wenn es also um Java geht und wenn sich Komponenten und Funktionen der IDE an die jeweiligen Bedrfnisse anpassen lassen sollen, ist Eclipse sicherlich ein Kandidat der engeren Wahl. Die Anforderungen an eine moderne IDE hngen primr von den ganz persnlichen Bedrfnissen ab und ob ein Produkt alles knnen soll oder ob Medienbrche (Wechsel zwischen mehreren Produkten bei der Entwicklung) vom Benutzer als akzeptabel empfunden werden oder nicht. Am vorteilhaftesten ist es vermutlich, wenn man selbst entscheiden kann, welche Funktionen ber den Basisrhythmus wie Programmierung-Compile-Deployment hinaus fr das eigene Vorgehen noch bentigt werden. Wenn dies mit einer kostenlosen IDE (wie Eclipse) funktioniert, umso besser.

1.7

Open Source

Entgegen der Meinung vieler Projektverantwortlicher sind nicht unbedingt immer die teuersten Produkte die besten. Besonders die unter der Apache Group laufenden Jakarta-Subprojekte1 sprechen eine ganz andere Sprache und haben Produkte wie LOG4J, Struts, Hivemind oder Tomcat zur Welt gebracht, die auch in einer Reihe von kommerziellen Produkten als Subframeworks Einsatz finden. Der groe Vorteil fr Unternehmen liegt dabei weniger in der preislichen Attraktivitt als mehr im Vorhandensein des Produkt-Sourcecodes und Quasi-Standards. Besonders bei Problemen, bei denen die Dokumentation nicht mehr weiterhilft, kann die Untersuchung des Sourcecodes Support-Anfragen auch zuweilen ersetzen. Fr Unternehmen ist oft der Zeitfaktor im Projektmanagement erheblich drngender als der Kostenfaktor. Beide lassen sich ganz erheblich reduzieren, wenn eine Open SourceLsung gewhlt wird.1. http://jakarta.apache.org

16


1 Einleitung

Probleme mit Open Source-Produkten knnen dadurch entstehen, dass sie im frhen Stadium ihres Lebenszyklus noch nicht ausgereift sind. Das Risiko besteht dabei, dass die Weiterentwicklung nicht oder nur langsam erfolgt. Auerdem kann es vorkommen, dass ein Open Source-Produkt nach dem Erreichen eines Stadiums, in dem es schlielich effektiv eingesetzt werden kann, nur noch kommerziell vertrieben wird. Letztendlich muss jeder selbst entscheiden, welches Framework oder Produkt fr ihn am sinnvollsten erscheint. Die Mchtigkeit von Open Source-Produkten (auch professionellen) im Java-Sektor ist allerdings schon recht beeindruckend. Lassen Sie sich nun mitnehmen auf die Reise durch eine weltweit prmierte Open SourceEntwicklungsumgebung, durch die Tools und Utilities, die dafr geschrieben wurden, durch die Welt von objektorientierter Softwareentwicklung und Enterprise-Technologien. Willkommen in der Welt von Eclipse! Viel Spa beim Kennenlernen von Eclipse und beim Erobern neuer Horizonte! Lars Wunderlich

17



2

Wegweiser durch Eclipse

von Lars Wunderlich Zur besseren Orientierung auf der Oberflche von Eclipse wollen wir in diesem Kapitel mit einem Quickstart beginnen. Dieser berblick ber Eclipse beinhaltet im Gegensatz zu einer Referenz nicht jede Funktion, sondern nur jene, die bei der Arbeit vorrangig wichtig erscheinen. Nach dem Start von Eclipse fragt dieses nach einem Workspace-Verzeichnis fr seine eigenen Dateien. Wir klicken die Checkbox an, um das vorgeschlagene Verzeichnis zum Defaultdirectory zu erklren, und whlen danach OK. Sollten Sie eine alte Eclipse-Version installiert haben oder die Daten mit einer anderen Eclipse-Version teilen wollen (z.B. wenn Eclipse-Metadaten in einem Source-Control-System liegen), empfiehlt sich die Wahl eines entsprechenden, anderen Verzeichnisses. Eclipse begrt uns daraufhin mit dem Welcome-Bildschirm. Fr Neueinsteiger empfiehlt sich hier grundstzlich die Fhrung durch die einzelnen Tutorials, um die Oberflche kennen zu lernen. Wir mchten allerdings gleich in medias res gehen und klicken daher im Men WINDOW den Menpunkt OPEN PERSPECTIVE | JAVA an, um in die Java-Perspektive zu wechseln. Gegebenenfalls mssen Sie das Welcome-Fenster auch schlieen. Aus jeder beliebigen Ansicht lsst sich ber diese Menpunkte zurck in die Java-Perspektive wechseln.

2.1 2.1.1

Perspektiven und Views von Eclipse Perspektiven

Das Aussehen von Eclipse bzw. dessen Erscheinungsbild bei der Arbeit hngt im Wesentlichen von der Perspektive ab, die jeweils aktiviert ist. Eine Perspektive ist eine Sammlung von Fenstern (im Eclipse-Kontext als Views bezeichnet) und Menpunkten, die gemeinsam ein Themengebiet behandeln. Solche Themengebiete knnten das Editieren des Sourcecodes, das Debuggen, aber auch das Installieren von weiteren Plug-Ins sein. Grundstzlich knnen eigene Perspektiven wie in einer Art Baukasten zusammengestellt, angeordnet und fr weitere Verwendungszwecke gespeichert werden (siehe Abschnitt 2.11.1).

2.1.2

Perspektiven auswhlen

Zur Auswahl einer persnlichen Perspektive muss das Men WINDOW | OPEN PERSPECTIVE geffnet und dann die gewnschte Ansicht angeklickt werden. Fr das im Folgenden betrachtete Beispiel whlten wir die Java-Perspektive. Die jeweils aktuelle Perspektive ist dabei mit einem schwarzen Kreis markiert. Weitere Perspektiven (auch jene, die gegebenenfalls von Plug-Ins hinzugefgt werden) finden sich unter dem Menpunkt WINDOW | OPEN PERSPECTIVE | OTHER.

19


Perspektiven und Views von Eclipse

Die so genannte Shortcut-Bar, die Leiste der Schnellzugriffe, ist am rechten oberen Rand des Eclipse-Fensters angeordnet. In ihr befinden sich alle auswhlbaren und bereits einmal aktivierten Perspektiven. In der linken unteren Ecke sehen Sie Icons fr alle Views, die vom Benutzer in die Leiste gelegt wurden, um schnell zugreifbar zu sein.

2.1.3

Die Java-Perspektive

Die Standard-Java-Perspektive ist in Abb. 2.1 dargestellt. Die dort erscheinenden einzelnen Fenster bezeichnen wir als Views. Sie tragen die Beschriftungen Package Explorer, Outline oder Tasks und beschreiben einen konkreten Sachverhalt oder ein Problem der aktuellen Arbeit.

Abb. 2.1: Java-Perspektive

In Abb. 2.1 sehen wir oben die aus vielen Programmen bekannte Menzeile. Auf die einzelnen Funktionen wollen wir hier noch nicht eingehen. Wenn bereits Erfahrungen mit Eclipse vorliegen, sollte Ihnen bekannt sein, wie man die Such- und Startfunktionen fr Java-Programme aufruft und neue Klassen anlegt. Daneben finden sich hier alle wesentlichen Funktionen die Arbeit mit Projekten, Sourcecode-Modifikationen, Suchalgorithmen, die Konfiguration der kompletten Oberflche, das Hilfesystem und der WelcomeBildschirm, den wir bereits sahen.

20


2 Wegweiser durch Eclipse

Viele Funktionen aus den Mens kommen im Beispielprojekt zum Einsatz. Eine ganze Reihe von ihnen sind auch ber entsprechende Kontextmens oder eine spezielle Tastenkombination, die neben dem Namen des Menpunkts steht, verfgbar.

2.1.4

Neues Java-Projekt erzeugen

Zur Erstellung eines Java-Projekts whlen wir zunchst das Men FILE | NEW | PROJECT und klicken im nachfolgenden Dialog JAVA PROJECT und den Button NEXT an. Anschlieend geben wir einen Projektnamen ein (z.B. Testprojekt) und klicken den FINISH-Button an, um ein Java-Projekt mit Standardeinstellungen zu erzeugen. Auf der linken Seite der Java-Perspektive erscheint im PACKAGE EXPLORER das Projekt. ber das Kontextmen des Projekts und den Befehl FILE | NEW knnen Packages und Klassen zu dem Projekt hinzugefgt werden.

2.1.5

Package Explorer und View-Funktionen

Wie in Abb. 2.2 zu sehen, zeigt der Package Explorer die Projekte mit deren Packages sowie deren Elementen (Klassen, Interfaces, Methoden, Variablen etc. hier am Beispiel eines Ausschnitts der String-Klasse). Die Icons, die zur visuellen Untersttzung der Elemente angezeigt werden, sind abhngig von der View bzw. davon, welche Plug-Ins aktiviert und welche Label Decorators (siehe Abschnitt 2.12) zugelassen sind.

Abb. 2.2: Package Explorer

Viele Views verfgen ber eine eigene Toolbar (wie beispielsweise Package Explorer und Outline View), die sich direkt unter der Fenster-Namenszeile befindet und zumeist das Aus-

21



sehen und den Inhalt der jeweiligen View beeinflusst. Die Package Explorer View erlaubt dabei beispielsweise wie dargestellt die nachfolgenden Aktionen: BACK zeigt die Hierarchie, so wie sie direkt vor der aktuellen Anzeige ausgesehen hat. FORWARD zeigt die Hierarchie, wie sie direkt nach der aktuellen Anzeige ausgesehen hat. UP zeigt die Hierarchie des Elternobjekts der aktuell hchsten Resourcestufe. COLLAPSE fllt.ALL

schliet die aktuelle Baumansicht, indem der Baum in sich zusammen-

LINK WITH EDITOR aktiviert die Synchronisation zwischen dieser View und dem aktiven Editorfenster. Einzelne ausgesuchte Views besitzen zustzlich ein eigenes Funktionsmen, das ber den kleinen nach unten weisenden schwarzen Pfeil aktiviert wird. In diesen Mens befinden sich zumeist jene Aktionen, die es erlauben, die Anzeige dieser View weiter an die persnlichen Bedrfnisse anzupassen (Ein/Ausblenden bestimmter Inhalte, Wechsel der Strukturdarstellungen, ...).

Abb. 2.3: Fensterfunktionen

Mit einem Rechtsklick auf das Fenster-Icon knnen die Fensterfunktionen angezeigt werden (Abb. 2.3), wobei die Features (egal ob View oder nicht) stets gleichbleibend sind. Neben den klassischen Funktionen wie Minimierung (MINIMIZE), Maximierung (MAXIMIZE), Grennderung (SIZE) oder Schlieen (CLOSE) verfgen die Fenster zustzlich ber die Fhigkeit, sich mit anderen in einem so genannten Stack zusammenfassen zu lassen. Ein Stack ist dabei eine Art Blattsammlung mit Registern (siehe Abb. 2.4).

Abb. 2.4: View Stack (Package Explorer ausgewhlt)

Per Drag&Drop kann entschieden werden, auf welchem Stack eine View abgelegt werden soll (docking). Neu geffnete Views werden automatisch einem Stack zugeordnet. Die Register der Views im Stack erscheinen am oberen Rand der jeweiligen View. Durch Klicken auf den Namen des entsprechenden Registers ffnet sich die zugehrige View. Views, die

22



nicht mehr in den Stack passen, knnen ber die Doppelpfeile am rechten Rand ausgewhlt und ber das Eingabefeld am oberen Rand sogar namentlich gesucht werden.VIEW

Als so genannte Fast Views werden View-Fenster bezeichnet, die ber den Menpunkt FAST in die Shortcut Bar auf der unteren linken Seite des Eclipse Fensters verbannt wurden. Beim Klicken auf deren Icon wird vorbergehend die entsprechende View eingeblendet. Durch Klicken in einen anderen Fensterbereich verschwindet sie wieder. ber die rechte Maustaste auf dem View-Icon kann die Fast-View-Anzeige wieder deaktiviert werden. Fr die Navigation zwischen Views und ihren Funktionen finden sich entsprechende Menpunkte und Tastatur-Shortcuts im Men WINDOW | NAVIGATION.

2.1.6

Das Eclipse-Editorfenster

Im Zentrum von Eclipse befindet sich der Editor bzw. das Editorfenster. Pro geffneter Datei existiert ein Editierfenster (siehe Abb. 2.5), wobei jeweils eines aktiv ist. In allen nachfolgenden Betrachtungen der Fhigkeiten des Eclipse Editors werden wir uns die Aktionen innerhalb dieses Fensters ansehen.

Abb. 2.5: Eclipse-Editorfenster und Outline View

2.1.7

Outline View

Auf der rechten Seite der Java-Perspektive erscheint die Outline View (Abb. 2.5). Sie visualisiert abhngig von der jeweils geffneten Datei deren Inhalte strukturell. Bei Anzeige einer Java-Datei werden darin die Hauptelemente (Variablen, Methoden, Konstruktoren), deren Attribute und Abhngigkeiten zu Superklassen angezeigt. Im Gegensatz zur Package Explorer-Ansicht kann hier die Klassenstruktur ganz individuell angezeigt werden. Dazu stehen folgende Funktionalitten in der Outline-View als Shortcuts zur Verfgung:

23



SORT Aktivierung/Deaktivierung der Sortierung innerhalb der Java-Elemente der Klasse HIDE FIELDS Ein-/Ausblenden von Instanz- und Klassenvariablen HIDE STATIC FIELDS AND METHODS Ein-/Ausblenden von Klassenelementen HIDE NON-PUBLIC MEMBERS Ein-/Ausblenden aller nicht ffentlichen Variablen/Methoden HIDE LOCAL TYPES Ein-/Ausblenden aller lokalen und anonymen Typen der Klasse LINK TO EDITOR (IM MEN) Synchronisation zwischen Editorfenster und dieser View GO INTO TOPLEVEL TYPE (IM MEN) ffnet die Ansicht des Baums auf Ebene der angezeigten KlasseHilfreich ist es, wenn alle Views einen in sich geschlossenen, konsistenten Zustand zeigen. Damit Outline View, Editor und Package Explorer dabei Bezug nehmen auf die gleichen Methoden und Klassen, aktiviert man in den beiden Views das doppelte File-Icon (link to editor). Danach fhren Klicks in einem der Fenster zur Synchronisation der Ansicht mit den verbleibenden.

2.1.8

Tasks/Problems View

Rechts unten finden sich in Eclipse standardmig die Tasks, Warnings und Errors. Dabei handelt es sich stets um zu erledigende Aufgaben, allerdings mit unterschiedlicher Prioritt. Im schlimmsten Fall zeigt die Problems View (siehe Abb. 2.6), dass ein komplettes Projekt nicht kompiliert werden konnte, weil einzelne Bibliotheken oder sogar das komplette Java Runtime Environment fehlt oder nicht an der gesuchten Stelle gefunden wurde. In einem anderen Fall werden Methoden, die als deprecated gekennzeichnet sind, aufgerufen, so dass bestimmte Klassen nicht kompiliert werden knnen. In der separaten Taskview (aktivierbar ber das Men WINDOW | SHOW VIEW | OTHER | BASIC | TASKS) knnen Hinweise angezeigt werden, was z.B. noch berarbeitet, getestet oder dokumentiert werden soll.

Abb. 2.6: Problems View zur Anzeige von Build-Problemen

Wie in jeder View kann auch in diesen beiden die Darstellung gefiltert werden. Durch Klick auf das Filternsymbol (die drei nach rechts weisenden Pfeile auf der Tasks/Problems View) erscheint ein Dialog, in dem individuell bestimmt werden kann, welche Informationselemente wichtig sind.

24


2 Wegweiser durch Eclipse Die Anzeige sollte sinnvollerweise eingeschrnkt werden. Hierzu sollte die Menge der gleichzeitig sichtbaren Fehler (LIMIT VISIBLE ITEMS TO) auf 500 reduziert werden und der Radiobutton ON ANY RESOURCE IN SAME PROJECT gewhlt werden. In diesem Fall werden pro angelegtem Eclipse-Projekt die Fehler angezeigt. Wenn externe Klassen, auf deren SourcecodeDebugging nicht verzichtet werden soll oder kann, in eigene Eclipse-Projekte ausgelagert werden, wird das Durcheinander in der Problem- und Task-Anzeige deutlich reduziert, allerdings belastet hufiges Wechseln zwischen den Projekten dann auch die Gesamtperformance der Anwendung. Darber hinaus besteht die Mglichkeit, durch die Definition von so genannten Working-Sets (Arbeitsmengen) die Menge der Klassen nochmals wesentlich einzuschrnken. Nur kann dies auch schnell zu Verwirrungen fhren.

2.1.9

To be done Arbeiten mit Tasks

Wird in einem Projekt konsequent modelliert und der Sourcecode von einem CASE-Tool generiert (siehe auch Kapitel 3 ber Modellierung), werden eine Flle von Klassen und Methoden erzeugt, deren Ausgestaltung (Implementierung und Erstellung entsprechender Dokumentation) vom Wohlwollen der Programmierer abhngt.

Abb. 2.7: Tasks View und TODO-Definitionen im Editorfenster

Eclipse erlaubt die Erfassung von so genannten Tasks. Hierzu wird im linken schraffierten Bereich des Editors die rechte Maustaste gedrckt, ADD TASK gewhlt und dann die noch auszufhrende Aufgabe beschrieben. Die neue Task befindet sich daraufhin in der Tasks View (siehe Abb. 2.7). Abgeschlossene Arbeiten knnen spter gelscht werden. Sollte die Taskview noch nicht angezeigt werden, lsst sie sich ber WINDOW | SHOW VIEW | OTHER... | BASIC | TASKS schnell herbeizaubern. Alternativ zu Standardkommentaren bietet Eclipse die Mglichkeit, durch Inline-Kommentare im Sourcecode solche Tasks selbst zu definieren und zu erzeugen. Diese Variante hat den Vorteil, dass die komplette Information im Sourcecode bereits enthalten ist und nicht verloren geht, wenn die Eclipse-Informationen nicht mit weitergegeben werden (z.B. zwischen Entwicklern). Dafr sind diese ToDos auch gleich projektweit fr alle sichtbar.

25



Hierzu wird einfach der Begriff TODO und dahinter die Beschreibung, was zu tun ist, in den Sourcecode-Kommentar geschrieben. Beim nchsten Speichern der Datei (+S) wird der Kommentar automatisch zu einer Task in der Taskliste. Dort kann er gegebenenfalls auch modifiziert werden, was sich gleich wieder auf den Sourcecode auswirkt. Eclipse selbst bedient sich dieser Funktionalitt auch gerne und erzeugt knstlich Kommentare mit dem Hinweis To do, wenn es beispielsweise Methoden automatisch generiert und daher Javadoc und Implementierung nicht vollstndig sein knnen.ToDos in den Sourcecode zu schreiben ist sehr angenehm und einfach und berlebt z.B. auch einen Eclipse-Absturz, bei dem hin und wieder leider auch manuell erfasste Tasks verloren gehen knnen. Wenn die Zahl der ToDo's (eigene und die von Kollegen) zu unbersichtlich wird, lassen sich auch eigene persnliche definieren. Vordefiniert sind TODO, FIXME und XXX.

2.1.10

Eigene Tasks definieren

Die Tasks bzw. die begrifflichen Definitionen, die zu einer Task fhren, knnen in einem Projekt vollkommen frei vergeben werden. Entweder wird dies in den Preferences eingestellt (siehe Abschnitt 2.12) oder man entscheidet sich, dass nur das einzelne Projekt auf diese Tasks reagieren soll (Kontextmen des Eclipse-Projekts im Package Explorer PROPERTIES | JAVA COMPILER | JAVA TASK TAGS siehe Abb. 2.8).

Abb. 2.8: Erstellen eigener Tasks ber Project-Properties Neben dem TODO-Tag sind andere Tags wie to be reviewed oder to be optimized in ihrem jeweiligen Kontext sinnvoll. Sehr interessant ist auch immer mitanzusehen, wenn ein Projekt beispielsweise aus dem JakartaUmfeld importiert wird, an welchen Hotspots die dortigen Autoren noch nicht gedreht haben.

26



2.2

Hilfe in Eclipse

Die Hilfe ist vor allem fr diejenigen interessant, die noch nie mit Eclipse gearbeitet haben. Wir haben sie bereits kurz nach der Installation von Eclipse in Form einer Reihe von Tutorials in der Welcome-Perspektive gesehen. Diese lsst sich bei Bedarf ber den Menpunkt HELP | WELCOME erneut anzeigen. Die Standard-Eclipse-Hilfe wird ber den Befehl HELP | HELP CONTENTS aktiviert. In zahlreichen Dialogen kann aber auch durch Drcken der -Taste eine kontextsensitive Hilfe aufgerufen werden, die einzelne Funktionen erlutert. Eclipse untersttzt zustzlich einen Mechanismus der sich Cheat Sheets nennt und den Benutzer durch eine Sequenz von definierten Schritten fhrt. Nach dem Abschluss jedes einzelnen Schritts schreitet das Cheat Sheet voran, wobei jeder Step automatisch ausgefhrt oder manuell durch den Benutzer durchzufhren ist. Die Tutorials in Eclipse untersttzen diese Cheat-Sheet-Technik, um beispielsweise die Entwicklung eines Hello-World-Beispiels in Eclipse zu prsentieren (HELP | CHEAT SHEETS...). Zu diesem Mechanismus gehrt auch eine Cheat Sheets View, die sich ber WINDOW | SHOW VIEW | OTHER | CHEAT SHEETS | CHEAT SHEETS aktivieren lsst. Beispielprojekt Arbeiten mit Regular Expressions Jedes klassische Buch ber Programmierung oder IDEs fngt mit dem berhmten HelloWorld-Beispiel an, das einen zwischen ein paar Minuten Aufwand und mehreren Anrufen beim entsprechenden Support Zeit kosten kann (eben auch je nach Sprache und Entwicklungsumgebung). Da es allerdings wenige Unternehmen gibt, die Hello-World-Programme auch kommerziell vertreiben knnen (auer vielleicht Buchverlage und deren Autoren ;-), werden wir im Folgenden ein etwas komplizierteres Beispiel betrachten. Ziel ist das Entwickeln einer Klasse, die einen StringBuilder (z.B. gelesen aus einer Datei oder von einer Webseite) nach bestimmten Zeichenkombinationen durchsucht. Gemeinhin wird so etwas oft mit Regular Expressions realisiert. Da man im Projekt oft schon fertige Frameworks einsetzt und mit greren Klassenmengen umgehen muss, werden wir mittels Jakarta ORO an einer solchen Kleinstanwendung die Funktionen von Eclipse betrachten. Ziel ist es nicht, ein komplexes Design abzubilden, sondern zunchst einmal EclipseGrundkenntnisse zu erhalten. Hierzu wird Apache Jakarta ORO (hier in Version 2.0.8) als Sourcecode1 bentigt. Bevor wir uns dem Beispiel widmen, erfahren Sie, was unter einer Regular Expression zu verstehen ist. Eine Regular Expression beschreibt, wie ein Computerprogramm ein Textmuster verarbeiten soll und was zu tun ist, wenn dieses Muster gefunden wird. Das OROFramework prft unter Verwendung unterschiedlicher Methoden, inwieweit andere Zeichenketten eine beschriebene Bedingung erfllen. Eine solche Regular Expression knnte lauten: [0-9]. Alle Zeichenketten, die genau aus einer Zahl bestehen, wrden in diesem Fall der Regular Expression gehorchen.1. http://jakarta.apache.org/oro

27


Hilfe in Eclipse

Die Beschreibung einer Regular Expression setzt sich zumeist aus der Kombination eines Wertebereichs (z.B. [0-9]) und einer Mengenangabe ({5}) zusammen. Tabelle 2.1 zeigt einige Beispiele.Tabelle 2.1: Einfache Regular Expressions Regular expression [0-9] [0-9]{2} [A-Za-z] Erluterung eine Ziffer Beispiel: 0, 1, 2, 3, 4, 5, ... zwei Ziffern Beispiel: 05, 76, 65, 54, 29, 99, ... irgendein Buchstabe Beispiel: A, z, Z, j , I, x, C

Fr unser Beispiel legen wir jetzt als Erstes ber das Men FILE | NEW | PROJECT | JAVA | JAVA PROJECT | NEXT ein neues Java-Projekt mit dem Namen RegExTest an. Nach der Eingabe des Namens im Feld PROJECT NAME drcken wir den Button FINISH, um das Projekt zu erzeugen. Dann drcken wir auf dem Projektnamen die rechte Maustaste, whlen aus dem Kontextmen den Menpunkt NEW | PACKAGE, tippen als Package-Namen com.entwickler.eclipsebuch.kapitel2.analyzer ein und klicken auf FINISH. Auf dem erzeugten Package whlen wir wiederum aus dem Kontextmen den Menpunkt NEW | CLASS, als Klassennamen geben wir ExpressionAnalyzer im Wizard ein und drcken auf FINISH. Sollte automatisch eine Main-Methode erzeugt worden sein, knnen Sie diese getrost erst einmal lschen. Damit ist die erste Beispielklasse com.entwickler.eclipsebuch.kapitel2.analyzer.ExpressionAnalyzer erzeugt, wenn auch bisher mit wenig Sourcecode. Diesen kann man sich in einem Editor ansehen. Ein Doppelklick auf den Dateinamen ffnet stets ein entsprechendes Editorfenster. Eine gegebenenfalls generierte Main-Methode knnen wir vorerst lschen. Wir schreiben jetzt eine Methode, die alle Vorkommnisse eines Pattern innerhalb eines Strings heraussucht und die Menge dieser gefundenen Ergebnisse in einem Vektor zurckliefert. Zunchst erzeugen wir die Methodensignatur. Hierzu tippen wir den folgenden Sourcecode in die ExpressionAnalyzer-Klasse ein:public Vector getAllOccurrencesOfPattern( final String originalContent, final String patternString) { }

Bereits jetzt meldet Eclipse, dass es die Begriffe Vector und den Listentyp String nicht kennt, da wir in den Importstatements die Klasse Vector auch noch nicht bekannt gemacht haben. Lassen wir die Maus ber den Begriff Vector fahren, zeigt uns Eclipse die Begrndung in einem so genannten Hover an. Eclipse benutzt Hovers an vielen Stellen zur Anzeige von Problemen, fr Vorschlge, wie man diese lsen kann, oder zur Kenntlichmachung von Dokumentationen.

28



Abb. 2.9: Hinweise auf Build-Fehler in Eclipse

Haben wir bereits gespeichert (Tastenkombination: +S) und dadurch implizit den Compile-Lauf ausgelst, finden wir eine ganze Reihe von Hinweisen auf einen Fehler. Zunchst einmal ist der Begriff Vector unterstrichen. Das kleine Lmpchen mit dem X links vom Sourcecode zeigt den Fehler an, auf der rechten Seite vom Sourcecode-Fenster findet sich ein kleiner Balken, der anzeigt, dass sich an dieser Stelle vom Gesamtdokument ein Fehler befindet. Ein kleiner roter Kasten in der rechten oberen Ecke des Editorfensters weist auf einen Fehler hin und der Editorreiter mit dem Namen ExpressionAnalyzer.java besitzt ebenfalls ein rotes X (siehe Abb. 2.9). Dies setzt sich in der Package Explorer View auf der linken Seite fort. Die Klasse, das Package und auch das komplette Projekt bekommen ein X als Kennzeichnung eines Compile-Fehlers und schlielich finden sich in der Problems View darunter noch einmal die Fehler mit Beschreibung, Resource, Ordner und Angabe der Zeilennummer. Ein Doppelklick auf den Fehler in der Problems View fhrt ebenfalls zum Compile-Fehler. Dass der Fehler auch in der Outline View rechts angezeigt wird, drfte schon fast selbstverstndlich erscheinen. Eclipse bietet zur Problemlsung mehrere Mglichkeiten an. Bei keiner davon muss das Importstatement allerdings per Hand ergnzt werden.Eclipse kompiliert im Gegensatz zu vielen anderen Umgebungen inkrementell, das heit, nur jene Sourcecodeteile, auf die nderungen Auswirkungen haben, werden kompiliert. Eclipse kompiliert die Teile, die kompilierbar sind, und lsst die anderen beim Erzeugen des Classfiles unberhrt. Voraussetzung fr den inkrementellen Compile ist, dass der automatische Compile des Projekts nicht deaktiviert ist (Men PROJECT | BUILD AUTOMATICALLY) und durch die Tastenkombination +S kompiliert wird. ber den Menpunkt PROJECT kann man nun das gesamte Projekt, einen Source-Teil (Workingset) oder alle Projekte neu kompilieren und den Neucompile mittels des Menpunkts CLEAN forcieren.

29


Hilfe in Eclipse

Abb. 2.10: Quick Fix und Lsungsmglichkeiten im Einsatz

Das Klicken auf das kleine Lmpchen links vom Sourcecode (oder -1 auf dem selektierten Vector-Begriff) ermglicht es, sich die Lsungsmglichkeiten (Quick Fix) fr das Problem anzeigen zu lassen. Eclipse bietet u.a. an, die Klasse Vector aus java.util zu importieren, eine Vector-Klasse zu erzeugen oder ein entsprechendes Interface zu generieren, und zwar jeweils im Hover daneben unter Erluterung der Aktivitten, die es durchfhren wrde. Wir entscheiden uns fr den Import der Klasse Vector. Nach einem weiteren Compile mit +S bleiben Vector und String aber markiert. Grund ist dafr der Compliance Level. In Java 1.4 waren getypte Listen noch nicht erlaubt. Wir klicken nun mit dem Cursor auf den Begriff String und drcken erneut -1. Aus der Auswahl whlen wir CHANGE WORKSPACE COMPLIANCE AND JRE TO 5.0. Hiermit wird der gesamte Workspace Java-5.0-fhig gemacht. Wir speichern erneut mit -S. Vector und String sind jetzt nicht mehr unterstrichen. Dieser Fehler scheint behoben.Eclipse 3.1 ist grundstzlich in der Lage, neben 5.0 auch mit JRE 1.3 und 1.4 umzugehen. Die Eclipse-Version 3.2 bringt zustzlich Untersttzung fr Java 6 mit. Da sich die Java-5-Sprachfeatures deutlich von denen von Java 1.4 unterscheiden, mssen sie entweder pro Projekt oder fr das ganze Eclipse aktiviert werden. Die Installation eines Java-5-JDKs ist hierfr Voraussetzung. Haben Sie dies noch nicht getan, knnen Sie weitere JREs ber das Men WINDOW | PREFERENCES | JAVA | INSTALLED JREs nachholen. In den Beispielen kam ein Sun JDK 5.0_05 zum Einsatz. Whlen Sie zum ndern der Compile-Einstellungen entweder im Men WINDOW | PREFERENCES | JAVA | COMPILER | JAVA COMPLIANCE LEVEL aus oder whlen Sie ber das Kontextmen auf einem Java-Projekt im Menpunkt PROPERTIES den Unterpunkt JAVA COMPILER | ENABLE PROJECT SPECIFIC SETTINGS und stellen Sie den JAVA COMPLIANCE LEVEL entsprechend ein.

Dafr weist Eclipse nun darauf hin, dass wir zwar ein getyptes Vector-Objekt zurckgeben wollten, aber kein return-Statement haben. Auch hier knnen wir den Fehler auf die gleiche Art und Weise beheben, indem wir uns die Lsungsvarianten durch Klick auf das Lmpchen anzeigen lassen (siehe Abb. 2.11).

30



Die Entscheidung fllt erneut auf die erste Lsungsalternative: das Erzeugen des returnStatement.

Abb. 2.11: Quick Fix mit Lsungsmglichkeiten (2)

2.3

Eclipse-Projekte individuell konfigurieren

Vor dem Einsatz des ORO-Frameworks importieren wir es. Hierzu mssen zunchst die zu Jakarta ORO gehrigen Dateien gespeichert werden.

Abb. 2.12: ORO-Verzeichnisstruktur

Daraufhin sollte am Speicherort die in Abb. 2.12 sichtbare Verzeichnisstruktur zu finden sein. Neben einem Document-Verzeichnis ist noch das Source-Verzeichnis, in dem die Java-Klassen liegen, interessant. Wir wechseln zurck zu Eclipse und erzeugen ein neues Projekt mit dem Namen ORO, indem wir im Men FILE | NEW | PROJECT | JAVA PROJECT | NEXT whlen und im daraufhin erscheinenden Fenster als Projektnamen ORO eingeben. Wir aktivieren den Radiobutton CREATE PROJECT FROM EXISTING SOURCE und whlen das Verzeichnis, in dem wir ORO entpackt haben (z.B. D:\jakarta-oro-2.0.8). Bereits hier knnen Sie whlen, ob Eclipse spter Sourcecode und generierte Class-Files in unterschiedlichen Verzeichnissen ablegen soll. Fr den Moment lassen wir diese Funktion aber unangetastet. Eclipse deaktiviert die Definition eines Projektlayouts und versucht nun, das Verzeichnis nach bereits existierenden Class-Files und Libraries zu durchsuchen. Mit NEXT gelangen wir auf die Project-Property-Seite.

31



Abb. 2.13: ORO New project Java settings

Eclipse erkennt anhand seines Scans ber das Verzeichnis, in welchen Unterverzeichnissen sich Java-Klassen befinden (kann versionsbedingt leicht abweichen) und dass zum Beispiel ein Compile des /doc-Verzeichnisses keinen Sinn macht (siehe Abb. 2.13). Eclipse erkennt dabei auch die unterschiedlichen Packagestatements und dass bei den Hauptklassen die Package-Struktur bereits bei /src/java beginnt. Es bietet ein entsprechendes Projektlayout zur Erstellung in Form einer Baumdarstellung an. Da wir die Tools und Examples nicht mitkompilieren mchten, lschen wir deren Eintrge heraus, so dass nur noch /src/java brig bleibt. Hierfr klicken wir auf dem /src/java-Zweig mit der rechten Maustaste den Menpunkt CONFIGURE INCLUSION/ EXCLUSION FILTERS an. Er definiert, welche Verzeichnisse unterhalb von /src/java nicht in den Compile mit einbezogen werden sollen. Um die gegebenenfalls unerwnschten Packages examples und tools auszuschlieen, fgen wir nun im Fenster EXCLUSION PATTERN ber den Button ADD MULTIPLE die Verzeichnisse examples und tools (siehe Abb. 2.14) hinzu.

32



Abb. 2.14: Source Folder Inclusion and Exclusion Patterns

Gleiches knnen Sie auf Wunsch mit dem org-Verzeichnis tun. Nach der Besttigung mit dem Button OK ist das Source-Verzeichnis, aus dem wir ORO laufen lassen wollen, hinreichend beschrieben. Den DEFAULT OUTPUT FOLDER stellen wir von ORO/bin auf 6ORO/classes ein (dies ist eine der Default-Eigenschaften, die in den Preferences definiert werden kann, siehe Kapitelabschnitt 2.12). Eclipse zieht zustzlich zum Sourcecode auch die jakarta-oro-2.0.8-JAR-Bibliothek mit heran. Auch sie finden wir noch im Projektbaum vor. ber die rechte Maustaste auf der Datei und den Menpunkt REMOVE FROM BUILD PATH knnen wir diese nun wieder ausschlieen. Fr jedes erkannte Source-Verzeichnis lsst sich auf Wunsch ein anderes Output-Verzeichnis fr die Classfiles definieren. Zu diesem Zweck wird die Checkbox ALLOW OUTPUT FOLDERS FOR SOURCE FOLDERS aktiviert. Fr das Beispiel macht diese Funktion allerdings keinen Sinn, weshalb wir die Checkbox deaktiviert belassen.

33


Eclipse-Projekte individuell konfigurieren Wenn ein entsprechend umfangreiches Projekt vorliegt und die generierten Classfiles auerhalb noch weiterbearbeitet werden sollen (z.B. in einer Ant-Task) kann es sinnvoll sein, Teile des Sourcecodes von anderen rtlich zu trennen. Fr das hier betrachtete einfache Beispiel bringt das aber keine Vorteile.

Abschlieend klicken wir den FINISH-Button an, um die Projekt-Properties zu verlassen, und fhren somit den Compile fr das Projekt durch, das daraufhin wie in Abb. 2.15 aussehen sollte.

Abb. 2.15: ORO-Projektstruktur

Mglicherweise (je nach Version, die von ORO vorliegt) erscheinen eine Reihe von Warndreiecken, die in der Problems View von Eclipse als nicht verwendete Importstatements in diversen Klassen ausgewiesen werden. Diese Warnings knnen wir wie im vorhergehenden Kapitel beschrieben wegfiltern. Sie wrden allerdings als Warndreiecke weiterhin zu sehen sein. Alternativ lassen sich auch die Compile-Einstellungen so ndern, dass diese Fehler keine Warnungen erzeugen.

34



2.3.1

Vorhandenen Sourcecode ins Projekt Link to Source

Grundstzlich lsst sich darber diskutieren, wie mit Sourcecode umgegangen werden sollte, der gleichzeitig in Form von Classfiles vorliegt. Im obigen Beispiel haben wir den Sourcecode nicht importiert, sondern quasi das Projekt aus dem normalen Eclipse-Workspace heraus auf der Festplatte verlinkt, um dort unseren Compile durchzufhren. Import Source Wrde die normale Importfunktionalitt von Eclipse benutzt werden (Men FILE | IMPORT |FILE SYSTEM), wrde im Normalfall ein Projekt im Eclipse-Workspace-Verzeichnis angelegt werden und alle bereits vorhandenen Dateien mssten noch einmal dort hineinkopiert werden. Das ist z.B. dann sinnvoll, wenn der Sourcecode nicht in einzelnen Dateien vorliegt, sondern in einem Jar-File, er aber trotzdem gesehen werden soll, oder wenn die ursprnglichen Dateien durch Modifikationen in Eclipse nicht verndert werden sollen. Attach Source Eclipse bietet die Mglichkeit wie auch beim Sourcecode des Java Runtime Environments, Sourcecode nachtrglich zu attachen. Wenn also neben dem Sourcecode auch der zustndige Bytecode bereits vorliegt, werden in das Projekt die entsprechenden Class- bzw. JarFiles importiert und Eclipse wird durch Doppelklick auf dem entsprechenden Classfile mitgeteilt, den Sourcecode hierzu anzuzeigen. Die Varianten im Vergleich Die Auswirkungen aller drei Varianten sind allerdings sehr unterschiedlich. Letztgenannte ist zwar sehr schnell und einfach, weil sie keinen Recompile und kein Vorhandensein abhngiger Libraries bentigt, dafr kann man nicht vernnftig durch diese Klassen debuggen. Wird der komplette Sourcecode ber die Import-Funktion (rechte Maustaste auf dem JavaProjekt oder ber das Men FILE | IMPORT) importiert, wird er effektiv eigentlich nur unntigerweise verdoppelt, ohne dadurch einen Mehrwert zu haben. Wird zum Sourcecode verlinkt, existiert der Sourcecode nur einmal und er lsst sich debuggen. Der Nachteil bei der Variante ist, dass alle abhngigen Libraries vorhanden sein mssen, um kompilieren zu knnen. Dafr knnen aber gegebenenfalls auch Modifikationen am Sourcecode vorgenommen werden.

35


Eclipse-Projekte individuell konfigurieren Als ratsam hat sich erwiesen, unter bestimmten Umstnden entgegen dem obigen Beispiel Sourcecode und das fertig kompilierte Jar-File mit den Classfiles gleichzeitig zu importieren. In diesem Fall wird der Sourcecode quasi doppelt importiert. Wenn man berlegt, dass die JVM streng nach der Reihenfolge der Klassen im Classpath die Classfiles den Classloadern bergibt, macht es Sinn, im Register ORDER der Build Path-Properties des Projekts die Sourcecode-Dateien vor die restlichen Libraries zu schieben. Je nach Eclipse-Version und verwendetem JDK zeigt sich Eclipse dann grozgig und debuggt durch die Sourcecode-Dateien, whrend im Hintergrund fr fehlerhafte Klassen, die nicht kompiliert werden konnten, die Classfiles aus dem Jar-File herangezogen werden. Dies macht auch dann Sinn, wenn einzelne Funktionen eines Frameworks testhalber deaktiviert werden sollen und dem Original eine Fake-Klasse untergejubelt werden soll, die weiter vorn in den Build- und Runtime-Classpath gelegt wird.

2.3.2

Projekteigenschaften definieren

Um die Eigenschaften des ORO-Projekts neu zu konfigurieren (siehe Abb. 2.16), klicken wir auf den Namen des ORO-Projekts mit der rechten Maustaste und whlen den Unterpunkt PROPERTIES oder drcken +. Auf der linken Seite erscheinen die Kategorien, fr die Einstellungen vorgenommen werden knnen, auf der rechten Seite daneben die zugeordneten Parameter, die durch Anklicken des OK-Buttons bernommen werden knnen.

Abb. 2.16: Java-Projekt Eigenschaften

36



ber die integrierte Combobox knnen Sie in den Properties nach Schlagwrtern suchen, was bei umfangreichen Einstellungen und vielen installierten Plug-Ins sehr hilfreich sein kann, um den berblick nicht zu verlieren. Mittels der Pfeile in der rechten oberen Bildhlfte ist es mglich zwischen einzelnen Eigenschaftsseiten und deren Konfigurationen hin- und herzublttern. Compiler-Einstellungen Im Unterpunkt JAVA COMPILER nehmen wir die Einstellungen fr die individuelle Konfiguration des Compile-Vorgangs bezogen auf dieses einzelne ORO-Projekt vor. Wir aktivieren die Checkbox fr USE PROJECT SETTINGS, um das Projekt separat zu konfigurieren. Hier knnen Sie nun auch nochmals falls noch nicht geschehen den Compiler-Level auf 5.0-Untersttzung umschalten. Neben der separaten Einzeleinstellung der generierten Class-FileVersionen findet sich darunter auch die sehr wichtige Konfiguration der zu generierenden Attribute der Class-Files. Wer sicher gehen mchte, dass keine Probleme whrend des Debuggens auftreten, sollte an diesen Einstellungen mglichst wenige Modifikationen vornehmen. Auf der linken Seite finden Sie im Baum unterhalb der Basis-Compiler-Einstellung auch weitere Eigenschaftsseiten fr den Build-Prozess und die erzeugten Warnungen und Fehler, die der Compiler dabei ausgibt. Wir klicken nun den Unterpunkt ERRORS/WARNINGS an, aktivieren die Checkbox USE PROJECT SETTINGS und klicken das Element UNNECESSARY CODE an. Wir finden hier eine ganze Reihe von Prfroutinen, darunter auch auf nicht verwendete Importstatements, die u.a. schuld an den Build-Warnungen bei ORO sind. Hier stellen wir die Combobox UNUSED IMPORTS von WARNING auf IGNORE um. Dies fhrt beim Kompilieren zum Ignorieren der unbenutzten Importstatements im Sourcecode. Grundstzlich sollte im Projekt vereinbart werden, wie streng der Compile bei der Arbeit vorgeht, fr welche Classfile-Version kompiliert wird und wie der Build-Path (welche Libraries verwendet werden) aussehen soll. Fr die projektbergreifende Dokumentation der Compiler-Einstellungen siehe Abschnitt 2.12. In diesem ERRORS/WARNINGS-Abschnitt finden sich sehr unterschiedliche Elemente, die den Build-Prozess beeinflussen knnen. Die Einstellungen fr POTENTIAL PROGRAMMING PROBLEMS und NAME SHADOWING AND CONFLICTS helfen schnell und einfach, bereits bei der Kodierung mgliche Unstimmigkeiten im Sourcecode aufzudecken. Eclipses Fhigkeit, dabei jede Java-Klasse sofort beim Speichern kompilieren zu knnen (inkrementelle Updates), hilft beim schnellen Aufdecken von Fehlern. Unter diesen Einstellungen findet sich auch eine, die serialisierbare Klassen auf das Vorhandensein eines serialVersionUID-Felds prft. Da diese Prfung nur bedingt sinnvoll ist, sei an dieser Stelle fr das ORO-Projekt empfohlen, den Punkt SERIALIZABLE CLASS WITHOUT SERIALVERSIONUID auf die Prfung IGNORE zu schalten. Auch fr die Java 5-Version wurden hier zahlreiche eigene Einstellungen integriert, die sich um Prfungen bezglich der neuen Sprachfeatures ranken. Darunter finden sich sowohl Checks fr generische Typen als auch Autoboxing (J2SE 5.0 OPTIONS). Da dieses ORO-Projekt noch Java-1.4-kompatibel ist, zielen zahlreiche Warnungen des Compilers auf unge-

37



typte List-Elemente ab, die sich darin finden. Um diese Probleme zu umgehen, whlen Sie in der Combobox UNCHECKED GENERIC TYPE OPERATIONS den Checkbox-Punkt IGNORE aus. Im Unterelement BUILDING der Java-Compiler-Einstellung lassen sich auf die Projekte im Workspace bezogene weitere Build-Einstellungen vornehmen, die nur indirekt zum JavaCompiler in Beziehung stehen.Die Einstellungen im Bereich BUILDING sind besonders dann interessant, wenn man beispielsweise mit vielen separaten Source- und unterschiedlichen Ausgabe-Compile-Verzeichnissen arbeiten mchte. Hier lsst sich nun konfigurieren, ob Eclipse auf unvollstndige oder kaputte BuildPfade (z.B. Jar-Files, die tatschlich derzeit nicht verfgbar sind) reagieren soll und ob zirkulre Abhngigkeiten zwischen Verzeichnissen erlaubt sind. In letzterem Fall wird Eclipse nur schwer handhabbar, wenn man nicht gleichzeitig Einfluss nimmt, wann die IDE auch die Ausgabeverzeichnisse fr einen Recompile lscht (Scrub output folders when cleaning projects). Diese Einstellungen sind sehr mchtig, nderungen an diesen knnen aber auch zu sehr unangenehmen Nebeneffekten fhren (z.B. existierende Class-Files ohne zugehrige Java-Dateien).

Der Unterpunkt JAVA TASK TAGS ermglicht es, das bereits definierte Tag TODO (siehe Abschnitt 2.1.10) von der Liste der geprften Tags zu entfernen. Wenn nicht groes Interesse an der Dokumentation von Alpha- oder Betaversionskommentaren besteht, ist es hin und wieder vorteilhaft, sich von diesem Ballast zu befreien. Wir lschen den TODO-Tag heraus. Info und Java Build Path Die Dialogpunkte INFO und JAVA BUILD PATH des Projekteigenschaftsdialogs schauen wir an dieser Stelle nicht weiter an. Die Info gibt grundstzliche Informationen ber das Projekt. Beim Punkt JAVA BUILD PATH handelt es sich um die Zusammenstellung der Source- und Class-Verzeichnisse und der Libraries, die zum Compile herangezogen wurden (siehe Abschnitt 2.3). Java Code Style Unter dem Unterpunkt JAVA CODE STYLES lassen sich individuelle Einstellungen fr die Kodierungsrichtlinien dieses Projekts vornehmen. Dies ist besonders in greren Projekten mit klar formulierten Design- und Coderichtlinien sehr hilfreich, wenn zahlreiche Einstellungen bereits whrend der Programmierphase geprft oder bei der Erstellung entsprechend untersttzt werden. Javadoc Location Der Dialogpunkt JAVADOC LOCATION bietet die Mglichkeit, die aus dem Javadoc durch die Entwickler erzeugte API-Dokumentation in das Projekt einzubringen. Da wir bereits in dem Beispiel den fertigen Sourcecode importiert haben, ist die Javadoc-Dokumentation quasi schon inklusive. Aber besonders bei Klassen von Drittanbietern, deren Sourcecode nicht vorliegt, ist das Hinzufgen der API-Dokumentation sinnvoll.

38



Die in dieser Kurzvorstellung prsentierten Einstellungen fr das ORO-Projekt lassen sich selbstverstndlich auch fr die gesamte Workbench, sprich alle Projekte, gleichzeitig durchfhren. Sie finden diese stets ber das WINDOW | PREFERENCES-Men oder den Link CONFIGURE WORKSPACE SETTINGS in diesem Eigenschaftendialog. Schlieen Sie nun den Eigenschaftsdialog des ORO-Projekts mit dem Klick auf den Button OK. Haben Sie einige oder sogar alle der oben empfohlenen Einstellungen vorgenommen, werden Sie nun gefragt, ob das Projekt sinnvoller neu kompiliert werden sollte, um diese auch zu aktivieren. Wir besttigen in diesem Fall mit OK. Haben Sie alle Einstellungen vorgenommen, sollte das Projekt selbst jetzt fehlerfrei kompilieren. Fremde Projekte referenzieren Wir ffnen nun noch einmal die PROPERTIES des RegExtTest-Projekts ber die Tastenkombination + nach Anklicken des Projektnamens im PACKAGE EXPLORER und klicken auf die Einstellungen des BUILD PATH. Da die beiden angelegten Projekte RegExTest und ORO sich gegenseitig nicht kennen, muss das Projekt RegExTest die ORO-Klassen beim Build bercksichtigen. Dies wird dadurch abgewickelt, dass das ORO-Projekt beim Compile referenziert wird. Klicken Sie im Register PROJECTS den Button ADD an und whlen Sie das nun neu zu assoziierende ORO-Projekt. Klicken Sie dann auf OK, damit das Projekt in den BUILD PATHEigenschaften von RegExTest erscheint. Auf diese Art und Weise werden die ORO-Klassen aus den Source-Pfaden des ORO-Projekts fr das RegExTest-Projekt sichtbar.Vom ORO-Projekt selbst wiederum referenzierte weitere Projekte, JARFiles oder Verzeichnisse werden erst auf Wunsch ber eine separate Export-Funktion im Register Classpath sichtbar.

Fr das RegExTest-Projekt erscheinen die Klassen aus ORO wie in einem einzigen groen Projekt, whrend ORO umgekehrt von RegExTest gar nichts wei.Das gegenseitige Referenzieren sollte nicht bertrieben werden, um bsen berraschungen vorzubeugen. Besonders zirkulre Beziehungen kann Eclipse nicht vernnftig bearbeiten, da es nicht wei, wer nun bei der Definition der Klassen die Vorreiterrolle spielt und wie der Classpath fr den Compile und zur Laufzeit zu bilden ist. Dennoch sind sie grundstzlich mglich, wie wir bereits gesehen haben. Besonders wenn Fremd-Plug-Ins oder unter

Eclipse Die-Plattform

Documents

Transcript of Eclipse Die-Plattform