Logging mit log4j in Maven Projekt integrieren

Log4j Properties in Maven Projekt integrierenLog4j ist eine logging Library der Apache Software Foundation und ermöglicht es Log-Ausgaben im Programm an verschiedenste Ziele zu schreiben. Das bekannteste Ziel ist sicher das Schreiben der Logmeldungen in eine Log-Datei, aber auch das schreiben der Meldungen in eine Datenbank oder das Verschicken per E-Mail ist möglich. Das Ziel der Meldungen wird über sogenannte Log-Appender in der Datei log4j.properties konfiguriert. Diese liegt in einem Maven Projekt in dem Resourcen Verzeichnis. (siehe Bild)

Datei: log4j.properties

# Root logger option
log4j.rootLogger=DEBUG, file
# LogLeel DEBUG und akive appender Console und Log-Datei

# Log to console
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Log to file
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.MaxBackupIndex=2
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Log to mail
log4j.appender.email=org.apache.log4j.net.SMTPAppender
log4j.appender.email.SMTPHost=mail.mydomain.com
log4j.appender.email.SMTPUsername=myuser@mydomain.com
log4j.appender.email.SMTPPassword=mypw
log4j.appender.email.From=myuser@mydomain.com
log4j.appender.email.To=myuser@mydomain.com
log4j.appender.email.Subject=Log of messages
log4j.appender.email.BufferSize=1
log4j.appender.email.EvaluatorClass=TriggerLogEvent
log4j.appender.email.layout=org.apache.log4j.PatternLayout
log4j.appender.email.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Log to DB
log4j.appender.DB=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DB.URL=jdbc:mysql://localhost/DBNAME
log4j.appender.DB.driver=com.mysql.jdbc.Driver
log4j.appender.DB.user=user_name
log4j.appender.DB.password=password
log4j.appender.DB.sql=INSERT INTO LOGS VALUES('%x','%d','%C','%p','%m')
log4j.appender.DB.layout=org.apache.log4j.PatternLayout

# CREATE TABLE LOGS
#   (USER_ID VARCHAR(20) NOT NULL,
#    DATED   DATE NOT NULL,
#    LOGGER  VARCHAR(50) NOT NULL,
#    LEVEL   VARCHAR(10) NOT NULL,
#    MESSAGE VARCHAR(1000) NOT NULL
#   );

Die erste Zeile der obigen Datei wird konfiguriert das Meldungen ab dem DEBUG-Level und darunter in eine Datei geschriebenen werden. Der Detailgrad wird mit steigender Anzahl an Meldungen durch die Level OFF, FATAL, ERROR, WARN, INFO, DEBUG und ALL angegeben.
Um log4j in das Programm zu integrieren reicht es die Dependency in der pom.xml hinzuzufügen. Log4j findet die weiter oben gelistete Konfigurationsdatei von alle, wenn sie sich im Resource-Verzeichnis befindet.

<dependencies>
	<dependency>
		<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>1.2.17</version>
	</dependency>
</dependencies>

Das Ausgeben der Logmeldungen auf verschiedenen Log-Ebenen ist mit wenigen Zeilen Code erledigt:

import org.apache.log4j.Logger;
public class LoggingTest{
   private static Logger logger = Logger.getLogger(LoggingTest.class);
   logger.info("Info");
   logger.warn("Warn");
   logger.error("Fehlermeldung");
}

WildFly – Debug-Mode aktivieren und mit Eclipse verbinden

Um eine Anwendung im WildFly Applicationserver deployte Anwendung zu debuggen muss eine Debug-Verbindung zwischen IDE und Server hergestellt werden. Dies ist mit wenigen Handgriffen erledigt. Dazu wird zunächst WildFly im Debug-Mode gestartet, indem es mit dem Parameter –debug gestartet wird: „WILDFLY_HOME\bin\standalone.bat –debug“.
Wird der WildFly Server zur Entwicklung genutzt empfiehlt es sich ihn so zu konfigurieren, das er dauerhaft im Debug-Mode startet. Dies kann in der Batchdatei zum Starten dauerhaft aktiviert werden. „WILDFLY_HOME\standalone\bin\standalone.bat“:

