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.

Kommando	Beskrivning
<plugin>	Definierar ett Maven-plugin som ska användas under byggprocessen. Plugins kan utföra specifika uppgifter som att kompilera kod eller paketera projektet.
<groupId>	Anger gruppidentifieraren för Maven-projektet, vanligtvis ett omvänt domännamn.
<artifactId>	Definierar artefaktens identifierare, vilket är projektets namn.
<version>	Indikerar projektets aktuella version.
<build>	Innehåller byggkonfigurationen för projektet, inklusive plugins och resurser.
<descriptorRef>	Refererar till en fördefinierad deskriptor för Maven Assembly Plugin att använda, till exempel "jar-med-beroenden".
<mainClass>	Anger huvudklassen som ska köras när JAR-filen körs.
<execution>	Definierar ett exekveringsblock i en plugin, och specificerar uppgifter som ska utföras i olika byggfaser.
mvn clean package	Kommando för att rensa projektet och paketera det i en JAR-fil, inklusive alla beroenden.
java -jar target/...jar	Kommando för att köra den genererade JAR-filen och specificera sökvägen till JAR.

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 fil, som innehåller projektets konfiguration. I den här filen, 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 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 tagg inuti 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 block inuti plugin-konfigurationen är där åtgärden sker. Den anger att pluginens mål bör utföras under 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 katalogen för projektet och namngiven enligt och 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 plugin istället för 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 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.

1. Hur anger jag huvudklassen i min JAR?
2. Du kan ange huvudklassen med hjälp av taggen i avsnitt av Maven-plugin-konfigurationen.
3. Hur kan jag utesluta specifika beroenden från den slutliga JAR?
4. Använd taggen i plugin-konfigurationen för att ange beroenden som inte ska inkluderas i den slutliga JAR.
5. Vad är en uber-JAR?
6. En uber-JAR är en JAR-fil som inte bara innehåller din kompilerade kod utan också alla dess beroenden.
7. Hur kan jag undvika klassvägskonflikter i min JAR?
8. De låter dig byta namn på paket inom beroenden för att undvika konflikter.
9. Hur hanterar jag dubbletter av klasser i beroenden?
10. Konfigurera att hantera dubbletter av klasser och resurser genom att specificera hur dubbletter ska hanteras i den slutliga JAR.
11. Kan jag inkludera endast specifika filer från ett beroende?
12. Ja, du kan konfigurera eller att endast inkludera specifika filer från ett beroende.
13. Hur kör jag den paketerade JAR?
14. Använd kommandot följt av sökvägen till din JAR-fil.
15. Hur kan jag verifiera innehållet i min JAR-fil?
16. Du kan använda kommandot för att lista innehållet i JAR-filen.
17. Vad händer om min JAR-fil är för stor?
18. Använd för att utesluta onödiga filer och minimera JAR-storleken.

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 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.