Skapa en körbar JAR med beroenden med Maven

Packa Maven-projekt till en enda körbar JAR

När du arbetar med Java-projekt är det ofta nödvändigt att paketera din applikation till en enda körbar JAR-fil för enkel distribution. Maven, ett kraftfullt byggautomatiseringsverktyg, låter utvecklare inkludera alla nödvändiga beroenden i denna enda utdata-JAR.

Den här artikeln guidar dig genom stegen som behövs för att konfigurera ditt Maven-projekt för att inkludera alla beroende JAR:er i din slutliga körbara JAR. Genom att följa dessa instruktioner förenklar du distributionsprocessen och säkerställer att din applikation fungerar smidigt i olika miljöer.

Skapa och köra en körbar JAR med Maven

Skripten som tillhandahålls ovan visar hur man konfigurerar ett Maven-projekt för att paketera alla dess beroenden i en enda körbar JAR-fil. Det första manuset är en Maven pom.xml fil, som innehåller projektets konfiguration. I den här filen, <plugin> taggen används för att definiera Maven Assembly Plugin. Denna plugin är avgörande för att skapa en körbar JAR som inkluderar alla beroenden. De <descriptorRefs> taggen i plugin-konfigurationen anger användningen av jar-with-dependencies descriptor, som säkerställer att alla projektets beroenden paketeras i den slutliga JAR-filen. De <mainClass> tagg inuti <manifest> avsnittet är viktigt eftersom det talar om för Maven vilken klass som innehåller huvudmetoden som ska köras när JAR körs.

De <execution> block inuti plugin-konfigurationen är där åtgärden sker. Den anger att pluginens mål single bör utföras under package fas av bygglivscykeln. Det är detta som utlöser skapandet av JAR-filen med beroenden. Det andra skriptet är en enkel kommandoradsinstruktion: mvn clean package. Det här kommandot rensar projektet (tar bort tidigare byggartefakter), kompilerar källkoden, kör tester och paketerar projektet till en JAR-fil. Den slutliga JAR-filen kommer att finnas i target katalogen för projektet och namngiven enligt artifactId och version specificeras i pom.xml.

<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</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.example.MainClass</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

mvn clean package
# This command will compile the code, run the tests, and create the JAR file
# The JAR file will include all dependencies specified in the pom.xml
# It will be located in the target directory of the project
# The final JAR file will be named my-app-1.0-SNAPSHOT-jar-with-dependencies.jar

# To run the JAR file, use the following command:
java -jar target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar
# Ensure that the mainClass specified in the pom.xml is correct
# This will start your application with all dependencies included

Avancerade Maven-tekniker för förpackningsberoende

Utöver den grundläggande konfigurationen för att skapa en körbar JAR med Maven, finns det ytterligare tekniker som kan förbättra din byggprocess. En sådan teknik involverar att använda shade plugin istället för assembly plugin. Maven Shade Plugin erbjuder mer avancerade funktioner för att skapa uber-JARs (JARs med beroenden inkluderade). Det låter dig byta namn på paket för att undvika klassvägskonflikter och ger bättre hantering av dubbletter av klasser och resurser. Dessutom erbjuder den finkornig kontroll över vilka beroenden som ingår i den slutliga JAR.

En annan viktig aspekt är att hantera storleken på din JAR-fil. Stora JAR-filer kan vara besvärliga och långsamma att överföra eller ladda. De maven-shade-plugin kan hjälpa till med detta genom att tillåta dig att utesluta onödiga filer och klasser, vilket minskar storleken på den slutliga JAR. Du kan också konfigurera plugin-programmet för att minimera JAR genom att ta bort icke-essentiell information som oanvända klasser eller redundanta resurser. Dessa avancerade konfigurationer kan vara särskilt användbara när du arbetar med stora projekt med många beroenden.

Avslutande tankar om Maven Executable JARs

Att skapa en körbar JAR med beroenden med Maven förenklar distributionsprocessen för Java-applikationer. Genom att korrekt konfigurera pom.xml fil och med hjälp av plugins som Maven Assembly Plugin eller Maven Shade Plugin, kan utvecklare paketera alla nödvändiga beroenden i en enda JAR-fil. Detta tillvägagångssätt säkerställer att applikationen kan köras sömlöst i olika miljöer, vilket gör distribution och exekvering enkel. Att följa dessa steg hjälper dig att hantera ditt projekts beroenden effektivt och skapa pålitliga, körbara JAR-filer.