Eclipse: Erste Schritte

 + andere TechDocs
+ Eclipse-Einstellungen
+ Eclipse.org
+


Eclipse ist ein sehr flexibles und leistungsfähiges Open-Source-Framework für eine Entwicklungsumgebung.

In diesem Dokument geht es nur um den Einsatz von Eclipse als Java-IDE, obwohl Eclipse weit mehr bietet.

Einige Erläuterungen basieren noch auf dem Stand von Eclipse 3.1, an anderen Stellen sind Neuerungen in Eclipse 3.3 berücksichtigt.



Inhalt

  1. Terminologie in Eclipse
  2. Installation von Eclipse
  3. Einige Tastaturkürzel
  4. Templates
  5. Erste Konsolenanwendung
  6. Weitere erste Anwendungen
  7. Import von 'Ant'-Projekten
  8. Export als ausführbare .jar-Datei
  9. SQL-Datenbank-Clients (SQuirreL, QuantumDB, SQLExplorer, Clay)
  10. UML-Editor (JUDE und yEd, EclipseUML)
  11. JUnit mit Eclipse
  12. CVS-Integration
  13. Subversion-Integration
  14. Eclipse mit Maven
  15. Links auf weiterführende Informationen


Terminologie in Eclipse



Installation von Eclipse

  1. Falls Sie bereits eine ältere Java-Version (JRE, JDK oder SDK) installiert haben, deinstallieren Sie sie (in Windows XP bzw. Vista unter 'Start' | 'Systemsteuerung' | 'Software' bzw. 'Programme' | 'Java ...' bzw. 'J2SE ...' | 'Entfernen').
  2. Downloaden Sie ein aktuelles Java SE JDK 6 von http://java.sun.com/javase und installieren Sie es zum Beispiel nach 'C:\Java\jdk', so wie beschrieben unter java-install.htm (inklusive Setzen der korrekten Umgebungsvariablen).
  3. Downloaden Sie das aktuelle Eclipse SDK (z.B. 'eclipse-SDK-3.3-win32.zip') von http://www.eclipse.org in ein beliebiges temporäres Verzeichnis.
  4. Entzippen Sie die Eclipse-.zip-Datei und kopieren Sie den kompletten darin enthaltenen Verzeichnisbaum ab 'eclipse' zum Beispiel nach 'C:\Java', so dass die Datei 'eclipse.exe' im Verzeichnis 'C:\Java\eclipse' liegt.
  5. Start von 'C:\Java\eclipse\eclipse.exe'.
  6. Als Workspace-Verzeichnis besser nicht das vorgeschlagene bei den Eclipse-Programmdateien angeordnete 'C:\Java\eclipse\workspace' wählen, sondern besser getrennt zum Beispiel auf einer Daten-Partition 'D:' ein neues Verzeichnis anlegen, z.B. 'D:\MeinWorkspace'.
  7. Führen Sie weitere Einstellungen durch, wie sie in java-eclipse-einstellungen.htm aufgeführt sind.
  8. Lesen Sie die Texte unter 'Overview', 'Tutorials' und 'Samples'.
  9. Oft werden zusätzliche Plug-ins zu Eclipse benötigt, siehe dazu http://www.eclipse-plugins.info/eclipse/plugins.jsp.
  10. Falls Sie ein vorhandenes Projekt importieren wollen, wählen Sie:
    'File' | 'Import...' | '[+] General' | 'Existing Projects into Workspace' | 'Select root directory'.
  11. Falls Eclipse Probleme bezüglich des "JDK" meldet (bei Web-Projekten z.B. "Your Web Application Project must be configured to use a JDK in order to use JSPs."), dann ist eventuell nur ein JRE und kein JDK konfiguriert:
    Fügen Sie in Eclipse über 'Window' | 'Preferences' | '[+] Java' | 'Installed JREs' | 'Add...' | 'Standard VM' | 'JRE home' das Verzeichnis Ihres JDKs hinzu (z.B. 'C:\Program Files\Java\jdk1.6') und aktivieren Sie in der 'Installed JREs'-Liste nicht das JRE, sondern das JDK.
  12. Falls sich Eclipse bei größeren Projekten über Speichermangel beschwert: Starten Sie Eclipse mit dem Kommandozeilenparameter '-vmargs -Xmx512M'.
    Falls in Eclipse ausgeführte JUnit-Tests mit OutOfMemoryError aussteigen, geben sie für diese JUnit-Tests mehr Speicher vor:
    'Run' | 'Open Run Dialog…' (bzw. 'Open Debug Dialog…') | links den JUnit-Test markieren | rechts Tabulatorreiter 'Arguments' | Eingabefeld 'VM arguments': -Xmx512M
  13. Weiter unten finden Sie Hinweise zur CVS- und Subversion-Integration.


Einige Tastaturkürzel

