Opprette en kjørbar JAR med avhengigheter ved å bruke Maven

Pakke Maven-prosjekter til en enkelt kjørbar JAR

Når du arbeider med Java-prosjekter, er det ofte nødvendig å pakke programmet inn i en enkelt kjørbar JAR-fil for enkel distribusjon. Maven, et kraftig byggeautomatiseringsverktøy, lar utviklere inkludere alle nødvendige avhengigheter i denne enkeltutdata-JARen.

Denne artikkelen vil veilede deg gjennom trinnene som trengs for å konfigurere Maven-prosjektet ditt til å inkludere alle avhengighets-JAR-er i din endelige kjørbare JAR. Ved å følge disse instruksjonene vil du forenkle distribusjonsprosessen og sikre at applikasjonen din kjører jevnt på tvers av forskjellige miljøer.

Opprette og kjøre en kjørbar JAR med Maven

Skriptene ovenfor viser hvordan du konfigurerer et Maven-prosjekt til å pakke alle dets avhengigheter i en enkelt kjørbar JAR-fil. Det første manuset er en Maven pom.xml fil, som inneholder prosjektets konfigurasjon. I denne filen er <plugin> taggen brukes til å definere Maven Assembly Plugin. Denne plugin er avgjørende for å lage en kjørbar JAR som inkluderer alle avhengigheter. De <descriptorRefs> taggen i plugin-konfigurasjonen spesifiserer bruken av jar-with-dependencies descriptor, som sikrer at alle prosjektets avhengigheter er pakket inn i den endelige JAR-filen. De <mainClass> tag inne i <manifest> delen er viktig da den forteller Maven hvilken klasse som inneholder hovedmetoden som skal kjøres når JAR kjøres.

De <execution> blokk inne i plugin-konfigurasjonen er der handlingen skjer. Den spesifiserer at pluginens mål single bør utføres i løpet av package fase av byggelivssyklusen. Det er dette som utløser opprettelsen av JAR-filen med avhengigheter. Det andre skriptet er en enkel kommandolinjeinstruksjon: mvn clean package. Denne kommandoen renser prosjektet (fjerner tidligere byggeartefakter), kompilerer kildekoden, kjører tester og pakker prosjektet inn i en JAR-fil. Den endelige JAR-filen vil bli plassert i target katalogen til prosjektet og navngitt i henhold til artifactId og version spesifisert 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

Avanserte Maven-teknikker for emballasjeavhengigheter

Utover den grunnleggende konfigurasjonen for å lage en kjørbar JAR med Maven, er det flere teknikker som kan forbedre byggeprosessen din. En slik teknikk innebærer å bruke shade plugin i stedet for assembly plugg inn. Maven Shade Plugin tilbyr mer avanserte funksjoner for å lage uber-JARs (JARs med avhengigheter inkludert). Den lar deg gi nytt navn til pakker for å unngå klassebanekonflikter og gir bedre håndtering av dupliserte klasser og ressurser. I tillegg tilbyr den finmasket kontroll over hvilke avhengigheter som er inkludert i den endelige JAR.

Et annet viktig aspekt er å administrere størrelsen på JAR-filen. Store JAR-filer kan være tungvinte og trege å overføre eller laste. De maven-shade-plugin kan hjelpe med dette ved å la deg ekskludere unødvendige filer og klasser, og dermed redusere størrelsen på den endelige JAR. Du kan også konfigurere plugin-en til å minimere JAR ved å fjerne ikke-essensiell informasjon som ubrukte klasser eller overflødige ressurser. Disse avanserte konfigurasjonene kan være spesielt nyttige når du arbeider med store prosjekter med mange avhengigheter.

Avsluttende tanker om Maven kjørbare JAR-er

Å lage en kjørbar JAR med avhengigheter ved hjelp av Maven forenkler distribusjonsprosessen for Java-applikasjoner. Ved å konfigurere riktig pom.xml fil og ved å bruke plugins som Maven Assembly Plugin eller Maven Shade Plugin, kan utviklere pakke alle nødvendige avhengigheter inn i en enkelt JAR-fil. Denne tilnærmingen sikrer at applikasjonen kan kjøre sømløst i ulike miljøer, noe som gjør distribusjon og utførelse enkel. Å følge disse trinnene vil hjelpe deg med å administrere prosjektets avhengigheter effektivt og lage pålitelige, kjørbare JAR-filer.