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
- Terminologie in Eclipse
- Installation von Eclipse unter Linux
- Installation von Eclipse unter Windows
- Einige Tastaturkürzel
- Templates
- Erste Konsolenanwendung
- Weitere erste Anwendungen
- Import von 'Ant'-Projekten
- Export als ausführbare .jar-Datei
- SQL-Datenbank-Clients
(SQuirreL,
QuantumDB,
SQLExplorer,
Clay)
- UML-Editor
(JUDE und yEd,
EclipseUML)
- JUnit mit Eclipse
- CVS-Integration
- Subversion-Integration
- Eclipse-Updates über Firmen-Firewalls mit dem Cntlm Authentication Proxy
- Plug-in-Installation ohne Internet
- Das M2Eclipse-Plugin (m2e) zur Zusammenarbeit von Eclipse mit Maven
- Eclipse mit Java 9 und Jigsaw
- Links auf weiterführende Informationen
Terminologie in Eclipse
- Workbench (Werkbank)
Eclipse-IDE (Integrated Developer Environment).
- Workspace (Arbeitsraum)
Verzeichnisordner auf der Festplatte zum Abspeichern der Projektdaten ('File' | 'Switch Workspace...').
- Project (Projekt)
Ein Projekt umfasst die zur Erzeugung einer Anwendung notwendigen Dateien.
Mehrere (voneinander abhängige oder unabhängige) Projekte können gemeinsam in einem Workspace oder auch außerhalb gespeichert sein.
- Perspective (Blickwinkel, Betrachtungsweise)
Kontextbezogene Sicht auf das Projekt, realisiert durch Auswahl und Anordnung bestimmter View- und Editor-Fenster.
- View (Ansicht)
Fenster in der Eclipse-IDE.
Während der Editor im Hauptfenster der Sourcecode-Bearbeitung dient,
fungieren die zusätzlichen View-Fenster eher zur Darstellung (und eventuell Bearbeitung) von Eigenschaften und Zusatzinformationen.
Installation von Eclipse unter Linux
Installation von Eclipse unter Windows
- 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').
- 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).
- Downloaden Sie das aktuelle Eclipse SDK (z.B. 'eclipse-jee-helios-win32.zip') von
http://www.eclipse.org
in ein beliebiges temporäres Verzeichnis.
- 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.
- Start von 'D:\Tools\eclipse\eclipse.exe'.
- 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'.
- Führen Sie weitere Einstellungen durch, wie sie in
java-eclipse-einstellungen.htm
aufgeführt sind.
- Lesen Sie die Texte unter 'Overview', 'Tutorials' und 'Samples'.
- Oft werden zusätzliche Plug-ins zu Eclipse benötigt, siehe dazu
http://www.eclipse-plugins.info/eclipse/plugins.jsp.
- Falls Sie ein vorhandenes Projekt importieren wollen, wählen Sie:
'File' | 'Import...' | '[+] General' | 'Existing Projects into Workspace' | 'Select root directory'.
- 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.
- 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
- 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'.
| F4 | Open type hierarchy |
| F5 | File, Package Explorer: Refresh |
| F5, F6, F7, F8 | Debugging: Step into, over, return, resume |
| F11 | Debug |
| F12 | Focus to editor window |
| Shift+F2 | Show Javadoc |
| Alt+Left, Alt+Right | Go to prev/next editor position in history |
| Alt+Shift+A | Toggle Block Selection Mode |
| Alt+Shift+M | Extract method |
| Alt+Shift+R | Rename method/variable |
| Ctrl+Mausclick | Go to declaration |
| Ctrl+Space | Automatic code completion |
| Ctrl+Shift+Space | Method parameters |
| Ctrl+, Ctrl+. | Go to previous/next problem, warning, bookmark, etc. |
| Ctrl+/ | Ein- bzw. Auskommentieren |
| Ctrl+_ | Split-Screen |
| Ctrl+1 | Quick fix |
| Ctrl+F | Search |
| Ctrl+G | Show declaration(s) |
| Ctrl+H | Search in files |
| Ctrl+K | Search next |
| Ctrl+M | Maximize or reduce size of view |
| Ctrl+O | Pop-up outline |
| Ctrl+Q | Go to last modified editor position |
| Ctrl+T | Show class hierarchy |
| Ctrl+F6 | Change to next Editor file |
| Ctrl+F11 | Run |
| Ctrl+Alt+H | Go to declaration and open call hierarchy |
| Ctrl+Shift+B | Toggle breakpoint |
| Ctrl+Shift+F | Format code |
| Ctrl+Shift+G | Show all references |
| Ctrl+Shift+I | Inspect variable |
| Ctrl+Shift+K | Search backwards |
| Ctrl+Shift+M | Import type under cursor |
| Ctrl+Shift+O | Organise imports |
| Ctrl+Shift+P | Go to matching bracket |
| Ctrl+Shift+R | Open resource |
| Ctrl+Shift+T | Open type |
| Ctrl+Shift+U | Show occurences in this file |
| ma Ctrl+Space | main( String[] args ) { } |
| syso Ctrl+Space | System.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:
- 'Window' | 'Preferences' | '[+] General' (früher '[+] Workbench')
| 'Keys' | 'Modify' (früher 'Keyboard Shortcuts')
- 'Command': 'Category' = 'Edit', 'Name' = 'Find Next', 'Assignments': 'Ctrl+K' markieren
- '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.
- 'Window' | 'Preferences' | '[+] Java' | '[+] Editor' | 'Template' | 'New...'
- 'Name = log4j', 'Description = Log4j-Logger',
'Pattern = private static final Logger LOGGER = Logger.getLogger(${primary_type_name}.class);'
- 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
- Installation von Java und Eclipse wie oben beschrieben und starten von Eclipse.
- 'Window' | 'Open Perspective' | 'Java'.
- 'File' | 'New' | 'Project...' | 'Java Project' | 'Next';
Project name: 'FirstHelloWorld' | 'Finish'.
- Links im 'Package Explorer' erscheint der neue Projektname.
Rechter Mausklick auf diesen Projektnamen | 'New' | 'Package' | Name: 'firsthelloworldpckg' | 'Finish'.
- Im 'Package Explorer' erscheint der neue Paketname.
Rechter Mausklick auf diesen Paketnamen | 'New' | 'Class' | Name: 'HelloWorld' | Checkbox 'public static void main(...)' einschalten | 'Finish'.
- 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.
- 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.
- 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.
- 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'.
- 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):
- 'Window' | 'Open Perspective' | 'Java'.
- 'File' | 'New' | 'Project...' | 'Java Project' | 'Next';
Project name: 'MeineErstenVersuche' | 'Finish'.
- Rechter Mausklick auf den neuen Projektnamen 'MeineErstenVersuche' im 'Package Explorer'
| 'New' | 'Package' | Name: 'beispiele' | 'Finish'.
- 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').
- 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.
- Fügen Sie als erste Anweisung in die Sourcedatei ein:
package beispiele;
- 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'.
- 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).
- 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.
- Falls die Anwendung Kommandozeilenparameter erwartet
(wie z.B. 'FileCopy', 'FileFromUrl' und 'MyImgShow'),
wählen Sie 'Run' | 'Run...' | 'Java Application' | 'New' | ... | 'Arguments' | ...
- 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
'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:
- 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').
- Wählen Sie weiter: 'Browse' | '<Ant-Skript-XML-Datei>' (meistens 'build.xml').
- 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.
- 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:
Ü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
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
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>
Rufen Sie im Kommandozeilenfenster auf
(hierfür muss natürlich 'ant' installiert sein, siehe
java-install.htm):
ant -f build-jar.xml
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
- Die erzeugte Datei 'MeineAnwendung.jar' können Sie bereits ausführen,
zum Beispiel um sie zu testen.
Aber beachten Sie bitte, dass 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.
- Zur Distribution ist nur die Datei 'MeineAnwendung.zip' geeignet.
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
Jetzt starten Sie die Anwendung wieder entweder durch Doppelklick auf
'MeineAnwendung.jar'
oder über die Kommandozeile
'java -jar MeineAnwendung.jar'.
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:
- Die folgende Beschreibung geht von einer bereits installierten SQL-Datenbank aus,
wie zum Beispiel für MySQL beschrieben unter
mysql.htm.
- Für Ihre Datenbank benötigen Sie einen passenden JDBC-Typ-4-Treiber.
Sehen Sie sich dazu
java-sql.htm an.
- Downloaden Sie die QuantumDB-Installationsdatei
(z.B. 'com.quantum.feature_3.0.0.bin.dist.zip') von
http://quantum.sourceforge.net.
- 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').
- Je nach Eclipse- und QuantumDB-Version benötigen Sie eventuell zusätzlich das 'Graphical Editor Framework (GEF)'-Plugin.
- Starten Sie Eclipse neu.
Schalten Sie die Perspektive um:
'Window' | 'Open Perspective' | 'Other...' | 'Quantum DB'.
- 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'.
- 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.
- 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'.
- 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.
- Mit dem 'Filter and Sort'-Icon (mit den drei nach rechts zeigenden Pfeilen) können Sie die Tabellenansicht beeinflussen.
- Im 'Quantum SQL Query Editor'-View können Sie SQL-Kommandos ausführen.
SQLExplorer-Plug-in
Installation des SQL-Clients SQLExplorer Eclipse-Plug-in:
- Die folgende Beschreibung geht von einer bereits installierten SQL-Datenbank aus,
wie zum Beispiel für MySQL beschrieben unter
mysql.htm.
- Für Ihre Datenbank benötigen Sie einen passenden JDBC-Typ-4-Treiber.
Sehen Sie sich dazu
java-sql.htm an.
- Downloaden Sie die SQLExplorer-Installationsdatei
(z.B. 'net.sourceforge.sqlexplorer_2.2.3.zip') von
http://sourceforge.net/projects/eclipsesql.
- 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').
- Starten Sie Eclipse neu.
Schalten Sie die Perspektive um:
'Window' | 'Open Perspective' | 'Other...' | 'SQLExplorer'.
- 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'
- 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'
- Klicken Sie doppelt auf den neu erstellten Alias-Namen im 'Aliases'-View um die Datenbankverbung herzustellen.
- 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.
- 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.
- 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.
- 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.
- 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).
- Befolgen Sie den 'Clay Quick Start Guide' unter
http://www.azzurri.jp/en/software/clay/quick_start_guide.jsp.
- Starten Sie ein Clay-Projekt über
'File' | 'New' | 'Other...' | '[+] Database Modeling' | 'Azzurri Clay Database Design Diagram'.
- 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:
- Download des EclipseUML-Plug-ins von
'http://www.omondo.com'.
In einem Kommandozeilenfenster Aufruf der .jar-Installationsdatei, zum Beispiel so:
java -jar eclipseUML_E310_freeEdition_2.1.0.jar
- Als Zielverzeichnis das Eclipse-Installationsverzeichnis angeben (z.B.
'D:\Tools\eclipse').
- 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 ...'.
- Beachten Sie die FAQs unter
'http://www.omondo.com/faq/common'.
Benutzung:
- In Eclipse: 'Window' | 'Open Perspective' | 'Java'.
- 'File' | 'New' | 'Project...' | 'Java Project' | 'Next' | 'Project name = MyUmlTestProject' | 'Finish'.
- Rechter Mausklick auf den links im 'Package Explorer' neu erscheinenden Projektnamen
| 'New' | 'Package' | 'Name = myumltestpckg' | 'Finish'.
- 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:
- 'Window' | 'Open Perspective' | 'Other...' | 'CVS Repository Exploring'.
- 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.
- Klicken Sie im 'CVS Repositories'-Fenster auf die '[+]'-Zeichen vor dem Repository Path,
vor den darunter erscheinenden CVS-Tags und vor den Projektmodulnamen.
- 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'.
- Ü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):
- 'Window' | 'Open Perspective' | 'Java'.
- Fenster 'Package Explorer' | rechte Maustaste auf Packagename | 'Team' | 'Update...'.
Lokale Datei mit Originaldatei aus CVS ersetzen:
- 'Window' | 'Open Perspective' | 'Java'.
- 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:
- Checken Sie zuerst normal zum Beispiel aus CVS-Head aus.
- 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'.
- 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:
- 'Window' | 'Open Perspective' | 'Java'.
- 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:
- '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:
- 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'.
- 'Window' | 'Open Perspective' | 'Other...' | 'SVN Repository Exploring'.
- 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.
- Falls zwischen Eclipse-PC und Subversion-Rechner eine Firewall geschaltet ist,
muss dort eventuell der Port 3690 für TCP freigegeben werden.
Modul auschecken:
- 'Window' | 'Open Perspective' | 'Other...' | 'SVN Repository Exploring'.
- Klicken Sie im 'SVN Repository'-Fenster auf die '[+]'-Zeichen vor dem Repository Path und
vor den darunter erscheinenden SVN-Tags und Projektmodulnamen.
- 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'.
- Ü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.
- Falls unerwartete 'errors' oder 'warnings' gemeldet werden, wählen Sie:
'Project' | 'Clean...' | 'Clean all Projects'.
Update (vom SVN Repository zur lokalen Festplatte):
- 'Window' | 'Open Perspective' | 'Java'.
- Fenster 'Package Explorer' | rechte Maustaste auf Packagename | 'Team' | 'Update...'.
Lokale Datei mit Originaldatei aus SVN vergleichen oder ersetzen:
- 'Window' | 'Open Perspective' | 'Java'.
- Fenster 'Package Explorer' | rechte Maustaste auf Sourcedateiname | 'Compare With' bzw. 'Replace With' | 'Latest from Repository'.
Synchronisierung zwischen SVN und lokalen Dateien:
- 'Window' | 'Open Perspective' | 'Java'.
- 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:
- 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
- Download von cntlm-0.92.3-setup.exe und ausführen.
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).
- 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> |
NoProxy | localhost, 127.0.0.*, 10.*, 192.168.* |
Listen | 3128 |
Auth | NTLMv2 |
PassNTLMv2 | <Hashcode des Proxy-Account-Kennworts, siehe Erläuterung> |
Gateway | no |
Allow | 127.0.0.1 |
Deny | 0/0 |
- 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).
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
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 | | | | | | | | |
- 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.
-
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]
-
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%
-
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%
-
Überprüfen Sie, ob die dabei entstandenen Logdateien Fehlermeldungen enthalten:
dir %_EclDir%\configuration\*.log
type %_EclDir%\configuration\*.log
-
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".
-
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.
-
Ü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)".
-
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.
-
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)
-
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.
-
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 |
-
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 |
-
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".
-
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.
-
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.
-
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
Eclipse mit Java 9 und Jigsaw
Siehe hierzu:
Jigsaw-Demo mit Eclipse.
Links auf weiterführende Informationen
Weitere Themen: andere TechDocs
| Eclipse-Einstellungen
| Eclipse mit Geronimo
© 2004-2010 Torsten Horn, Aachen