Einige der folgendenden Tastaturkürzel funktionieren nur in bestimmten Perspektiven (z.B. der Java Perspektive). Viele weitere Tastaturkürzel werden (ab Eclipse 3.1) aufgelistet in Kurform über 'Ctrl+Shift+L' sowie ausführlich und sortierbar unter 'Window' | 'Preferences' | '[+] General' | 'Keys' | 'View'.

 F4Open type hierarchy
 F5File, Package Explorer: Refresh
 F5, F6, F7, F8Debugging: Step into, over, return, resume
 F12Focus to editor window
 Shift+F2Show Javadoc
 Alt+Left, Alt+Right  Go to prev/next editor position in history
 Alt+Shift+MExtract method
 Alt+Shift+RRename method/variable
 Ctrl+MausclickGo to declaration
 Ctrl+SpaceAutomatic code completion
 Ctrl+Shift+SpaceMethod parameters
 Ctrl+, Ctrl+.Go to previous/next problem, warning, bookmark, etc.
 Ctrl+F6Change to next Editor file
 Ctrl+GShow declaration(s)
 Ctrl+HSearch in files
 Ctrl+MMaximize or reduce size of view
 Ctrl+OPop-up outline
 Ctrl+QGo to last modified editor position
 Ctrl+TShow class hierarchy
 Ctrl+Alt+H Go to declaration and open call hierarchy
 Ctrl+Shift+BToggle breakpoint
 Ctrl+Shift+FFormat code
 Ctrl+Shift+GShow all references
 Ctrl+Shift+MImport type under cursor
 Ctrl+Shift+OOrganise imports
 Ctrl+Shift+PGo to matching bracket
 Ctrl+Shift+ROpen resource
 Ctrl+Shift+TOpen type
 Ctrl+Shift+UShow occurences in this file
 syso Ctrl+SpaceSystem.out.println();

Natürlich können Tastaturkürzel auch umdefiniert werden. Zum Beispiel kann folgendermaßen die F3-Taste zur Suche nach der nächsten Fundstelle des gerade markierten Textes vereinbart werden:

  1. 'Window' | 'Preferences' | '[+] General' (früher '[+] Workbench') | 'Keys' | 'Modify' (früher 'Keyboard Shortcuts')
  2. 'Command': 'Category' = 'Edit', 'Name' = 'Find Next', 'Assignments': 'Ctrl+K' markieren
  3. 'Key Sequence': 'Name' = F3, 'Add'


Templates

In Eclipse können sehr einfach Templates definiert werden, die makroartig Codeschnipsel einfügen. Dabei können statische Textbestandteile mit dynamisch erstellten Ausdrücken kombiniert werden.

Das folgende Beispiel zeigt, wie 'log4j Ctrl+Space' zum Einfügen des Logging-Konstruktors inklusive dynamisch angepasstem Java-Klassennamen führt.

  1. 'Window' | 'Preferences' | '[+] Java' | '[+] Editor' | 'Template' | 'New...'
  2. 'Name = log4j', 'Description = Log4j-Logger',
    'Pattern = private static final Logger LOGGER = Logger.getLogger(${primary_type_name}.class);'
  3. Wenn Sie jetzt im Java-Sourceode 'log4j' eingeben und anschließend 'Ctrl+Space' betätigen, entsteht im Sourcecode:
    private static final Logger LOGGER = Logger.getLogger(<MeineKlasse>.class);


Erste Konsolenanwendung

  1. Installation von Java und Eclipse wie oben beschrieben und starten von Eclipse.
  2. 'Window' | 'Open Perspective' | 'Java'.
  3. 'File' | 'New' | 'Project...' | 'Java Project' | 'Next';
    Project name: 'FirstHelloWorld' | 'Finish'.
  4. Links im 'Package Explorer' erscheint der neue Projektname.
    Rechter Mausklick auf diesen Projektnamen | 'New' | 'Package' | Name: 'firsthelloworldpckg' | 'Finish'.
  5. Im 'Package Explorer' erscheint der neue Paketname.
    Rechter Mausklick auf diesen Paketnamen | 'New' | 'Class' | Name: 'HelloWorld' | Checkbox 'public static void main(...)' einschalten | 'Finish'.
  6. Im 'Package Explorer' erscheint der neue Klassenname und im Haupteditorfenster wird die Datei 'HelloWorld.java' angezeigt.
    Wenn Sie im rechten 'Outline'-Fenster nacheinander auf die Elemente 'firsthelloworldpckg', 'HelloWorld' und 'main(String[])' mit der Maus klicken, wird im Haupteditorfenster der Cursor auf die entsprechenden Stellen im Sourcecode gesetzt.
  7. Fügen Sie zwischen die geschweiften Klammern '{ }' von 'public static void main(String[] args) { }' in einer neuen Zeile die zwei Buchstaben 'Sy' ein, betätigen Sie 'Strg+Leertaste' und wählen Sie 'System - java.lang'.
    Setzen Sie hinter das erscheinende 'System' einen Punkt ('System.') und betätigen Sie 'Strg+Leertaste' und wählen Sie 'out  PrintStream - System'.
    Erweitern Sie das erscheinende 'System.out' zu 'System.out.println( "Hallo Welt" );'.
    Jetzt darf nichts mehr rot unterschlängelt sein.
    Fügen Sie dahinter in einer neuen Zeile 'syso' ein und betätigen Sie 'Strg+Leertaste'. Dieses Kürzel ist eine noch kürzere Variante, um 'System.out.println();' zu erzeugen. Fügen Sie noch einen anzuzeigenden Text ein.
  8. Binden Sie die Javadoc-API-Dokumentation in Eclipse ein, wie es beschrieben ist unter
    java-eclipse-einstellungen.htm#WorkspaceJavadoc.
    Setzen Sie den Textcursor auf das Wort 'out' in der Sourcecodezeile 'System.out.println( "Hallo Welt" );' und betätigen Sie 'Shift+F2' (oder 'F1' und 'Javadoc for out'). Sie erhalten die Javadoc-Information für das gewählte Element.
  9. Schalten Sie im unteren View-Fenster um auf den Tabulatorreiter 'Problems' (alternativ können Sie auch wählen: 'Window' | 'Show View' | 'Problems').
    Betätigen Sie 'Strg+S' zum Speichern und Compilieren. Im 'Problems'-View erscheint: '0 errors, 0 warnings, 0 infos'.
    Setzen Sie den Textcursor in das Editorfenster mit der 'main()'-Methode und wählen Sie 'Run' | 'Run as' | 'Java Application' (für wiederholte Aufrufe können Sie dann auch das Grüner-Pfeil-Symbol rechts neben dem Käfer-Symbol in der oberen Toolbar verwenden).
    Schalten Sie das untere View-Fenster um auf 'Console' ('Window' | 'Show View' | 'Console') und Sie sehen die Ausgabe 'Hallo Welt'.
  10. Klicken Sie in der Sourcecodezeile 'System.out.println( "Hallo Welt" );' mit der rechten Maustaste ganz links am Rand des Editorfensters und wählen Sie 'Toggle Breakpoint'.
    Setzen Sie den Textcursor in das Editorfenster mit der 'main()'-Methode und wählen Sie 'Run' | 'Debug as' | 'Java Application' (für wiederholte Aufrufe können Sie dann auch das Käfer-Symbol in der oberen Toolbar verwenden).
    Erlauben Sie die Umschaltung zur 'Debug Perspective'. Im 'Run'-Menü finden Sie diverse Möglichkeiten, um durch den Code zu laufen ('F5'...'F8').
    Oben rechts über das '>>'-Symbol können Sie wieder zurück auf die 'Java'-Perspektive umschalten (oder über 'Window' | 'Open Perspective' | 'Java').


