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.



Inhalt

  1. Terminologie in Eclipse
  2. Installation von Eclipse unter Linux
  3. Installation von Eclipse unter Windows
  4. Einige Tastaturkürzel
  5. Templates
  6. Erste Konsolenanwendung
  7. Weitere erste Anwendungen
  8. Import von 'Ant'-Projekten
  9. Export als ausführbare .jar-Datei
  10. SQL-Datenbank-Clients (SQuirreL, QuantumDB, SQLExplorer, Clay)
  11. UML-Editor (JUDE und yEd, EclipseUML)
  12. JUnit mit Eclipse
  13. CVS-Integration
  14. Subversion-Integration
  15. Eclipse-Updates über Firmen-Firewalls mit dem Cntlm Authentication Proxy
  16. Plug-in-Installation ohne Internet
  17. Das M2Eclipse-Plugin (m2e) zur Zusammenarbeit von Eclipse mit Maven
  18. Links auf weiterführende Informationen


Terminologie in Eclipse



Installation von Eclipse unter Linux



Installation von Eclipse unter Windows

  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 7 von http://www.oracle.com/technetwork/java/javase/downloads und installieren Sie es zum Beispiel nach 'C:\Program Files\Java\jdk1.7', so wie beschrieben unter java-install.htm (inklusive Setzen der korrekten Umgebungsvariablen).
  3. Downloaden Sie das aktuelle Eclipse SDK (z.B. 'eclipse-jee-helios-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 inklusive 'eclipse' zum Beispiel nach 'D:\Tools', so dass die Datei 'eclipse.exe' im Verzeichnis 'D:\Tools\eclipse' liegt.
  5. Start von 'D:\Tools\eclipse\eclipse.exe'.
  6. Als Workspace-Verzeichnis besser nicht das vorgeschlagene bei den Eclipse-Programmdateien angeordnete 'D:\Tools\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.7') 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
 F11Debug
 F12Focus to editor window
 Shift+F2Show Javadoc
 Alt+Left, Alt+Right  Go to prev/next editor position in history
 Alt+Shift+AToggle Block Selection Mode
 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+/Ein- bzw. Auskommentieren
 Ctrl+_Split-Screen
 Ctrl+1Quick fix
 Ctrl+FSearch
 Ctrl+GShow declaration(s)
 Ctrl+HSearch in files
 Ctrl+KSearch next
 Ctrl+MMaximize or reduce size of view
 Ctrl+OPop-up outline
 Ctrl+QGo to last modified editor position
 Ctrl+TShow class hierarchy
 Ctrl+F6Change to next Editor file
 Ctrl+F11Run
 Ctrl+Alt+HGo to declaration and open call hierarchy
 Ctrl+Shift+BToggle breakpoint
 Ctrl+Shift+FFormat code
 Ctrl+Shift+GShow all references
 Ctrl+Shift+IInspect variable
 Ctrl+Shift+KSearch backwards
 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
 ma Ctrl+Spacemain( String[] args ) { }
 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', 'jee-jax-ws.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.

ERMaster

ERMaster ist ein sehr empfehlenswertes Bearbeitungsprogramm für ER-Diagramme (Entity-Relationship). Es steht als Eclipse-Plug-in zur Verfügung und kann über die Update-Site http://ermaster.sourceforge.net/update-site/ in Eclipse installiert werden.

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. 'D:\Tools\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 'mysql-connector-java-5.1.16-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. 'D:\Tools\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 = 'mysql-connector-java-5.1.16-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 = 'mysql-connector-java-5.1.16-bin.jar'


UML-Editor

JUDE und yEd

Empfehlenswerte Editoren für UML-Diagramme sind zum Beispiel astah (früher JUDE), yEd und Cacoo. 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. 'D:\Tools\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'.

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 beispielsweise unter Introduction to CVS und im CVS-Buch.

Eclipse bietet eine sehr gute CVS-Integration.

Falls Sie im Folgenden auf eine dieser Fehlermeldungen stoßen:

Could not create the view: org.eclipse.team.ccvs.ui.RepositoriesView

org.eclipse.team.core.TeamException: Could not instantiate provider org.eclipse.team.cvs.core.cvsnature

Dann haben Sie wahrscheinlich eine neue Eclipse-Version installiert, bei der das CVS-Plug-in noch nicht installiert wurde. Führen Sie in diesem Fall beispielsweise für die Mars-Eclipse-Version aus:
'Help' | 'Install New Software...' | 'Work with: Mars - http://download.eclipse.org/releases/mars' | 'Collaboration' | 'Eclipse CVS Client'.

Die Konfiguration der CVS-Integration erfolgt in folgenden Schritten:

  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-Updates über Firmen-Firewalls mit dem Cntlm Authentication Proxy

