Raspberry Pi – Bildschirmausgabe über SSH

Der Raspberry Pi wird häufig ohne einen angeschlossenen Monitor betrieben, da dieser für Serveraufgaben nicht nötig ist. Die Administration erfolgt dann über das SSH Protokoll mit einem SSH Client wie z.B. Putty für Windows wie es hier beschrieben ist.

Es gibt aber Situationen wo eine grafische Oberfläche in Form eines Desktops erforderlich ist. Linux verwendet für diese Grafikausgabe ein Netzwerkprotokoll und Softwaresammlung namens X11. Ein X-Server übernimmt dabei die Grafikausgabe und verarbeitet die Eingaben der Maus und Tastatur. So ein X-Server gibt es auch für Windows. Hier kann beispielsweise Xming verwendet werden. Die Software kann mit den Standardeinstellungen installiert werden. Nach dem Start von Xming zeigt ein Programmicon neben der Uhr das der X-Server gestartet ist.

Nach dem Start des X-Server muss noch der SSH Client so eingestellt werden, dass er den lokalen X-Server nutzt. Bei Putty sind diese Einstellungen unter Connection -> SSH -> X11 zu finden. Hier wird „Enable X11 forwarding“ aktiviert und als „X Display location“ localhost:0 eingegeben. Siehe Screenshot:
Putty x11 Einstellung

Damit ist die Konfiguration bereits abgeschlossen. Bei der Raspbian Linux Distribution ist keine weitere Konfiguration nötig. Werden Programme mit grafischer Programmoberfläche durch den User pi in der Shell gestartet erfolgt die Ausgabe automatisch in einem Windows Fenster. Testweise kann dazu der Browser Midori gestartet werden:

pi@raspberrypi ~ $ midori

Midori Browser unter Windows mit Putty und X11

Ebenso ist es möglich den integrierten LXDE Desktop zu starten. Allerdings werden hier beim Beenden ggf. nicht alle Resourcen wieder korrekt freigegeben. Eine komfortablere Möglichkeit den Desktop von Windows aus zu nutzen ist die Verwendung des RDP (Remote Desktop Protokolls) und der xrdp Software auf dem Raspberry Pi. Wie dies funktioniert wird hier beschrieben.

startlxde

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>

Raspberry Pi – Hausautomatisierung mit Domoticz und Home Easy

RaspberryPi_RFXCOMRFXCOMDer folgende Artikel stellt den Aufbau einer Hausautomatisierung mit dem Raspberry Pi vor. Das System nutzt die Open Source Software Domoticz, die über einen 433 Mhz Transceiver der Firma RfxCom unterschiedlichste Hausautomatisierungs-Komponenten aus der Serie Home Easy der Firma ELRO steuern kann. Dazu zählen insbesondere Funksteckdosen, Thermometer, Bewegungsmelder oder Helligkeitssensoren.

Domoticz-Installation

Home Easy Funksteckdose

Home Easy Funksteckdose

Domoticz gibt es für Windows und Linux. Für den Raspberry Pi existiert ein vorkonfiguriertes Linux Images das mit der Software Win32 Imager auf eine SD Karte geschrieben werden kann. Soll Domoticz auf einem bestehenden Debian / Raspbian Linux installiert werden folgen Sie am besten der Anleitung im Domoticz Wiki. Detaillierte Informationen bietet auch das Domoticz Handbuch

Domoticz-Konfiguration

Domoticz bringt eine moderne HTML 5 Web Oberfläche mit, die sich dynamisch an das jeweilige Gerät (Desktop, Tablet, Smartphone) anpasst. Dazu wird ein aktueller Browser benötigt. IE User benötigen die Version 10+. Die Domoticz Web GUI ist über Port 8080 des Raspberry Pi erreichbar:

http://IP_ADRESSE_RASPI:8080

Auf der Startseite können die wichtigsten Komponenten des Hausautomatisierungssystems in Form von Kacheln abgelegt werden:

Domoticz - Dashboard

Domoticz – Dashboard

Als erstes sollte nach der Installation von Domoticz in den Einstellungen der RfxCom Sender konfiguriert werden. Im Normalfall ist der 433 Mhz Sender an den USB Port „dev/ttyUSB0“ angeschlossen und ermöglicht dem System die Verbindung zu den Funksteckdosen und weiteren Hausautomatisierungs-Komponenten.

Domoticz - Hardware RfxCOM

Domoticz – Hardware RfxCOM

Anlernen der Funksteckdosen