Weitere erste Anwendungen

Laden Sie die Beispiele unter 'java-examples.htm' in Eclipse. Die Beispiele sind dort der Einfachheit halber ohne Package-Struktur gezeigt. Um Sie in Eclipse einzubinden gehen Sie folgendermaßen vor (das Projekt und das Package brauchen Sie nur einmal anzulegen, Sie können alle Klassen darin anlegen):

  1. 'Window' | 'Open Perspective' | 'Java'.
  2. 'File' | 'New' | 'Project...' | 'Java Project' | 'Next';
    Project name: 'MeineErstenVersuche' | 'Finish'.
  3. Rechter Mausklick auf den neuen Projektnamen 'MeineErstenVersuche' im 'Package Explorer'
    | 'New' | 'Package' | Name: 'beispiele' | 'Finish'.
  4. Rechter Mausklick auf den neuen Paketnamen 'beispiele' im 'Package Explorer'
    | 'New' | 'Class' | Name: '<Name-so-wie-'public class ...'-Definition>' | Checkbox 'public static void main(...)' ausschalten | 'Finish'.
    (Der Name der Klassendatei muss genau so lauten wie die darin enthaltene 'public class ...'-Definition, also z.B. 'TextEinAusgabe1').
  5. Löschen Sie den gesamten Inhalt der neu erzeugten Klasse im Editor-Fenster und kopieren Sie den Dateiinhalt des jeweiligen Beispiels von der 'java-examples.htm'-Webseite.
  6. Fügen Sie als erste Anweisung in die Sourcedatei ein:
    package beispiele;
  7. Betätigen Sie 'Strg+S' zum Speichern und Compilieren. Im 'Problems'-View erscheint: '0 errors, 0 warnings, 0 infos'.
  8. Setzen Sie den Textcursor in das Editorfenster mit der 'main()'-Methode und wählen Sie 'Run' | 'Run as' | 'Java Application'.
  9. Falls Sie ein Applet (ohne 'main()'-Methode, wie z.B. 'TextEinAusgabe3') testen wollen, setzen Sie den Textcursor in das Editorfenster mit der 'init()'-Methode und wählen Sie 'Run' | 'Run as' | 'Java Applet' (wahrscheinlich müssen Sie das Applet-Fenster größer ziehen).
  10. Falls die Anwendung Texteingaben erwartet (wie z.B. 'TextEinAusgabe1'), aktivieren Sie den 'Console'-View. Sie können das 'Console'-Fenster durch einen Doppelklick auf den Reiter vergrößern.
  11. Falls die Anwendung Kommandozeilenparameter erwartet (wie z.B. 'FileCopy', 'FileFromUrl' und 'MyImgShow'), wählen Sie 'Run' | 'Run...' | 'Java Application' | 'New' | ... | 'Arguments' | ...
  12. Wenn Sie die Beispiele aus 'java-examples.htm' durch haben, können Sie fortfahren mit: 'java-io.htm', 'java-net.htm', 'java-smtp.htm', 'java-img.htm', 'java-print.htm', 'java-collections.htm', 'java-sql.htm', 'java-hibernate.htm', 'java-xml.htm', 'java-soap-axis.htm', 'java-log4j.htm', 'java-classfinder.htm', 'java-junit.htm', 'java-httpunit.htm' und den Tomcat/JSP/JavaEE-Beispielen unter 'jee-tomcat-eclipse.htm' und 'JSP/JavaEE/...'.


Import von 'Ant'-Projekten