set DEBUG_MODE=true
set DEBUG_PORT=8787

Eclipse Debug Konfiguration
Wenn WildFly im Debug-Mode läuft muss nur noch aus Eclipse eine TCP/IP Verbindung zum Port 8787 des WildFly Servers hergestellt werden. Die Eclipse-Konfiguration kann den Bildern entnommen werden. Im Beispiel läuft der Server auf dem lokalen Rechner. Ist dies nicht der Fall muss die IP Adresse des entfernten Widfly Servers genutzt werden. Nachdem die Verbindung zwischen Eclipse und WildFly hergestellt ist, werden Breakpoints die in der linken Leiste im Quellcode gesetzt werden aktiv. Zu erkennen an dem kleinen Häkchen.
Eclipse - WildFly Debug Connection

WildFly – Systemproperties konfigurieren und auslesen

Im WildFly Anwendungsserver können über die Systemproperties Werte gesetzt werden auf die die deployten Anwendungen zugreifen können. Dies stellt einen einfachen Weg zum Konfigurieren von Anwendungen dar. Die Konfiguration wird in der Datei „/WILDFLY_HOME/standalone/configuration/standalone.xml“ vorgenommen:

<server xmlns="urn:jboss:domain:1.3">
  <extensions>
  ...
  </extensions>
  <system-properties>
    <property name="property1name" value="property1value"/>
    <property name="property2name" value="property2value"/>
  </system-properties>
	...
</server>

Auslesen der Systemproperties im Java Programm:

String valueProperty1 = System.getProperty("property1name");

Betriebssystem Umgebungsvariablen auslesen

Auch auf die Systemvariablen des Betriebssystem lässt sich zugreifen:

System.getenv("NAME_DER_UMGEBUNGSVARIABLE ");

WildFly – Administration über die Webkonsole, CLI und Standalone.xml

WildFly speichert seine Konfiguration XML-formatiert in einer Datei ab. Die Konfiguration des Server kann direkt in dieser Datei erfolgen, oder alternativ über die Weboberfläche oder das Command Line Interface. Im folgenden werden die unterschiedlichen Wege kurz vorgestellt.

Weboberfläche

Wildfly stellt auf Port 9990 eine Weboberfläche zur Konfiguration einiger Systemeinstellungen bereit und liefert Informationen zur JVM und Systemumgebung. Zu einigen Subsystem werden Daten angezeigt und Konfigurationsmöglichkeiten angeboten. Dazu zählen u.a. Datasources, JPA, JNDI, Transactions und Webservices.

Bevor auf die Webmanagement-Oberfläche zugegriffen werden kann muss ein Management-User angelegt werden. Dazu führen Sie das Skript „add-user.bat“ unter Windows (wildfly_root\bin\add-user.bat) oder „add-user.sh“ unter Linux aus und folgen den Anweisungen.
Anschließend kann sich mit dem neuen Benutzer angemeldet werden:

http://127.0.0.1:9990/
Wildfly Webmanagement

Wildfly Webmanagement

CLI – Command Line Tool