1. Zunächst muss eine Home Easy Fernbedienung mit der Steckdose verbunden werden. Dazu drücken Sie die „LEARN“ Taste bei eingesteckter Dose für 3 Sekunden. Die Status LED der Funksteckdose blinkt danach und signalisiert damit die Empfangsbereitschaft für einen neuen Sendercode.
2. Anschließend wird auf der Funkverbindung die On und danach die Off Taste gedrückt die mit der Funksteckdose verbunden werden sollen.
3. Die Funksteckdose muss nun über die Fernbedienung schaltbar sein. Sollen alle angelernten Codes in der Funksteckdose gelöscht werden, so muss die „LEARN“-Taste für 6 Sekunden gedrückt werden.

Integration in Domoticz:

4. Um die Funksteckdose in Domoticz zu integrieren gibt es im Tab „Switches“ einen Button „Learn Light/Switch“. Dieser wird gedrückt und anschließend die Taste der Steckdose auf der Fernbedienung die in das System integriert werden soll.

Die Funksteckdosen können mit dem System auch zeitgesteuert geschaltet werden:

Domoticz - zeitgesteuert Schalten

Domoticz – zeitgesteuert Schalten

Temperaturwerte erfassen und visualisieren

In dem Temperatur-Tab der Software werden die Temperaturen mehrerer Funk Temperatursender in Form Diagrammen dargestellt. Die Temperaturen werden im Tages-, Monats- und Jahresverlauf dargestellt. Der Temperatursender TFA 30.3150 wird von Domoticz automatisch erkannt.

Domoticz - Temperaturdiagramme

Domoticz – Temperaturdiagramme

Fazit

Das System ist bei mir bereits mehrere Monate im Einsatz und funktioniert sehr gut. Durch die Kombination von dem fertigen RfxCom Transmittter / Receiver und der Open Source Software ist schnell eine lauffähige Hausautomatisierung aufgebaut. Domoticz bietet eine API mit einer Rest-Schnittstelle über die mit JSON-Formatierten-Befehlen der Status einzelner Komponenten abgefragt und geändert werden kann. Dadurch sind eigene Entwicklungen die an das System „andocken“ möglich.
Wer gerne etwas mehr bastelt und Zeit investieren möchte kann auch einen günstigen 433 Mhz Sender nehmen und diesen an die GPIO Pins des Raspberry Pi anschließen. Als Software bietet sich dafür die Open Source Software pilight an.

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);
    }
}

Raspberry Pi – GPIO Pins schalten

Das Raspberry Pi verfügt über 17 frei programmierbare GPIO Pins. Diese können als Eingabe- oder Ausgabeleitung verwendet werden. Wird die Leitung zur Ausgabe verwendet so liegt an ihrem GPIO Pin eine Spannung von 3,3V an (logisch 1). Wird die Leitung als Eingang verwendet kann logisch eine 1 gelesen werden wenn eine Spannung von 3,3 Volt anliegt. Hier finden Sie eine übersicht der GPIO Pins.

Um die GPIO Ausgabe zu testen empfiehlt sich die Visualisierung der Schaltzustände mit einer Leuchtdiode. Diese kann wie in folgender Grafik angeschlossen werden:

Anschluss einer LED an die Raspberry GPIO Pins

Anschluss einer LED an die Raspberry GPIO Pins

GPIO Ansteuerung per Shell

Die GPIO können über Dateien im Verzeichnis „/sys/class/gpio/“ angesteuert werden. Dies muss mit Root-Rechten geschehen. Entweder werden die Befehle direkt als root ausgeführt oder mit vorgestelltem sudo. Sind Sie als User „pi“ angemeldet kann mit su root zum Root User gewechselt werden.
Nach dem Systemstart sind die GPIO Pins zunächst als Eingang geschaltet und müssen mit „Export“ und Direction out als Ausgang definiert werden. Mit folgenden Befehlen kann der GPIO Pin 2 aus der oberen Schaltung geschaltet werden:

$ cd /sys/class/gpio
$ echo "2" > export
$ echo "out" > gpio2/direction

GPIO auf an (3,3V Spannung)
$ echo "1" > gpio2/value

GPIO auf aus(keine Spannung)
$ echo "0" > gpio2/value

GPIO Ansteuerung per WiringPi

Alternativ zur direkten Ansteuerung kann das Programm WiringPi installiert werden. Der Vorteil von WiringPi liegt darin das keine Rootrechte zum Schalten der GPIPO Pins benötigt werden. Eine Anleitung zum Installieren von WiringPi findet sich auf der Projektseite.

Eingang auslesen
gpio -g read 2

GPIO Pin als Ausgang definieren
gpio -g mode 2 out

Ausgang setzen
gpio -g write 2 1

GPIO Ansteuerung per PHP mit WiringPi