Projekte, die nicht mit Eclipse erzeugt wurden, sondern über ein 'Ant'-Skript-XML-Datei (meistens 'build.xml') erstellt werden, können leicht in Eclipse importiert und in ein Eclipse-Projekt umgewandelt werden:

  1. Wählen Sie in Eclipse 3.1: 'File' | 'New' | 'Project...' | 'Java Project from Existing Ant Buildfile' (bzw. in Eclipse 3.0: 'File' | 'Import...' | 'Existing Ant Buildfile').
  2. Wählen Sie weiter: 'Browse' | '<Ant-Skript-XML-Datei>' (meistens 'build.xml').
  3. Schalten Sie um in die 'Java'-Perspective ('Window' | 'Open Perspective' | 'Java') und wählen Sie: 'Window' | 'Show View' | 'Problems'. Wenn Sie im 'Problems'-Fenster die Fehlermeldung '... missing required library ...', 'Required library cannot denote external folder ...' oder 'Build path entry is missing ...' vorfinden, klicken Sie im 'Package Explorer' mit der rechten Maustaste auf das neu erstellte Projekt und wählen Sie 'Properties' | 'Java Build Path' | Tabulatorreiter 'Libraries' und löschen Sie den (meistens obersten) Eintrag, der auf das alte Build- oder Classes-Verzeichnis des 'Ant'-Projekts verweist, ohne dass davor eine .jar- oder Lib-Datei genannt ist.
  4. Jetzt sollte das 'Problems'-Fenster keine Fehlermeldung mehr zeigen und Sie können die Sourcedateien öffnen und das Projekt über 'Run' starten.

Natürlich können Sie auch in ein 'Ant'-Skript exportieren: 'File' | 'Export...' | 'Ant Buildfiles' (überprüfen Sie vorher, dass nicht eine 'build.xml'-Datei bereits existiert, die überschrieben würde).



Export als ausführbare .jar-Datei

Ohne zusätzliche Libraries

Projekte, die keine zusätzlichen .jar-Libraries benötigen, lassen sich in Eclipse einfach als direkt ausführbare .jar-Datei exportieren.
Klicken Sie in Eclipse im 'Package Explorer' auf das gewünschte Projekt und wählen Sie:
'File' | 'Export...' | 'JAR file'. Selektieren Sie das gewünschte Projekt und die gewünschten Dateien, geben Sie als 'Export Destination' den Pfad und Namen der zu erstellenden .jar-Datei ein (z.B. '<Projektverzeichnis>\MeineAnwendung.jar') und fahren Sie nicht mit 'Finish', sondern mit 'Next >' fort. Geben Sie im übernächsten Dialog entweder eine gültige 'Manifest'-Datei an (siehe unten) oder geben Sie die Java-Klasse an, die die 'main()'-Methode enthält.

Wenn Sie in Windows auf die so entstandene .jar-Datei (z.B. MeineAnwendung.jar) im Windows Explorer doppelt klicken, wird das Programm ausgeführt. Allerdings sehen Sie so keine Standard-Ausgaben (per 'System.out.println()' erzeugte Ausgaben). Wenn Sie die sehen wollen, geben Sie im Kommandozeilenfenster ein:

java -jar MeineAnwendung.jar


Inklusive zusätzlichen Libraries

Leider lassen sich nicht so ohne weiteres zusätzlich benötigte .jar-Libraries einbinden. Sie können die .jar-Libs zwar der Anwendungs-.jar-Datei hinzufügen, allerdings werden sie von Ihren Java-.class-Dateien so nicht gefunden, auch dann nicht, wenn Sie in der 'Manifest.mf'-Datei die 'Class-Path:'-Angabe entsprechend setzen.

Es gibt mehrere Ansätze, um trotzdem die komplette Anwendung in eine einzige Datei zu packen. Eine etwas aufwändige ist, den Classloader zu überschreiben. Dies finden Sie zum Beispiel beschrieben unter:
http://www-106.ibm.com/developerworks/java/library/j-onejar/ und
http://www.developertutorials.com/tutorials/java/simplify-application-delivery-one-jar-050422/page3.html sowie als Eclipse Plug-in realisiert unter http://fjep.sourceforge.net.

Im Folgenden wird ein weniger schöner, dafür aber übersichtlicherer Weg beschritten, wobei die Anwendung zu einer .zip-Datei zusammengefasst wird:

  1. Überprüfen Sie, ob Ihre Verzeichnisse dem folgenden (unter Eclipse üblichen) Schema entsprechen:

    [Projektverzeichnis]
  |- [bin]
  |    '- [meinpackage]
  |         |- MeineMainKlasse.class
  |         '- MeineWeitereKlasse.class
  |- [lib]
  |    |- meineLib1.jar
  |    '- meineLib2.jar
  '- [src]
       '- [meinpackage]
            |- MeineMainKlasse.java
            '- MeineWeitereKlasse.java

  2. Legen Sie im Projektverzeichnis die folgende Datei 'manifest.txt' an (inklusive der letzten Leerzeile):

    Manifest-Version: 1.0
Main-Class: meinpackage.MeineMainKlasse
Class-Path: . lib/meineLib1.jar lib/meineLib2.jar

  3. Legen Sie im Projektverzeichnis die folgende Datei 'build-jar.xml' an:

    <project name="MeinProjekt" default="dist">
  <property name="MyApp" value="MeineAnwendung" />
  <path id="compile.classpath">
    <fileset dir="lib" />
    <pathelement path="bin" />
  </path>
  <target name="compile">
    <javac srcdir="src" destdir="bin">
      <classpath refid="compile.classpath" />
    </javac>
  </target>
  <!-- Create binary distribution -->
  <target name="dist" depends="compile">
    <delete file="${MyApp}.jar"/>
    <delete file="dist/${MyApp}.zip"/>
    <mkdir dir="dist" />
    <jar jarfile="${MyApp}.jar"
         basedir="bin"
         manifest="manifest.txt" />
    <zip destfile="dist/${MyApp}.zip">
      <fileset dir="." includes="lib/*" />
      <fileset dir="." includes="${MyApp}.jar" />
    </zip>
  </target>
