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.

Commando	Beschrijving
<plugin>	Definieert een Maven-plug-in die tijdens het bouwproces moet worden gebruikt. Plug-ins kunnen specifieke taken uitvoeren, zoals het compileren van code of het verpakken van het project.
<groupId>	Specificeert de groeps-ID voor het Maven-project, meestal een omgekeerde domeinnaam.
<artifactId>	Definieert de ID van het artefact, wat de naam van het project is.
<version>	Geeft de huidige versie van het project aan.
<build>	Bevat de buildconfiguratie voor het project, inclusief plug-ins en bronnen.
<descriptorRef>	Verwijst naar een vooraf gedefinieerde descriptor die de Maven Assembly Plugin moet gebruiken, zoals "jar-with-dependencies".
<mainClass>	Specificeert de hoofdklasse die moet worden uitgevoerd wanneer het JAR-bestand wordt uitgevoerd.
<execution>	Definieert een uitvoeringsblok binnen een plug-in, waarbij taken worden gespecificeerd die in verschillende bouwfasen moeten worden uitgevoerd.
mvn clean package	Commando om het project op te schonen en in een JAR-bestand te verpakken, inclusief alle afhankelijkheden.
java -jar target/...jar	Commando om het gegenereerde JAR-bestand uit te voeren, waarbij het pad naar de JAR wordt opgegeven.

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 bestand, dat de configuratie van het project bevat. Binnen dit bestand wordt de 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 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 label binnen de sectie is essentieel omdat het Maven vertelt welke klasse de hoofdmethode bevat die moet worden uitgevoerd wanneer de JAR wordt uitgevoerd.

De blok binnen de plug-inconfiguratie is waar de actie plaatsvindt. Het specificeert het doel van de plug-in moet worden uitgevoerd tijdens de 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 map van het project en genoemd volgens de En 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 plug-in in plaats van de 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 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.

1. Hoe specificeer ik de hoofdklasse in mijn JAR?
2. U kunt de hoofdklasse opgeven met behulp van de label binnen de sectie van de Maven-plug-inconfiguratie.
3. Hoe kan ik specifieke afhankelijkheden uitsluiten van de uiteindelijke JAR?
4. Gebruik de tag binnen de plug-inconfiguratie om afhankelijkheden op te geven die niet mogen worden opgenomen in de uiteindelijke JAR.
5. Wat is een uber-JAR?
6. Een uber-JAR is een JAR-bestand dat niet alleen uw gecompileerde code bevat, maar ook alle afhankelijkheden ervan.
7. Hoe kan ik klassenpadconflicten in mijn JAR vermijden?
8. De Hiermee kunt u pakketten binnen afhankelijkheden hernoemen om conflicten te voorkomen.
9. Hoe ga ik om met dubbele klassen in afhankelijkheden?
10. Configureer de om dubbele klassen en bronnen te beheren door te specificeren hoe duplicaten moeten worden afgehandeld in de uiteindelijke JAR.
11. Kan ik alleen specifieke bestanden van een afhankelijkheid opnemen?
12. Ja, u kunt de of om alleen specifieke bestanden van een afhankelijkheid op te nemen.
13. Hoe voer ik de verpakte JAR uit?
14. Gebruik de commando gevolgd door het pad naar uw JAR-bestand.
15. Hoe kan ik de inhoud van mijn JAR-bestand verifiëren?
16. U kunt gebruik maken van de opdracht om de inhoud van het JAR-bestand weer te geven.
17. Wat moet ik doen als mijn JAR-bestand te groot is?
18. Gebruik de om onnodige bestanden uit te sluiten en de JAR-grootte te minimaliseren.

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