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.

Kommando	Beskrivelse
<plugin>	Definerer en Maven-plugin som skal brukes under byggeprosessen. Plugins kan utføre spesifikke oppgaver som å kompilere kode eller pakke prosjektet.
<groupId>	Spesifiserer gruppeidentifikatoren for Maven-prosjektet, vanligvis et omvendt domenenavn.
<artifactId>	Definerer artefaktens identifikator, som er prosjektets navn.
<version>	Indikerer prosjektets gjeldende versjon.
<build>	Inneholder byggekonfigurasjonen for prosjektet, inkludert plugins og ressurser.
<descriptorRef>	Refererer til en forhåndsdefinert beskrivelse som Maven Assembly Plugin skal bruke, for eksempel "jar-with-dependencies".
<mainClass>	Spesifiserer hovedklassen som skal kjøres når JAR-filen kjøres.
<execution>	Definerer en utførelsesblokk i en plugin, og spesifiserer oppgaver som skal utføres i forskjellige byggefaser.
mvn clean package	Kommando for å rense prosjektet og pakke det inn i en JAR-fil, inkludert alle avhengigheter.
java -jar target/...jar	Kommando for å kjøre den genererte JAR-filen, som spesifiserer banen til JAR.

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 fil, som inneholder prosjektets konfigurasjon. I denne filen er taggen brukes til å definere Maven Assembly Plugin. Denne plugin er avgjørende for å lage en kjørbar JAR som inkluderer alle avhengigheter. De 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 tag inne i delen er viktig da den forteller Maven hvilken klasse som inneholder hovedmetoden som skal kjøres når JAR kjøres.

De blokk inne i plugin-konfigurasjonen er der handlingen skjer. Den spesifiserer at pluginens mål bør utføres i løpet av 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 katalogen til prosjektet og navngitt i henhold til og 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 plugin i stedet for 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 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.

1. Hvordan spesifiserer jeg hovedklassen i JAR-en min?
2. Du kan spesifisere hovedklassen ved å bruke tag i delen av Maven-plugin-konfigurasjonen.
3. Hvordan kan jeg ekskludere spesifikke avhengigheter fra den endelige JAR?
4. Bruke tag i plugin-konfigurasjonen for å spesifisere avhengigheter som ikke skal inkluderes i den endelige JAR.
5. Hva er en uber-JAR?
6. En uber-JAR er en JAR-fil som inneholder ikke bare den kompilerte koden din, men også alle dens avhengigheter.
7. Hvordan kan jeg unngå klassebanekonflikter i JAR-en min?
8. De lar deg gi nytt navn til pakker innenfor avhengigheter for å unngå konflikter.
9. Hvordan håndterer jeg dupliserte klasser i avhengigheter?
10. Konfigurer å administrere dupliserte klasser og ressurser ved å spesifisere hvordan duplikater skal håndteres i den endelige JAR.
11. Kan jeg inkludere bare spesifikke filer fra en avhengighet?
12. Ja, du kan konfigurere eller å inkludere bare spesifikke filer fra en avhengighet.
13. Hvordan kjører jeg den pakkede JAR?
14. Bruke kommando etterfulgt av banen til JAR-filen.
15. Hvordan kan jeg verifisere innholdet i JAR-filen min?
16. Du kan bruke kommandoen for å vise innholdet i JAR-filen.
17. Hva om JAR-filen min er for stor?
18. Bruke for å ekskludere unødvendige filer og minimere JAR-størrelsen.

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