</project>

  4. Rufen Sie im Kommandozeilenfenster auf (hierfür muss natürlich 'ant' installiert sein, siehe java-install.htm):

    ant -f build-jar.xml

  5. Sie erhalten als Ergebnis:

    [Projektverzeichnis]
  |- [bin]
  |    '- [meinpackage]
  |         |- MeineMainKlasse.class
  |         '- MeineWeitereKlasse.class
  |- [dist]
  |    '- MeineAnwendung.zip
  |- [lib]
  |    |- meineLib1.jar
  |    '- meineLib2.jar
  |- [src]
  |    '- [meinpackage]
  |         |- MeineMainKlasse.java
  |         '- MeineWeitereKlasse.java
  |- manifest.txt
  '- MeineAnwendung.jar
  6. Die erzeugte Datei 'MeineAnwendung.jar' können Sie bereits ausführen, zum Beispiel um sie zu testen. Aber beachten Sie bitte, das dies nur deshalb funktioniert, weil das 'lib'-Verzeichnis parallel zur .jar-Datei liegt. Wenn Sie die 'MeineAnwendung.jar'-Datei woanders hin kopieren (oder Ihrem Kunden geben), fehlen die .jar-Libraries.
  7. Zur Distribution ist nur die Datei 'MeineAnwendung.zip' geeignet.

  8. Wenn Sie die Distributionsdatei 'MeineAnwendung.zip' in ein beliebiges Verzeichnis (z.B. beim Kunden) kopieren und zum Beispiel in das Unterverzeichnis 'MeineAnwendung' entpacken, erhalten Sie:

    [beliebigesZielverzeichnis]
  |- [MeineAnwendung]
  |    |- [lib]
  |    |    |- meineLib1.jar
  |    |    '- meineLib2.jar
  |    '- MeineAnwendung.jar
  '- MeineAnwendung.zip

  9. Jetzt starten Sie die Anwendung wieder entweder durch Doppelklick auf 'MeineAnwendung.jar' oder über die Kommandozeile 'java -jar MeineAnwendung.jar'.

  10. Falls Sie die .jar-Datei weder mit Eclipse noch mit obiger über 'ant' aufzurufender 'build-jar.xml' erstellen wollen, können Sie dies vom Projektverzeichnis aus mit folgendem Kommando (inklusive des '.' am Schluss):

    jar cvfm MeineAnwendung.jar manifest.txt -C bin .



SQL-Datenbank-Clients

SQuirreL

Ein sehr empfehlenswertes universelles Client-Programm zur Bearbeitung von SQL-Datenbanken ist SQuirreL. Leider steht SQuirreL noch nicht als Eclipse-Plug-in zur Verfügung.

QuantumDB-SQL-Plug-in

Installation des SQL-Clients QuantumDB Eclipse-Plug-in:

  1. Die folgende Beschreibung geht von einer bereits installierten SQL-Datenbank aus, wie zum Beispiel für MySQL beschrieben unter mysql.htm.
  2. Für Ihre Datenbank benötigen Sie einen passenden JDBC-Typ-4-Treiber. Sehen Sie sich dazu java-sql.htm an.
  3. Downloaden Sie die QuantumDB-Installationsdatei (z.B. 'com.quantum.feature_3.0.0.bin.dist.zip') von http://quantum.sourceforge.net.
  4. Entzippen Sie das Archiv und kopieren Sie den kompletten Inhalt (also die beiden Ordner 'features' und 'plugins') in Ihr Eclipse-Verzeichnis (z.B. 'C:\Java\eclipse').
  5. Je nach Eclipse- und QuantumDB-Version benötigen Sie eventuell zusätzlich das 'Graphical Editor Framework (GEF)'-Plugin.
  6. Starten Sie Eclipse neu. Schalten Sie die Perspektive um:
    'Window' | 'Open Perspective' | 'Other...' | 'Quantum DB'.
  7. Anmeldung eines JDBC-Treibers:
    Im 'Database Bookmarks'-View klicken Sie mit der rechten Maustaste in die weiße Fläche und wählen 'New Bookmark...' | 'Add driver...' | 'Add external Jar...' und den Pfad zu Ihrem JDBC-Typ-4-Treiber, für MySQL zum Beispiel 'C:\Java\jdk\jre\lib\ext\mysql-connector-java-5.1.11-bin.jar'.
    Klicken Sie auf 'Browse...' und wählen Sie die korrekte Treiberklasse, für MySQL zum Beispiel 'com.mysql.jdbc.Driver'. Bestätigen Sie mit 'Finish'.
  8. Einrichtung einer Datenbankverbindung:
    Im 'Database Bookmarks'-View klicken Sie mit der rechten Maustaste in die weiße Fläche und wählen 'New Bookmark...'. Wählen Sie in der JDBC-Driver-Liste den passenden Eintrag und klicken Sie auf 'Next >' Füllen Sie die Dialogfelder aus. Für eine MySQL-Verbindung könnten die Einträge zum Beispiel lauten:
    Userid = 'root'
    Password = 'mysqlpwd'
    Host name = 'localhost'
    Port = '3306'
    Database name = 'MeineDb'
    URL = 'jdbc:mysql://localhost:3306/MeineDb'
    Klicken Sie auf 'Next >' und vergeben Sie einen Bookmark Name.
  9. Klicken Sie im 'Database Bookmarks'-View mit der rechten Maustaste auf den neu erstellten Bookmark Name und wählen Sie 'Connect'. Klicken Sie auf die '[+]'-Symbole, bis Sie die Tabellennamen sehen. Klicken Sie mit der rechten Maustaste auf einen Tabellennamen und wählen Sie 'View Table'.
  10. Wenn Sie in einer Tabelle einen Eintrag editieren wollen, klicken Sie in die entsprechende Zeile mit der rechten Maustaste und wählen Sie 'Update...'. Tragen Sie den neuen Wert ein und wählen Sie rechts daneben 'Set Value'. Überprüfen Sie das unten erscheinende 'UPDATE ...'-SQL-Kommando und betätigen Sie 'Finish'. Führen Sie mit dem 'Refresh'-Icon-Symbol (mit den zwei geschwungenen Pfeilen) einen Refresh der Tabellenanzeige durch.
  11. Mit dem 'Filter and Sort'-Icon (mit den drei nach rechts zeigenden Pfeilen) können Sie die Tabellenansicht beeinflussen.
  12. Im 'Quantum SQL Query Editor'-View können Sie SQL-Kommandos ausführen.