Wildfly_CLI_GUI
Seit JBoss AS 7 gibt es ein Command Line Interface (CLI) Tool mit dem man sich zum Server verbinden kann und diverse Aufgaben durchführen kann. U.a:

  • Anwendungen im Standalone/Domain Mode deployen oder undeployen
  • Informationen zu deployten Anwendungen anzeigen
  • Starten, stoppen und neustarten des Servers
  • Hinzufügen, ändern und löschen von Subsystemen
  • Anzeige von Logdateien

    • Das CLI Tool wird über ein Skript (jboss-cli.bat oder sh) im Bin-Verzeichnis gestartet.

      "WILDFLY_HOME/bin/jboss-cli.bat"

      Mit dem Parameter gui „jboss-cli.bat –gui“ kann die Konsole in einer grafischen Ausführung gestartet werden:

      XML Konfigurationsdatei

      Wildfly speichert seine Konfiguration als XML formatierte Datei ab. Diese liegt für Standalone-Anwendungen in „WILDFLY_HOME/standalone/configuration/standalone.xml“ und für geclusterte Anwendungen, die in einer Domain zusammengefasst werden und sich eine Konfiguration teilen, in „WILDFLY_HOME/domain/configuration/domain.xml“.

      Die Konfigurationsdatei enthält für jedes Subsystem einen einzelnen Konfigurationsblock. Einige der häufiger benötigten Subsysteme sind u.a. Datasources zur Verbindung zu Datenbanken, Mail und Logging. Im unteren Part finden sich mit den Interfaces und Socket-Binding-Groups die Konfigurationseinstellungen auf welchen Ports der Wildfly Server Dienste bereit stellt. Hier ist z.B. konfiguriert, das der Server mit den Default-Einstellungen seine Dienste nur auf der lokalen IP-Adresse bereitstellt (localhost – 127.0.0.1)

WildFly – Installieren und als Dienst ausführen

Wildfly- UmgebungsvariableWildfly ist ein Application Server für Java Anwendungen der den Java EE Standard implementiert. Er ist leicht zu installieren, da es ausreicht ein aktuelles Java JRE oder JDK auf dem System zu installieren und das Wildfly Zip-Archiv zu entpackt. Die Systemvariablen sollten um eine Variable „WILDFLY_HOME“ erweitert werden, die auf das Root-Verzeichnis des Wildfly Servers zeigt. (Win7: Rechtsklick Computer -> Eigenschaften -> Erweiterte Systemeinstellungen -> Umgebungsvariablen) (Siehe Screenshot) Unter Linux wird die Systemvariable mit dem Export Befehl gesetzt: „export WILDFLY_HOME=/opt/wildfly/“

Zum Starten des Servers reicht es unter Windows die Datei „standalone.bat“ oder unter Linux die Datei „standalone.sh“ im „bin“ Verzeichnis zu starten. In einer Produktivumgebung empfiehlt es sich WildFly als Windows-Dienst oder Linux Service einzurichten.

Wildfly als Windowsdienst einrichten

Gegenüber dem JBoss AS7 ist die Installation des WildFy Anwendungsservers als Windowsservice sehr einfach, da bereits alles „ab Werk“ mit ausgeliefert wird. Dazu wird lediglich die Batchdatei „WILDFLY_HOME\bin\service\service.bat“ mit dem Parameter „install“ aufgerufen. Die Verwaltung des Dienstes inklusive Starten und Stoppen erfolgt wie gewohnt über die Computerverwaltung. Siehe Screenshot. (Windows7: Rechtsklick Computer Icon -> Verwalten -> Dienste – und Anwendungen Dienste)

Wildfly Windowsservice

Wildfly Windowsservice

WildFly als Linux Service einrichten

Um WildFly als Linux Service einzurichten werden die Skripte aus dem Verzeichnis „WILDFLY_HOME/bin/init.d“ verwendet. In diesem Verzeichnis finden sich die folgenden Skripte:

wildfly-init-redhat.sh: Dieses Skript wird für Red Hat Enterprise Linux Distributions verwendet wie RHEL oder Centos.
wildfly-init-debian.sh: Dieses Skript wird für Debian basierende Distributionen wie Debian oder Ubuntu verwendet.
wildfly.conf: Diese Datei enthält die Konfiguration für die beiden oben genannten Init-Skripte.

1. WildFly nach „/opt/wildfly“ entpacken oder kopieren. z.B. mit WinSCP. Sofern das Java JRE installiert ist, kann der WildFly Server bereits testweise gestartet werden, indem das Shell Skript „WILDFLY_HOME/bin/standalone.sh“ ausgeführt wird.