In Firmennetzwerken ist häufig der direkte Internetzugang für Tools wie Eclipse gesperrt. Um dennoch die automatische Eclipse-Update-Funktion verwenden zu können, kann der Cntlm Authentication Proxy verwendet werden (wenn die IT-Abteilung das erlaubt). Er steht für verschiedene Betriebssysteme zur Verfügung. Hier folgt eine Kurzanleitung für Windows-Workstations, die übers Firmennetzwerk nur über eine NTLM-Authentifizierung ins Internet gelangen.

Installation von Cntlm

  1. Download von cntlm-0.92.3-setup.exe und ausführen.
  2. Falls Sie alternativ eine ältere Version installieren wollen, zum Beispiel 0.35.1:
    Download von cntlm-0.35.1-win32.zip und entzippen. cntlm-install\README.txt lesen.

    Falls Sie unter 64-bit-Windows installieren, müssen Sie die cntlm-install\setup.bat-Datei anpassen. Ändern Sie die Zeile

    set DIR=%PROGRAMFILES%\Cntlm

    zu:

    set DIR=%ProgramFiles(x86)%\Cntlm

    Führen Sie die cntlm-install\setup.bat mit Administratorrechten aus (über rechte Maustaste).

  3. Passen Sie die cntlm.ini an (in "C:\Programme\Cntlm" bzw. "C:\Program Files (x86)\Cntlm"), zum Beispiel so:
    Username<Windows-Benutzername>
    Password<Windows-Kennwort>
    Domain<Windows-Domäne>
    Proxy<Firmen-Proxy-Adresse>:<Port>
    NoProxylocalhost, 127.0.0.*, 10.*, 192.168.*
    Listen3128
    AuthNTLMv2
    PassNTLMv2 <Hashcode des Proxy-Account-Kennworts, siehe Erläuterung>
    Gatewayno
    Allow127.0.0.1
    Deny0/0
  4. Starten Sie Cntlm als Windows-Dienst:
    'Start' | 'Systemsteuerung' | ['System und Sicherheit'] | 'Verwaltung' | 'Dienste' | 'Cntlm Authentication Proxy': "Autostart Automatisch"
    (es gibt auch einen alternativen Weg, siehe: http://wiki.eclipse.org/ECF_Filetransfer_Support_for_NTLMv2_Proxies).
  5. Falls Sie unsicher sind, ob die Cntlm-Installation erfolgreich ist, können Sie dies mit cURL überprüfen. Der folgende Aufruf muss HTML-Code downloaden:

    curl -x localhost:3128 www.google.de

    Falls dies funktioniert, aber Eclipse Updates und Plug-ins trotzdem nicht findet, müssen eventuell vom Netzwerkadministrator Gruppenrichtlinien zur Proxyberechtigung erweitert werden.

Proxy in Eclipse eintragen

  1. In Eclipse Cntlm als Autorisierungs-Proxy definieren:
    'Window' | 'Preferences' | 'General' | 'Network Connections':

    Active Provider: Manual
    Proxy entries
    [X] HTTP 127.0.0.1 3128 Manual No    
    [X] HTTPS     Manual No   [Clear betätigen]
    [X] SOCKS     Manual No   [Clear betätigen]
    [ ] HTTP Dynamic Dynamic Native No    
    Proxy bypass
    [X] localhost Manual        
    [X] 127.0.0.1 Manual        
  2. In Eclipse automatische Updates aktivieren:
    'Window' | 'Preferences' | 'Install/Update' | 'Automatic Updates': Aktivieren.


Plug-in-Installation ohne Internet

Falls Sie Eclipse-Updates oder Eclipse-Plug-ins installieren wollen, aber Ihr PC keine Internetverbindung hat, oder es kommt zu Fehlern und Abbrüchen während des Downloads (z.B. "Read timed out"), dann können Sie die Installation folgendermaßen auch ohne Internetverbindung durchführen.

  1. Ermitteln Sie die URL des gewünschten Artifakts. Einige Beispiele:
    http://download.eclipse.org/technology/m2e/releases    [für das M2Eclipse-Plugin]
    http://cbes.javaforge.com/update    [für das MercurialEclipse-Plugin]
    http://download.eclipse.org/birt/update-site/4.4    [für das BIRT-Plugin]
    http://ermaster.sourceforge.net/update-site    [für das ERMaster-Plugin]

  2. Downloaden Sie (z.B. von einem anderen PC aus mit funktionierender Internetverbindung) zuerst die Metadaten und dann das eigentliche Artefakt. Passen Sie in den drei set-Variablen die Artefakt-Download/Update-URL, den Zielpfad und den Pfad zu Eclipse an:

    set _SrcUrl=http://download.eclipse.org/technology/m2e/releases

    set _DstDir=C:\Temp\MeinNeuesEclipsePlugin

    set _EclDir=D:\Tools\Eclipse

    %_EclDir%\eclipse.exe -nosplash -verbose -application org.eclipse.equinox.p2.metadata.repository.mirrorApplication -source %_SrcUrl% -destination %_DstDir%

    %_EclDir%\eclipse.exe -nosplash -verbose -application org.eclipse.equinox.p2.artifact.repository.mirrorApplication -source %_SrcUrl% -destination %_DstDir%

  3. Alternativ können Sie auch folgende Kommandos verwenden:

    java -jar %_EclDir%\plugins\org.eclipse.equinox.launcher_*.jar -verbose -application org.eclipse.equinox.p2.metadata.repository.mirrorApplication -source %_SrcUrl% -destination %_DstDir%

    java -jar %_EclDir%\plugins\org.eclipse.equinox.launcher_*.jar -verbose -application org.eclipse.equinox.p2.artifact.repository.mirrorApplication -source %_SrcUrl% -destination %_DstDir%

  4. Überprüfen Sie, ob die dabei entstandenen Logdateien Fehlermeldungen enthalten:

    dir  %_EclDir%\configuration\*.log

    type %_EclDir%\configuration\*.log

  5. Installieren Sie das Artefakt in Eclipse (ersetzen Sie <MeinZielpfad> z.B. durch C:\Temp\MeinNeuesEclipsePlugin):
    "Help | Install New Software... | Add... | Local... | Location: <MeinZielpfad> | OK".
    Deaktivieren Sie dabei unbedingt folgende Checkbox:
    "Contact all update sites during install to find required software".

  6. Falls Sie eine Fehlermeldung erhalten ähnlich zu:

    An error occurred while installing the items
    session context was:(profile=epp.package.jee, phase=org.eclipse.equinox.internal.p2.engine.phases.Install, operand=...).
    Failed to prepare partial IU: [R]...

    Der Grund hierfür sind meistens korrupte Installationsdateien, etwa weil ein Proxy den vollständigen Download blockiert. In solchen Fällen kann die oben beschriebene Vorgehensweise helfen.

    Falls Sie diese Fehlermeldung bei obiger Vorgehensweise erhalten: Dann ist vermutlich durch vorherige Fehlversuche noch eine korrupte .jar-Datei im Eclipse-plugins-Verzeichnis (z.B. D:\Tools\Eclipse\plugins) vorhanden. Falls Sie eine .jar-Datei im Eclipse-plugins-Verzeichnis finden mit demselben Dateinamen wie im Plugin-Installationsverzeichnis, und diese Datei hat eine andere Größe, dann löschen Sie diese Datei oder ersetzen Sie sie durch die Datei aus dem Plugin-Installationsverzeichnis.



Das M2Eclipse-Plugin (m2e) zur Zusammenarbeit von Eclipse mit Maven

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

Falls Sie zusätzliche Unterstützung in Eclipse zu Maven wünschen, empfiehlt sich das M2Eclipse-Plugin. In Eclipse ab Version 4.3 ist es bereits enthalten. In vorherigen Versionen installieren Sie es wie im Folgenden beschrieben ist.

  1. Überprüfen Sie in Eclipse unter
    "Window | Preferences | Java | Installed JREs",
    dass nicht ein reines JRE, sondern ein JDK eingetragen und aktiviert ist, zum Beispiel: "jdk1.7 (C:\Programme\Java\jdk1.7)".

  2. Geben Sie unter
    "Help | Install New Software... | Add..." ein:

    Name:M2Eclipse
    Location: http://download.eclipse.org/technology/m2e/releases

    Falls Sie ein älteres Projekt haben und die aktuelle M2Eclipse-Version für dieses Projekt nicht funktioniert: Die M2Eclipse-Vorgängerversionen (z.B. 0.12) finden Sie unter: http://m2eclipse.sonatype.org/sites/m2e.

  3. Normalerweise sollten Sie folgende Checkboxen aktivieren:
    "Show only the latest versions of available software"
    "Contact all update sites during install to find required software" (nicht aktivieren, falls Installation ohne Internet, siehe oben)

  4. Falls Sie Fehlermeldungen erhalten wie:
    Eclipse is running in a JRE, but a JDK is required
    oder
    Please make sure the -vm option in eclipse.ini is pointing to a JDK and verify that Installed JREs are also using JDK installs,
    dann fügen Sie in der eclipse.ini (z.B. in D:\Tools\eclipse) vor dem -vmargs-Eintrag einen geeigneten Eintrag ähnlich Folgendem hinzu:

    -vm
    C:\Programme\Java\jdk1.7\jre\bin\client\jvm.dll

    Überprüfung Sie die Eclipse-Konfiguration unter:
    "Help | About Eclipse | Installation Details | Configuration":
    Dort finden Sie auch den gesetzten "-vm ..."-Eintrag.

  5. Passen Sie die M2Eclipse-Settings an unter:
    "Window | Preferences | Maven | User Settings", zum Beispiel so (passen Sie die Pfade an):

    User Settings File: C:\Users\User\.m2\settings.xml
    Local Repository:C:\Users\User\.m2\repository

    Oder so:

    User Settings File: D:\Tools\Maven3\conf\settings.xml
    Local Repository:D:\Tools\Maven3-Repo
  6. Vorsichtshalber können können Sie überprüfen, dass die M2_REPO-Variable korrekt gesetzt ist:
    "Window | Preferences | Java | Build Path | Classpath Variables":

    M2_REPO: C:\Users\User\.m2\repository bzw. D:\Tools\Maven3-Repo
  7. Bevor Sie ein Projekt als "Maven-Projekt" importieren oder umkonfigurieren, sollten Sie die .classpath-Datei im Projektverzeichnis löschen, falls eine vorhanden ist.
    Importieren Sie ein Projekt als Maven-Projekt über:
    "File | Import... | Maven | Existing Maven Projects | D:\MeinWorkspace".
    Oder alternativ klicken Sie im Eclipse Package Explorer mit der rechten Maustaste auf vorhandene Projekte und wählen:
    "Configure | Convert to Maven Project".
    In beiden Fällen sollten Sie anschließend noch über die rechten Maustaste wählen (bevor Sie in Eclipse mit F5 "refreshen"):
    "Properties | Maven": Deaktivieren: "Resolve dependencies from Workspace projects".
    Zuletzt müssen Sie unbedingt (wie nach jeder Änderung außerhalb von Eclipse) in Eclipse das Projekt mit F5 "refreshen".

  8. Falls Sie Probleme haben, klicken Sie im Eclipse Package Explorer mit der rechten Maustaste auf das Projekt und versuchen Sie:
    a) "Properties | Maven": Deaktivieren: "Resolve dependencies from Workspace projects".
    b) "Maven | Update Project Configuration...": Aktivieren: "Force Update of Snapshots/Releases", anschließend: OK.

  9. Falls Sie Mercurial (hg) verwenden: Sehen Sie sich das MercurialEclipse-Plugin an.
    Falls Sie Maven-Multimodulprojekte verwenden: Sehen Sie sich Maven-Multimodulprojekt aus einem Mercurial-Repository in Eclipse importieren an.

  10. Falls Sie in einem gemeinsamen Eclipse-Workspace-Verzeichnis (z.B. D:\MeinWorkspace) sowohl M2Eclipse-Maven-Projekte als auch Maven-Projekte haben, die nicht M2Eclipse verwenden, sondern deren Eclipse-Projektdateien per "mvn eclipse:eclipse" aktualisiert werden, kann folgende Batchdatei hilfreich sein, mit der Sie alle Nicht-M2Eclipse-Maven-Projekte aktualisieren können, ohne die M2Eclipse-Maven-Projekte zu beschädigen:

    MvnEclipseAusserM2e.bat

    cls
    @title %~n0
    @echo off
    echo.
    echo -----------------------------------------------------------
    echo Fuehre in allen Unterordnern, die eine 'pom.xml' enthalten
    echo und kein Multimodulprojekt und kein M2Eclipse-Projekt sind,
    echo das Kommando 'mvn eclipse:clean eclipse:eclipse' aus.
    echo -----------------------------------------------------------
    echo.
    pushd .
    echo %cd%
    FOR /F %%i in ('dir /B /A:D') DO (
      cd %%i
      echo.
      if not exist pom.xml (
        echo --- Info: %%i enthaelt keine 'pom.xml'.
      ) else (
        findstr ^<modules^> pom.xml > nul
        if not errorlevel 1 (
          echo --- Info: %%i ist ein Multimodulprojekt, keine Aktion.
        ) else (
          if not exist .project (
            echo --- Info: %%i enthaelt keine '.project', starte 'mvn eclipse:eclipse':
            call mvn eclipse:clean eclipse:eclipse
            if errorlevel 1 goto _Fehler
          ) else (
            findstr .maven2Nature .project > nul
            if not errorlevel 1 (
              echo --- Info: %%i ist ein M2Eclipse-Projekt.
            ) else (
              echo --- Info: %%i ist kein M2Eclipse-Projekt, starte 'mvn eclipse:eclipse':
              call mvn eclipse:clean eclipse:eclipse
              if errorlevel 1 goto _Fehler
            )
          )
        )
      )
      @echo off
      cd ..
    )
    echo.
    echo -------------------
    echo --- SUCCESSFULL ---
    echo -------------------
    @echo 
    goto _fertig
    
    :_Fehler
    echo.
    echo ##############
    echo ### Fehler ###
    echo ##############
    @echo 
    pause
    
    :_fertig
    @popd
    @title %~dp0
    


Links auf weiterführende Informationen





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