SQLExplorer-Plug-in

Installation des SQL-Clients SQLExplorer Eclipse-Plug-in:

  1. Die folgende Beschreibung geht von einer bereits installierten SQL-Datenbank aus, wie zum Beispiel für MySQL beschrieben unter mysql.htm.
  2. Für Ihre Datenbank benötigen Sie einen passenden JDBC-Typ-4-Treiber. Sehen Sie sich dazu java-sql.htm an.
  3. Downloaden Sie die SQLExplorer-Installationsdatei (z.B. 'net.sourceforge.sqlexplorer_2.2.3.zip') von http://sourceforge.net/projects/eclipsesql.
  4. Entzippen Sie das Archiv und kopieren Sie den Inhalt des darin enthaltenen Ordners 'plugins' in Ihren Eclipse-'plugins'-Ordner (z.B. 'C:\Java\eclipse\plugins').
  5. Starten Sie Eclipse neu. Schalten Sie die Perspektive um:
    'Window' | 'Open Perspective' | 'Other...' | 'SQLExplorer'.
  6. Im 'Drivers'-View klicken Sie mit der rechten Maustaste auf den zu Ihrer Datenbank passenden Treiber (für MySQL z.B. 'MMMySQL Driver') und wählen 'Change the selected Driver'.
    Füllen Sie die Dialogfelder aus. Für eine MySQL-Verbindung könnten die Einträge zum Beispiel lauten:
    Example URL = 'jdbc:mysql://localhost:3306/MeineDb'
    Extra Class Path | Add = 'C:\Java\jdk\jre\lib\ext\mysql-connector-java-5.1.11-bin.jar'
    Driver Class Name = 'com.mysql.jdbc.Driver'
  7. Schalten Sie um auf den 'Aliases'-View, wählen Sie 'Create new Alias' und füllen Sie die Dialogfelder aus. Für eine MySQL-Verbindung könnten die Einträge zum Beispiel lauten:
    Name = 'MySQL-MeineDb'
    Driver = 'MMMySQL Driver'
    URL = 'jdbc:mysql://localhost:3306/MeineDb'
    User Name = 'root'
    Password = 'mysqlpwd'
  8. Klicken Sie doppelt auf den neu erstellten Alias-Namen im 'Aliases'-View um die Datenbankverbung herzustellen.
  9. Oben rechts im 'Database Structure View' sehen Sie die Datenbank-Schemata. Klicken Sie auf die '[+]'-Symbole bis Sie Tabellennamen anklicken können. Unten im 'Database Structure View' sehen Sie dann die 'Columns' mit ihren Eigenschaften dargestellt. Klicken Sie unten auf den Tabulatorreiter 'Preview' um die Tabelleninhalte zu sehen.
  10. Klicken Sie oben rechts im 'Database Structure View' mit der rechten Maustaste auf einen Tabellennamen und wählen Sie 'Generate Select in Sql Editor'. Im 'SQL Editor'-View erscheint ein SQL-'select'-Kommando. Führen Sie es aus indem Sie auf das Icon mit dem laufenden Männchen klicken (oder über rechte Maustaste). Unten im 'SQL Results'-View erscheint das Ergebnis als Tabelle. In dieser Tabelle können Sie auf die Tabellenspaltentitel klicken, um die Tabelleninhalte zu sortieren.
  11. Klicken Sie oben rechts im 'Database Structure View' mit der rechten Maustaste auf einen Tabellennamen und wählen Sie 'Create Table Script'. Im 'SQL Editor'-View erscheint ein SQL-'create'-Kommando, um eine solche Tabelle anzulegen.
  12. Eine ausführlichere Installationsanleitung finden Sie auch unter http://www.onjava.com/pub/a/onjava/2005/05/11/sqlexplorer.html.

Datenbank-Modelierung mit dem Clay-Plug-in