Mit WiringPi und dem PHP Befehl „shell_exec“ können die GPIO Pins auf einfache Weise über eine Webseite geschaltet werden.

$val = trim(@shell_exec("/usr/local/bin/gpio -g read 2"));
$val = trim(@shell_exec("/usr/local/bin/gpio -g write 2 1"));

GPIO Ansteuerung per Java und Pi4J

Unter Java können die GPIO Pins komfortable mit der Libraray Pi4J angesprochen werden. Das Programm jgRaspiGPIO nutzt die Library und ist mit Quelcode verfügbar.

Raspberry Pi – FM Sender

Im Rahmen eines #pihack-Wochenendes für das Schulprojekt „Code Club“ entstand an der Imperial College Robotik Society in London eine Software mit der der Raspberry Pi in einen UKW Sender verwandelt werden kann. Der Programm Code ist GPL lizensiert und kann hier heruntergeladen werden. Hardwareseitig sind keine Änderungen nötig. Lediglich eine kurze Antenne (20 cm Kabel) kann an GPIO 4 (Pin 7) angeschlossen werden. In Deutschland darf der Sender jedoch nicht betrieben werden, da seine Ausgangsleitung zu hoch ist und ein breiter Frequenzbereich gestört werden kann! Trotzdem zeigt das Projekt eindrucksvoll was mit dem Raspberry Pi möglich ist.

Das FM-Signal wird durch Modulation der GPIO-Clock generiert und kann Audiosignale im Bereich von 1 MHz bis 250 MHz übertragen.

Senden einer Wave Datei bei 100 Mhz:

sudo ./pifm sound.wav 100.0

Die Software erwartet ein Monoaudiosignal in Form einer Wave-Datei mit 16 Bit Auflösung und 22,05 kHz Abtastrate. Eine solche Wave Datei kann mit der Open Source Software „mPlayer“ erstellt werden:

mplayer -quiet -vo null -vc dummy -af resample=22050,channels=1 -ao pcm:waveheader:file=file_out_22kHz.wav file_in.wav

Raspberry Pi – Schaltungen zeichnen mit Fritzing

Mit der Open Source Softwarte Fritzing können Schaltungen für den Raspberry Pi auf einem virtuellen Breadboard(Steckplatine) entworfen werden. Die Software bietet drei Sichten auf die entworfene Schaltung. Dazu zählen eine visuelle Ansicht mit einem Breadboard, eine Schaltplan-Ansicht und eine Ansicht die das Platinenlayout darstellt. Eine Änderung in einer Ansicht führt dazu das die anderen Ansichten ebenfalls geändert werden.

Breatboardansicht einer Raspberry Pi Schaltung in der Software Fritzing

Breadboard-Ansicht einer Raspberry Pi Schaltung in der Software Fritzing

Die Software bringt bereits viele elektronische Bauteile mit, die über einen Bauteilbibliothek am rechten Rand ausgewählt werden können. Ãœber einen Button am rechts oben in der Bibliothek kann diese um weitere Bauteile erweitert werden. Ein Bauteileditor (Menü -> Bauteil -> Bearbeiten) erlaubt das verändern von Bauteilen und das erstellen neuer Bauteile. Das Erstellen neuer Bauteile wird gut in diesem Video erklärt.

Schaltplan-Ansicht einer Raspberry Pi Schaltung in der Software Fritzing

Schaltplan-Ansicht einer Raspberry Pi Schaltung in der Software Fritzing

Raspberry Pi – Temperaturmessung mit DS18B20 1-Wire Sensor

Raspberry Pi mit angeschlossenem 1-Wire DS18B20 Temperatursensor

Raspberry Pi mit angeschlossenem 1-Wire DS18B20 Temperatursensor

Mit dem 1-Wire Sensor DS18B20 können mit dem Raspberry Pi einfach Temperaturen messen. Dieser Sensor verwendet das 1-Wire Bussystem zur Ãœbertragung der Daten an den Raspberry Pi und kann an die GPIO Pins angeschlossen werden. Der Sensor benutzt dabei die drei Leitungen Masse, Spannungsversorgung und eine Signalleitung. Softwareseitig bringt die Raspbian Linux Distribution bereits die benötigten 1-Wire Kernel-Module mit um solche Sensoren auszulesen. Im nachfolgenden wird gezeigt wie der Sensor an den Raspberry Pi angeschlossen wird und die Temperaturwerte ausgelesen werden können.

Hardware-Installation des DS18B20