cd /opt/wildfly/bin/
./standalone.sh
Wenn die Berechtigungen nicht zum Ausführen des Skriptes reichen müssen sie entsprechend gesetzt werden:
chmod 777 standalone.sh

2. Das zur Linux Distribution passende Skript wird in das Verzeichnis „/etc/init.d“ kopiert. Für RHEL sieht dies ausgehend vom Verzeichnis „WILDFLY_HOME/bin/init.d“ wie folgt aus:

cp wildfly-init-redhat.sh /etc/init.d/wildfly

3. Die Konfigurationsdatei „wildfly.conf“ muss in das Verzeichnis „/etc/default/wildfly“ kopiert werden, damit das Startskript sie findet:

mkdir /etc/default/wildfly
cp wildfly.conf /etc/default/wildfly

4. Anschließend wird die Konfigurationsdatei angepasst. Dazu kann der Editor Nano oder vi genutzt werden:

nano /etc/default/wildfly/wildfly.conf

Der Pfad zum Java JDK und der User unter dem der Wildfly Service ausgeführt werden sollen müssen entsprechend angepasst werden. Ein neuer User kann mit dem Befehl „adduser“ angelegt werden:

JAVA_HOME=/usr/java/jdk1.7.0_21
# Location of WildFly
JBOSS_HOME=/usr/share/wildfly.8.0.0.Final
# The username who should own the process.
JBOSS_USER=wildfly
# The mode WildFly should start, standalone or domain
JBOSS_MODE=standalone
# Configuration for standalone mode
JBOSS_CONFIG=standalone.xml

5. Als nächstes wird dem Befehl „chkconfig“ das Wildfly Skript als Dienst eingerichtet. Der zweite Befehl setzt die Runlevel in denen der Dienst gestartet wird.

chkconfig --add wildfly
chkconfig --level 2345 wildfly on

6. Sofern alles richtig konfiguriert ist lässt sich der WildFly Service wie folgt starten und stoppen:

service wildfly start
service wildfly stop

Maven – JAR mit allen Dependencies erstellen

jarWenn mit Maven eine JAR-Datei erzeugt wird werden die abhängigen Libraries im Normalfall nicht mit in das JAR aufgenommen. Soll jedoch ein lauffähiges Programm ausgeliefert werden, so müssen alle Dependencies zu einem JAR zusammengefasst werden. Diese Aufgabe übernimmt das Maven Assembly Plugin. In der POM-Datei des Hauptprojektes wird es als Plugin aufgenommen und ihm mitgeteilt wo sich die Klasse mit der Main-Methode befindet. Über das Attribut „finalName“ kann der Name der zu erzeugenden JAR-Datei festgelegt werden. Abschließend wird Assembly Plugin über die Execution-Einstellungen an die Package-Phase des Maven Lebenszyklus gebunden. Ein JAR mit allen abhängigen Klassen kann dann über den Package-Befehl erstellt werden:

mvn clean package

POM Inhalt:

<build>
		<plugins>
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<configuration>
				    <finalName>JAR_NAME</finalName>
				    <appendAssemblyId>false</appendAssemblyId> 
					<descriptorRefs>
						<descriptorRef>jar-with-dependencies</descriptorRef>
					</descriptorRefs>
					<archive>
						<manifest>
							<mainClass>net.it_adviser.test.MainClass</mainClass>
						</manifest>
					</archive>
				</configuration>
				<executions>
					<execution>
						<phase>package</phase>
						<goals>
							<goal>attached</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>

Java – Dateien lesen -> zippen -> speichern

Java ZIP TestDas folgende Beispiel zeigt die Verwendung der JFileChooser Klasse zum Öffnen und Speichern von Dateien sowie das Erstellen von ZIP Archiven. Dabei wird für die Dateien ein „Umweg“ über ein Byte-Array gegangen bevor diese in eine ZIP-Datei geschrieben werden. Byte-Arrays können in BLOB (Binary large Object) Spalten von Datenbanktabellen geschrieben werden, so das dieses Beispiel den Weg zum Byte-Array mit aufzeigt. Der Quelltext ist unten aufgeführt und als Maven Projekt angehängt:

/**
 * File open -> ZIP -> save
 *
 */
public class App {
	
	private class SelectedFile {
		private String fileName;
		private byte[] rawData;
	}

	private List<SelectedFile> filesToZip = new ArrayList<SelectedFile>();
	
	public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                new App().createUI();
            }
        };
        EventQueue.invokeLater(r);
    }

	/**
	 * Creates an zip archive with all entries from List<SelectedFile> filesToZip
	 */
	private void createZipFile(String pathWithFilename) {
		byte[] buffer = new byte[1024 * 4];

		pathWithFilename = pathWithFilename.toLowerCase();
		if(!pathWithFilename.endsWith(".zip")){
			pathWithFilename += ".zip";
		}
		
		try {
			String outputFileName = pathWithFilename;
			FileOutputStream fos = new FileOutputStream(outputFileName);
			ZipOutputStream zos = new ZipOutputStream(fos);

			for (SelectedFile file : filesToZip) {
				ZipEntry ze = new ZipEntry(file.fileName);
				zos.putNextEntry(ze);

				ByteArrayInputStream bis = new ByteArrayInputStream(file.rawData);

				int len;
				while ((len = bis.read(buffer)) > 0) {
					zos.write(buffer, 0, len);
				}
				bis.close();
			}
			zos.closeEntry();
			zos.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		JOptionPane.showMessageDialog(null, "Die Datei(n) wurde(n) gezipt...",
				"Info", JOptionPane.INFORMATION_MESSAGE);
	}
	
    private void createUI() {
        final JFrame frame = new JFrame();
        frame.setLayout(new BorderLayout());

        JButton btnOpen = new JButton("Datei öffnen");
        JButton btnSave = new JButton("ZIP speichern");

        btnOpen.addActionListener(new ActionListener() {
        	@Override
        	public void actionPerformed(ActionEvent ae) {
        		JFileChooser openDialog = new JFileChooser();
        		int openDialogReturn = openDialog.showOpenDialog(frame);
        		openDialog.setMultiSelectionEnabled(false);
        	        if(openDialogReturn == JFileChooser.APPROVE_OPTION)
        	        {
        	        	SelectedFile sf = new SelectedFile();
        	        	sf.fileName = openDialog.getSelectedFile().getName();
        	        	String pathToFile = openDialog.getSelectedFile().getAbsolutePath();
        	        	try {
							sf.rawData = Files.readAllBytes(Paths.get(pathToFile));
						} catch (IOException e) {
							e.printStackTrace();
						}
        	        	filesToZip.add(sf);
        	        }
        	}
        });

		btnSave.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent ae) {
				JFileChooser saveDialog = new JFileChooser();
			    FileNameExtensionFilter zipExtensionFilter =
			            new FileNameExtensionFilter("ZIP File(*.zip)", "zip");
			    saveDialog.addChoosableFileFilter(zipExtensionFilter);
			    int saveDialogReturn = saveDialog.showSaveDialog(frame);
				
			    if (saveDialogReturn == JFileChooser.APPROVE_OPTION) {
					createZipFile(saveDialog.getSelectedFile().getAbsolutePath());
				}
			}
		});

        frame.add(new JLabel("Bitte zu zippende Datei auswählen:"), BorderLayout.NORTH);
        frame.add(btnOpen, BorderLayout.CENTER);
        frame.add(btnSave, BorderLayout.SOUTH);
        frame.setTitle("ZIP Files");
        frame.pack();
        frame.setLocationRelativeTo(null); // Desktop mittig
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Java Webanwendungen mit Maven erstellen