Unter http://www.azzurri.jp/en/software/clay finden Sie ein Eclipse-Plug-in zur Datenbank-Modelierung.

  1. Die Installation des Clay-Plug-ins kann übers Internet über den Eclipse Update Manager erfolgen wie beschrieben unter http://www.azzurri.jp/eclipse/plugins ('Help' | 'Software Updates' | 'Find and Install...' | 'Search for new features to install' 'New Remote Site...' | Name = 'Azzurri Plugins', URL = 'http://www.azzurri.jp/eclipse/plugins').
    Beachten Sie, dass das 'Graphical Editor Framework (GEF)' mitinstalliert werden muss (falls noch nicht geschehen).
  2. Befolgen Sie den 'Clay Quick Start Guide' unter http://www.azzurri.jp/en/software/clay/quick_start_guide.jsp.
  3. Starten Sie ein Clay-Projekt über 'File' | 'New' | 'Other...' | '[+] Database Modeling' | 'Azzurri Clay Database Design Diagram'.
  4. Um sich ein bestehendes Datenbank-Schema anzusehen, starten Sie ebenfalls ein neues Clay-Projekt wie gerade beschrieben. Anschließend klicken Sie mit der rechten Maustaste in den mittleren Editor-View und wählen 'Reverse Engineer Database...' | 'Add New' und geben die Verbindungsdaten zu Ihrer Datenbank ein. Für eine MySQL-Datenbank könnten die Einträge zum Beispiel folgendermaßen aussehen:
    Connection Type = 'MM.MySQL'
    Alias = 'MySQL-MeineDb'
    URL = 'jdbc:mysql://localhost:3306/MeineDb'
    User = 'root'
    Password = 'mysqlpwd'
    JDBC Driver = 'com.mysql.jdbc.Driver'
    Driver Location = 'C:\Java\jdk\jre\lib\ext\mysql-connector-java-5.1.11-bin.jar'


UML-Editor

JUDE und yEd

Empfehlenswerte Editoren für UML-Diagramme sind zum Beispiel JUDE und yEd. Leider stehen sie nicht als Eclipse-Plug-in zur Verfügung.

EclipseUML

Omondo EclipseUML ist ein UML-Editor als Eclipse-Plug-in. Die kostenlose EclipseUML Free Edition unterliegt allerdings vielen Einschränkungen.

Installation:

  1. Download des EclipseUML-Plug-ins von 'http://www.omondo.com'.

  2. In einem Kommandozeilenfenster Aufruf der .jar-Installationsdatei, zum Beispiel so:

    java -jar eclipseUML_E310_freeEdition_2.1.0.jar

  3. Als Zielverzeichnis das Eclipse-Installationsverzeichnis angeben (z.B. 'C:\Java\eclipse').
  4. Eclipse neu starten und überprüfen, dass Plug-ins installiert sind: Unter 'Help' | 'About Eclipse' | 'Plug-in Details' müssen aufgelistet sein: 'Eclipse.org EMF ...', 'Eclipse.org Graphical Editing Framework (GEF)' und 'Omondo EclipseUML ...'.
  5. Beachten Sie die FAQs unter 'http://www.omondo.com/faq/common' und insbesondere die Doku unter 'http://www.download-omondo.com/documentation/EclipseUMLStudioDocumentation.pdf'.

Benutzung:

  1. In Eclipse: 'Window' | 'Open Perspective' | 'Java'.
  2. 'File' | 'New' | 'Project...' | 'Java Project' | 'Next' | 'Project name = MyUmlTestProject' | 'Finish'.
  3. Rechter Mausklick auf den links im 'Package Explorer' neu erscheinenden Projektnamen | 'New' | 'Package' | 'Name = myumltestpckg' | 'Finish'.
  4. Rechter Mausklick auf den links im 'Package Explorer' neu erscheinenden Paketnamen | 'New' | 'Other...' | '[+] UML Diagrams' | die gewünschte Diagrammart auswählen.


JUnit mit Eclipse

... finden Sie in java-junit.htm#JUnit-mit-Eclipse.



CVS-Integration

Informationen zu CVS finden Sie unter Introduction und CVS-Buch.

Eclipse bietet eine sehr gute CVS-Integration. Die Konfiguration der CVS-Integration erfolgt folgendermaßen:

  1. 'Window' | 'Open Perspective' | 'Other...' | 'CVS Repository Exploring'.
  2. Klicken Sie mit der rechten Maustaste in das neu geöffnete 'CVS Repositories'-Fenster und wählen Sie 'New' | 'Repository Location...'. Tragen Sie 'Host', 'Repository Path', 'User' und 'Password' ein.
  3. Klicken Sie im 'CVS Repositories'-Fenster auf die '[+]'-Zeichen vor dem Repository Path, vor den darunter erscheinenden CVS-Tags und vor den Projektmodulnamen.
  4. Klicken Sie nacheinander mit der rechten Maustaste auf die Modulnamen, die Sie auschecken wollen und wählen Sie jeweils 'Check Out As...' | korrekten Projekttyp wählen | 'Next' | 'Project name' eingeben | 'Finish'.
  5. Überprüfen Sie die Projekteingenschaften, indem Sie in der 'Java'-Perspektive im 'Package Explorer' mit der rechten Maustaste auf den Projektmodulnamen klicken und 'Properties' | 'Java Build Path' wählen.

Update (vom CVS Repository zur lokalen Festplatte):

  1. 'Window' | 'Open Perspective' | 'Java'.
  2. Fenster 'Package Explorer' | rechte Maustaste auf Packagename | 'Team' | 'Update...'.

Lokale Datei mit Originaldatei aus CVS ersetzen:

  1. 'Window' | 'Open Perspective' | 'Java'.
  2. Fenster 'Package Explorer' | rechte Maustaste auf Sourcedateiname | 'Replace With' | 'Latest from <MeinCvsTag>'.

