Een uitvoerbare JAR maken met afhankelijkheden met behulp van Maven

Maven-projecten verpakken in één uitvoerbare JAR

Wanneer u met Java-projecten werkt, is het vaak nodig om uw toepassing in één uitvoerbaar JAR-bestand te verpakken, zodat deze gemakkelijk kan worden verspreid. Maven, een krachtige tool voor bouwautomatisering, stelt ontwikkelaars in staat alle noodzakelijke afhankelijkheden op te nemen in deze JAR met enkele uitvoer.

In dit artikel wordt u door de stappen geleid die nodig zijn om uw Maven-project zo te configureren dat alle afhankelijkheids-JAR's in uw uiteindelijke uitvoerbare JAR worden opgenomen. Door deze instructies te volgen, vereenvoudigt u het implementatieproces en zorgt u ervoor dat uw applicatie soepel draait in verschillende omgevingen.

Een uitvoerbare JAR maken en uitvoeren met Maven

De hierboven gegeven scripts demonstreren hoe u een Maven-project configureert om al zijn afhankelijkheden in één uitvoerbaar JAR-bestand te verpakken. Het eerste script is een Maven pom.xml bestand, dat de configuratie van het project bevat. Binnen dit bestand wordt de <plugin> tag wordt gebruikt om de Maven Assembly Plugin te definiëren. Deze plug-in is cruciaal voor het maken van een uitvoerbare JAR die alle afhankelijkheden bevat. De <descriptorRefs> tag binnen de plug-inconfiguratie specificeert het gebruik van de jar-with-dependencies descriptor, die ervoor zorgt dat alle afhankelijkheden van het project in het uiteindelijke JAR-bestand worden verpakt. De <mainClass> label binnen de <manifest> sectie is essentieel omdat het Maven vertelt welke klasse de hoofdmethode bevat die moet worden uitgevoerd wanneer de JAR wordt uitgevoerd.

De <execution> blok binnen de plug-inconfiguratie is waar de actie plaatsvindt. Het specificeert het doel van de plug-in single moet worden uitgevoerd tijdens de package fase van de bouwlevenscyclus. Dit is wat de aanmaak van het JAR-bestand met afhankelijkheden activeert. Het tweede script is een eenvoudige opdrachtregelinstructie: mvn clean package. Met deze opdracht wordt het project opgeschoond (waarbij eerdere build-artefacten worden verwijderd), wordt de broncode gecompileerd, worden tests uitgevoerd en wordt het project in een JAR-bestand verpakt. Het uiteindelijke JAR-bestand bevindt zich in de target map van het project en genoemd volgens de artifactId En version gespecificeerd in de 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

Geavanceerde Maven-technieken voor verpakkingsafhankelijkheden

Naast de basisconfiguratie voor het maken van een uitvoerbare JAR met Maven, zijn er aanvullende technieken die uw bouwproces kunnen verbeteren. Eén van die technieken is het gebruik van de shade plug-in in plaats van de assembly inpluggen. De Maven Shade Plugin biedt meer geavanceerde functies voor het maken van uber-JAR's (JAR's inclusief afhankelijkheden). Hiermee kunt u de naam van pakketten wijzigen om klassenpadconflicten te voorkomen en wordt een betere afhandeling van dubbele klassen en bronnen geboden. Bovendien biedt het een nauwkeurige controle over welke afhankelijkheden in de uiteindelijke JAR worden opgenomen.

Een ander belangrijk aspect is het beheren van de grootte van uw JAR-bestand. Grote JAR-bestanden kunnen lastig zijn en langzaam worden overgedragen of geladen. De maven-shade-plugin kan hierbij helpen doordat u onnodige bestanden en klassen kunt uitsluiten, waardoor de grootte van de uiteindelijke JAR wordt verkleind. U kunt de plug-in ook configureren om de JAR te minimaliseren door niet-essentiële informatie te verwijderen, zoals ongebruikte klassen of overtollige bronnen. Deze geavanceerde configuraties kunnen met name handig zijn bij het werken aan grote projecten met talrijke afhankelijkheden.

Afsluitende gedachten over uitvoerbare JAR's van Maven

Het maken van een uitvoerbare JAR met afhankelijkheden met behulp van Maven vereenvoudigt het implementatieproces voor Java-applicaties. Door het correct configureren van de pom.xml -bestand en met behulp van plug-ins zoals de Maven Assembly Plugin of Maven Shade Plugin kunnen ontwikkelaars alle noodzakelijke afhankelijkheden in één JAR-bestand verpakken. Deze aanpak zorgt ervoor dat de applicatie naadloos in verschillende omgevingen kan draaien, waardoor distributie en uitvoering eenvoudig worden. Door deze stappen te volgen, kunt u de afhankelijkheden van uw project effectief beheren en betrouwbare, uitvoerbare JAR-bestanden maken.