Das Grundgerüst einer Java-Webanwendung lässt sich mit Maven schnell erstellen. Webanwendungen stellen das GUI (Graphical User Interface) des Programms in Form von Webseiten mit HTML, CSS und JavaScript dar. Um die Programmoberfläche zu erstellen stehen verschiedene Java Frameworks bereit, wovon einige am Ende des Artikels genannt werden. Das fertige Kompilat / Programm ist eine Datei mit der Dateiendung *.war (Web Archive), welche in einem Servlet Container wie Tomcat oder einem Anwendungsserver wie Wildfly deployed wird.

Falls Maven noch nicht installiert ist, wird hier erklärt wie die Installation unter Windows durchgeführt werden kann.
Als erstes erstellen Sie ein Verzeichnis in dem die Webanwendung erstellt werden soll und navigieren in der Windows Konsole (Windows-Taste + R -> cmd ) in dieses Verzeichnis. Die grundlegende Struktur der neuen Webanwendung kann durch einen einzigen Maven Befehl erzeugt werden.

mvn archetype:create -DgroupId=GROUPID -DartifactId=ARTIFACTID -DarchetypeArtifactId=maven-archetype-webapp

Hier wird Maven (mvn) mit dem Create-Befehl für das archetype Plugin aufgerufen. Parameter werden mit „-D“ eingeleitet. Bei dem Anlegen des Webprojektes muss über die Parameter eine GroupID und eine ArtifactID übergeben werden.

groupId – Der Paketname für das Projekt. Als GroupId wird meist der Domain Name verwendet, unter dem die Anwendung später erreichbar sein soll. Die einzelnen Bestandteile des Domainnamen werden dabei in umgekehrter Reihenfolge angegeben.
artifactId – Der Projektname. Die ArtifactId wird als Verzeichnisname für das Projekt genutzt und ist später in der URL der Webanwendung vorhanden. http://localhost:8080/artifactID
archetypeArtifactId – Der Archetype gibt das von dem Create-Befehl verwendete Template an. In unserem Fall ist dies das Template für eine Webanwendung. Würde der Befehl werggelassen erstellt Maven ein Standard Java-Projekt.

Beispiel:

mvn archetype:create -DgroupId=net.it_adviser.webapp -DartifactId=WebApp -DarchetypeArtifactId=maven-archetype-webapp

Das Programm kann mit dem Maven Befehl Package im Root Verzeichnis der Anwendung kompiliert werden und somit die zur Distribution fertige WAR-Datei erstellt werden. Das fertige Kompilat befindet sich im „target“ Verzeichnis:

mvn package

In Eclipse kann das Mavenprojekt einfach importiert werden. Dazu wird der das neue Verzeichnis mit der Webanwendung in das Workspace Verzeichnis kopiert und anschließend importiert. Dazu sollte in Eclipse nicht das Embedded Maven genutzt werden, sondern die externe Maven-Installation. Dies kann Preferences eingestellt werden. (Window -> Preferences -> Maven -> Installations). Das neue Projekt kann einfach über das Menü importiert werden: (File -> Import -> Maven -> Existing Maven Projekt). Dort wählen Sie das Root Verzeichnis des neuen Webprojektes und importieren die POM-Datei (Project Object Model). Siehe Bild:

Maven_Projekt_Importieren

Projektstruktur im Eclipse Projektexplorer:
Java_Webprojekt_ProjectExplorer

Für die Erstellung einer ansprechenden Weboberfläche stehen eine reihe von Frameworks bereit. u.a:
Die „Klassiker“
JSP – Java Server Pages
JSF – Java Server Faces

Moderner
Primefaces
Richfaces
GWT – Google Webtoolkit
Vaadin (GWT basiert)
Sencha GXT (GWT basiert)

Apache Maven installieren

maven-logoMaven ist ein auf Java basierendes Build-Management-Tool der Apache Software Foundation mit dem standardisierte Java Programme erstellt und verwaltet werden können. Maven verfolgt dabei das Prinzip des „Convention over Configuration“ wodurch viele Schritte (u.a. Projektaufbau, Kompilieren, Testen, Packen, Distribution) über den gesamten Zyklus der Softwareerstellung standardisiert sind und automatisiert werden.