Wenn Sie von einem bestimmten Branch (oder einer bestimmten Version) auschecken wollen, verfahren Sie folgendermaßen:

  1. Checken Sie zuerst normal zum Beispiel aus CVS-Head aus.
  2. Für das Modul, welches aus einem bestimmten Branch ausgecheckt werden soll:
    Im 'Package Explorer' | rechte Maustaste auf Modulname | 'Replace With' | 'Another Branch or Version...' | [+] Branches | Branch wählen | 'OK'.
  3. Falls der gewünschte Branch (bzw. die Version) in der Liste der Branches nicht angezeigt wird:
    Im 'Package Explorer' | rechte Maustaste auf Modulname | 'Replace With' | 'Another Branch or Version...' | 'Configure Tags…' | Unter 'Browse files or Tags' irgendeine signifikante Datei anklicken | 'Deselect All' wählen | unter 'New tags found in the selected files' den gewünschten Branch (bzw. Version) aktivieren | 'Add Checked Tags' wählen | 'OK'.

Synchronisierung zwischen CVS und lokalen Dateien:

  1. 'Window' | 'Open Perspective' | 'Java'.
  2. Fenster 'Package Explorer' | rechte Maustaste auf Packagename | 'Team' | 'Synchronize with Repository...' | Umschaltung zur Perspective 'Team Synchronizing' | im Fenster 'Synchronize' Mausklick auf Icon 'Synchronize...' | Mausklick auf Icon 'Incoming/Outgoing Mode' | Mausklick auf Icon 'Go to Next Difference'.

Wenn Sie die CVS-Dialoge im Consolenfenster verfolgen wollen, wählen Sie:

  1. 'Window' | 'Preferences' | '[+] Team' | '[+] CVS' | 'Console' | 'Show CVS console automatically when command is run'.


Subversion-Integration

Subclipse ist ein Eclipse-Plug-in, mit dem Projekte in Subversion ein- und ausgecheckt werden können. Die Benutzung erfolgt folgendermaßen:

Installation von Subclipse in Eclipse:

  1. In Eclipse: 'Help' | 'Software Updates' | 'Find and Install...' | 'Search for new features to install' | 'New Remote Site...' | Name = 'Subclipse', URL = 'http://subclipse.tigris.org/update' | 'Finish' | 'Select the features to install': Häkchen einschalten | 'Finish'.
  2. 'Window' | 'Open Perspective' | 'Other...' | 'SVN Repository Exploring'.
  3. Klicken Sie mit der rechten Maustaste in das neu geöffnete 'SVN Repository'-Fenster und wählen Sie 'New' | 'Repository Location...'. Tragen Sie 'Url', 'User' und 'Password' ein.
  4. Falls zwischen Eclipse-PC und Subversion-Rechner eine Firewall geschaltet ist, muss dort eventuell der Port 3690 für TCP freigegeben werden.

Modul auschecken:

  1. 'Window' | 'Open Perspective' | 'Other...' | 'SVN Repository Exploring'.
  2. Klicken Sie im 'SVN Repository'-Fenster auf die '[+]'-Zeichen vor dem Repository Path und vor den darunter erscheinenden SVN-Tags und Projektmodulnamen.
  3. Klicken Sie nacheinander mit der rechten Maustaste auf die Modulnamen, die Sie auschecken wollen und wählen Sie jeweils 'Check Out As...' | korrekten Projekttyp wählen | 'Next' | 'Project name' eingeben | 'Finish'.
  4. Überprüfen Sie die Projekteingenschaften, indem Sie in der 'Java'-Perspektive im 'Package Explorer' mit der rechten Maustaste auf den Projektmodulnamen klicken und 'Properties' | 'Java Build Path' wählen.
  5. Falls unerwartete 'errors' oder 'warnings' gemeldet werden, wählen Sie:
    'Project' | 'Clean...' | 'Clean all Projects'.

Update (vom SVN Repository zur lokalen Festplatte):

  1. 'Window' | 'Open Perspective' | 'Java'.
  2. Fenster 'Package Explorer' | rechte Maustaste auf Packagename | 'Team' | 'Update...'.

Lokale Datei mit Originaldatei aus SVN vergleichen oder ersetzen:

  1. 'Window' | 'Open Perspective' | 'Java'.
  2. Fenster 'Package Explorer' | rechte Maustaste auf Sourcedateiname | 'Compare With' bzw. 'Replace With' | 'Latest from Repository'.

Synchronisierung zwischen SVN und lokalen Dateien:

  1. 'Window' | 'Open Perspective' | 'Java'.
  2. Fenster 'Package Explorer' | rechte Maustaste auf Packagename | 'Team' | 'Synchronize with Repository' | Umschaltung zur Perspective 'Team Synchronizing' | im Fenster 'Synchronize' Mausklick auf Icon 'Synchronize...' | Mausklick auf Icon 'Incoming/Outgoing Mode' | Mausklick auf Icon 'Go to Next Difference'.

Löschen von Dateien im SVN Repository:

  1. Sowohl im 'SVN Repository'- als auch im 'Synchronize'-View können Dateien oder Ordner gelöscht werden.


Eclipse mit Maven

Zur Zusammenarbeit von Eclipse mit Maven siehe: maven.htm#Eclipse.



Links auf weiterführende Informationen




Weitere Themen: andere TechDocs | Eclipse-Einstellungen | Eclipse mit Tomcat | Eclipse mit Geronimo
© 1998-2008 Torsten Horn, Aachen