Der DS18B20 wird an die GPIO-Pins für 3,3V Spannung und Ground angeschlossen sowie an GPIO-Pin 4 für die Datenleitung. Zwischen die 5V Leitung und die Datenleitung wird 4k7 Ohm Wiederstand geschaltet. Das GPIO Pinlayout für den Raspberry Pi der Version 1 & 2 kann hier nachgeschlagen werden. Die untere Grafik zeigt den Aufbau der Schaltung:
Raspberry Pi DS1820 Steckplatine

Software-Installation des DS18B20

Die bereits angesprochenen 1-Wire Kernelmodule können mit folgendem Befehl geladen werden:

pi@raspberrypi ~ $ sudo modprobe wire
pi@raspberrypi ~ $ sudo modprobe w1_gpio
pi@raspberrypi ~ $ sudo modprobe w1_therm

Ob das Laden der Kenrel-Module erfolgreich war kann mit „lsmod“ überprüft werden:

pi@raspberrypi ~ $ sudo lsmod
Module                  Size  Used by
w1_therm                2705  0
w1_gpio                 1283  0
wire                   23530  2 w1_gpio,w1_therm
cn                      4649  1 wire
snd_bcm2835            12808  0

Damit die Kernel-Module nach einem Systemneustart automatisch geladen werden. Sollten sie in die Datei „/etc/modules“ eingetragen werden:

pi@raspberrypi ~ $ sudo nano /etc/modules

Module hinzufügen und speichern:
wire
w1-gpio
w1-therm

Ist die Hardware angeschlossen und die Kernel-Module geladen werden die Temperaturwerte laufend in eine Datei geschrieben. Es können mehrere Temperatursensoren angeschlossen werden, wobei jeder Sensor mit einem Verzeichnis unter „/sys/bus/w1/devices/“ auftaucht. Innerhalb des Verzeichnis eines Sensors kann die Temperatur aus der Datei „w1_slave“ ausgelesen werden. Mit dem „cat“ Befehl kann der Inhalt auf die Konsole ausgegeben werden.:

pi@raspberrypi ~ $ cat /sys/bus/w1/devices/28-00000436ccd1/w1_slave
41 01 4b 46 7f ff 0f 10 aa : crc=aa YES
41 01 4b 46 7f ff 0f 10 aa t=20062

t=20062 ist die aktuell gemessene Temperatur und entspricht 20,062 Grad.

Mögliche Verarbeitung der Temperaturdaten mit PHP, MySQL Datenbank und Webseitenanzeige

Raspi_DS18B20_TemperaturauswertungDie Temperaturwerte können auf verschiedenste Weise verarbeitet werden. z.B können sie in eine Datenbank geschrieben werden und auf einer Webseite veröffentlicht werden. Ich habe dazu ein Beispiel geschrieben, das die Temperatur im Tagesverlauf darstellt und noch einige Zusatzinformationen von Yahoo zieht. Das vorgehen wird hier nur grob beschrieben. Die benötigten Dateien sind am Ende des Artikels angefügt und können verändert werden.

1. Die Temperaturwerte werden in eine Tabelle einer MySQL Datenbank geschrieben. Wie eine MySQL DB auf dem Raspi installiert wird, ist hier beschrieben.:

use DB_NAME;
CREATE TABLE TB_Weather (
	timestamp BIGINT NOT NULL,
	temperature FLOAT,
	PRIMARY KEY (timestamp)
	)
	ENGINE=InnoDB;

2. Ein PHP Skript schreibt die Werte in die Tabelle. Falls der PHP Interpreter noch nicht installiert ist kann dies mit wie folgt erledigt werden. Damit kann das PHP-Skript auf der Console aufgerufen werden. „php -f temperatursensor.php“

sudo apt-get install php5
Module:
sudo apt-get install libapache2-mod-php5 libapache2-mod-perl2 php5 php5-cli php5-common php5-curl php5-dev php5-gd php5-imap php5-ldap php5-mhash php5-mysql php5-odbc

3. Mittels Cron können die Temperaturwerte zyklisch in die Datenbank geschrieben werden:

pi@raspberrypi ~ $ sudo crontab -e
In der Datei zyklisch das PHP Skript zum schreiben der Temperaturwerte aufrufrn:
*/5 * * * * php -f /home/pi/temperatursensor.php

4. Die Weboberfläche zur Auswertung der Temperaturdaten aus der DB muss auf einem Webserver wie Apache laufen und Zugriff auf die Datenbank haben.
Die Wetterinformationen werden mit dem Simple Weather Plugin von Yahoo ermittelt. Dazu muss in der index.php auf Clientseite die woeid (where on earth id) passend zu dem gewünschten Standort gesetzt werden. Die woeid kann mittels einer Suchmaschine ermittelt werden.

Download der Projektdateien zur Temperaturauswertung

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)