Installation von Apache Maven unter Windows

1. Maven benötigt das Java Development Kit (JDK).
2. Wenn das JDK vorhanden ist kann Maven heruntergeladen werden und in ein beliebiges Verzeichnis entpackt werden. z.B. nach C:\Maven
3. Anschließend müssen einige Systemvariablen gesetzt werden, die im Dialog Systemvariablen (Windows Taste + Pause Taste -> Erweiterte Systemeinstellungen -> Reiter „Erweitert“ -> Umgebungsvariablen…) gepflegt werden. Dabei müssen die Pfade zum Java SDK und Maven entsprechend ihrer Lage auf der Festplatte angepasst werden.

Systemvariablen setzen:

JAVA_HOME C:\Program Files\Java\jdk1.7 
M2_HOME C:\Maven
MAVEN_OPTS -Xms256m -Xmx512m 
PATH %JAVA_HOME%\bin;%M2_HOME%\bin

Maven Ungebungsvariablen

4. Die Installation kann überprüft werden, indem in der Windows Console (Windows-Taste + R ->“cmd“) der Befehl „mvn -Version“ aufgerufen wird:

C:\>mvn -version
Apache Maven 3.0.5 (r01de14724cdef164cd33c7c8c2fe155faf9602da; 2013-02-19 14:51:
28+0100)
Maven home: D:\Maven\bin\..
Java version: 1.7.0_21, vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk1.7.0_21\jre
Default locale: de_DE, platform encoding: Cp1252
OS name: "windows 7", version: "6.1", arch: "amd64", family: "windows"

5. Maven legt auf der lokalen Festplatte ein lokales Repository an, welches standardmäßig im Benutzerverzeichnis liegt:

  • unter XP im Verzeichnis C:\Dokumente und Einstellungen\{Kürzel}\.m2
  • unter Windows 7 im Verzeichnis C:\Users\{Kürzel}\.m2

Das Repository kann verschoben werden, indem in der „settings.xml“ die im oben genannten Pfad liegt der folgende Eintrag angepasst und aus dem Kommentar genommen wird:

D:/repository

Hilfreiche Eclipse Tastaturkürzel

eclipse_logoDurch die Verwendung von Tastaturkürzeln kann die Arbeit mit der Java IDE Eclipse deutlich beschleunigt werden. Die Tabelle zeigt die von mir am häufigsten verwendeten Shortcuts:

Tastaturkürzel Funktion
STRG + SHIFT + L Liste aller Tastaturkürzel
STRG + ALT + O Importe organisieren
STRG + SHIFT + F Markierten Quelltextbereich oder gesamte Klasse formatieren
STRG + SHIFT + C markierten Quelltext auskommentieren
STRG + D Zeile oder markierten Quelltext löschen
STRG + Leertaste Code Assist
STRG + SHFT + T Kalsse öffnen
STRG + SHIFT + R Resource öffnen
STRG + SHIFT + G Suche nach Referenzen im Workspace
STRG + F lokale Textsuche und Suchen / Ersetzen
STRG + H globale Suche
STRG + T Klassenhierachie
STRG + ALT + H Call Hierachie
STRG + W aktuell geöfnete Klasse schließen
STRG + L zur x ten Zeile springen
STRG + Q zur letzten editierten Stelle springen
STRG + 1 Quickfix
STRG + SHFT + J Statement inspect – makierten Bereich bei Brakepoint auswerten
STRG + ALT + Pfeilhoch oder runter Zeile oder markierten Block duplizieren
ALT + Pfeilhoch oder runter Zeile oder markierten Block verschieben
ALT + SHIFT + R Refactoring -> variable umbenennen
ALT + SHIFT + S – R Getter & Setter generieren
ALT – SHIFT + S – O Constructor generieren
ALT + SHIFT + M markierten Codebereich als Methode extrahieren
ALT , P , N Clean Project