Verwenden von Maven für die Projektverwaltung
In diesem Schritt lernen Sie, wie Sie Apache Maven verwenden, um Ihr Java-Projekt zu verwalten. Maven ist ein leistungsstarkes Tool zur Build-Automatisierung und Abhängigkeitsverwaltung, das die Projektaufsetzung und -wartung vereinfacht.
Grundlegendes zu Maven
Maven bietet:
- Standardisierte Projektstruktur
- Abhängigkeitsverwaltung
- Build-Automatisierung
- Projektinformationsverwaltung
- Einheitlichen Build-Prozess über Projekte hinweg
Einrichten eines Maven-Projekts
Erstellen wir ein neues Projekt mit Maven:
- Prüfen Sie zunächst, ob Maven installiert ist:
mvn --version
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
Apache Maven 3.6.3
Maven home: /usr/share/maven
Java version: 11.0.18, vendor: Ubuntu, runtime: /usr/lib/jvm/java-11-openjdk-amd64
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "5.15.0-1036-azure", arch: "amd64", family: "unix"
- Navigieren Sie in Ihr Projektverzeichnis:
cd /home/labex/project
- Erstellen Sie ein neues Maven-Projekt mithilfe eines Archetyps (eines Projektvorlagens):
mvn archetype:generate \
-DgroupId=com.example.calculator \
-DartifactId=simple-calculator \
-DarchetypeArtifactId=maven-archetype-quickstart \
-DarchetypeVersion=1.4 \
-DinteractiveMode=false
Dieser Befehl erstellt ein neues Projekt mit einer standardisierten Verzeichnisstruktur.
- Untersuchen Sie die Projektstruktur:
cd simple-calculator
ls -la
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
total 24
drwxr-xr-x 4 labex labex 4096 ... .
drwxr-xr-x 6 labex labex 4096 ... ..
-rw-r--r-- 1 labex labex 174 ... .gitignore
-rw-r--r-- 1 labex labex 720 ... pom.xml
drwxr-xr-x 4 labex labex 4096 ... src
Die wichtigste Datei hier ist pom.xml
(Project Object Model), die die Projektkonfiguration definiert.
- Untersuchen Sie das Maven-Standardverzeichnislayout:
find src -type d
Sie sollten Folgendes sehen:
src
src/main
src/main/java
src/main/java/com
src/main/java/com/example
src/main/java/com/example/calculator
src/test
src/test/java
src/test/java/com
src/test/java/com/example
src/test/java/com/example/calculator
Dies ist das Maven-Standardverzeichnislayout:
src/main/java
: Quellcode
src/main/resources
: Ressourcendateien
src/test/java
: Testcode
src/test/resources
: Testressourcen
- Schauen wir uns die generierte
App.java
-Datei an:
cat src/main/java/com/example/calculator/App.java
Sie sollten eine einfache "Hello World"-Klasse sehen:
package com.example.calculator;
/**
* Hello world!
*
*/
public class App
{
public static void main( String[] args )
{
System.out.println( "Hello World!" );
}
}
Verbessern des Maven-Projekts
Verbessern wir unser Taschenrechnerprojekt, indem wir weitere Klassen hinzufügen:
- Erstellen Sie eine neue Datei namens
Calculator.java
in src/main/java/com/example/calculator/
:
package com.example.calculator;
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public int subtract(int a, int b) {
return a - b;
}
public int multiply(int a, int b) {
return a * b;
}
public double divide(int a, int b) {
if (b == 0) {
throw new ArithmeticException("Cannot divide by zero");
}
return (double) a / b;
}
}
- Modifizieren Sie nun die vorhandene
App.java
-Datei, um unsere Calculator-Klasse zu verwenden:
package com.example.calculator;
/**
* Simple Calculator Application
*/
public class App
{
public static void main( String[] args )
{
Calculator calculator = new Calculator();
// Perform some calculations
System.out.println("Addition: 5 + 3 = " + calculator.add(5, 3));
System.out.println("Subtraction: 10 - 4 = " + calculator.subtract(10, 4));
System.out.println("Multiplication: 6 * 7 = " + calculator.multiply(6, 7));
System.out.println("Division: 20 / 4 = " + calculator.divide(20, 4));
System.out.println("Calculator application completed successfully!");
}
}
- Bauen Sie das Projekt mit Maven:
mvn compile
Sie sollten eine Ausgabe sehen, die mit folgendem endet:
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
- Packen Sie die Anwendung in eine JAR-Datei:
mvn package
Dieser Befehl kompiliert Ihren Code, führt Tests aus und packt die Anwendung.
- Führen Sie die gepackte Anwendung aus:
java -cp target/simple-calculator-1.0-SNAPSHOT.jar com.example.calculator.App
Sie sollten die folgende Ausgabe sehen:
Addition: 5 + 3 = 8
Subtraction: 10 - 4 = 6
Multiplication: 6 * 7 = 42
Division: 20 / 4 = 5.0
Calculator application completed successfully!
Grundlegendes zur Maven-POM-Datei
Die Project Object Model (POM)-Datei enthält die Projektkonfiguration. Öffnen Sie die pom.xml
-Datei im Editor und untersuchen Sie ihre Struktur:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example.calculator</groupId>
<artifactId>simple-calculator</artifactId>
<version>1.0-SNAPSHOT</version>
<name>simple-calculator</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
<!-- Build configuration... -->
</project>
Wichtige Elemente in der POM-Datei:
groupId
: Organisations- oder Projektkennung
artifactId
: Projektname
version
: Projektversion
dependencies
: Externe Bibliotheken, die vom Projekt verwendet werden
build
: Konfiguration für das Bauen des Projekts
Wichtige Maven-Befehle
Hier sind einige essentielle Maven-Befehle:
mvn compile
: Kompiliert Quellcode
mvn test
: Führt Tests aus
mvn package
: Erstellt verteilbare Pakete (JAR, WAR)
mvn install
: Installiert das Paket im lokalen Repository
mvn clean
: Entfernt Build-Artefakte (Verzeichnis target
)
mvn clean install
: Kombination aus clean
und install
Maven hat die Java-Projektverwaltung erheblich vereinfacht, indem es Konventionen, Abhängigkeitsverwaltung und Build-Automatisierung bietet. Dieser standardisierte Ansatz hilft Entwicklern, sich auf das Schreiben von Code statt auf die Verwaltung der Projektstruktur zu konzentrieren.