Creazione di un JAR eseguibile con dipendenze utilizzando Maven

Packaging di progetti Maven in un singolo JAR eseguibile

Quando si lavora con progetti Java, spesso è necessario comprimere l'applicazione in un unico file JAR eseguibile per una facile distribuzione. Maven, un potente strumento di automazione della compilazione, consente agli sviluppatori di includere tutte le dipendenze necessarie all'interno di questo singolo JAR di output.

Questo articolo ti guiderà attraverso i passaggi necessari per configurare il tuo progetto Maven per includere tutti i JAR delle dipendenze nel tuo JAR eseguibile finale. Seguendo queste istruzioni, semplificherai il processo di distribuzione e assicurerai che la tua applicazione funzioni senza problemi in ambienti diversi.

Creazione ed esecuzione di un JAR eseguibile con Maven

Gli script forniti sopra dimostrano come configurare un progetto Maven per racchiudere tutte le sue dipendenze in un unico file JAR eseguibile. Il primo script è un Maven pom.xml file, che contiene la configurazione del progetto. All'interno di questo file, il <plugin> Il tag viene utilizzato per definire il plug-in Assembly Maven. Questo plugin è fondamentale per creare un JAR eseguibile che includa tutte le dipendenze. IL <descriptorRefs> all'interno della configurazione del plugin specifica l'uso del file jar-with-dependencies descrittore, che garantisce che tutte le dipendenze del progetto siano inserite nel file JAR finale. IL <mainClass> tag all'interno del <manifest> è essenziale in quanto indica a Maven quale classe contiene il metodo principale da eseguire quando viene eseguito il JAR.

IL <execution> block all'interno della configurazione del plugin è dove avviene l'azione. Specifica che l'obiettivo del plugin single dovrebbe essere eseguito durante il package fase del ciclo di vita della build. Questo è ciò che attiva la creazione del file JAR con le dipendenze. Il secondo script è una semplice istruzione da riga di comando: mvn clean package. Questo comando pulisce il progetto (rimuovendo gli artefatti della build precedente), compila il codice sorgente, esegue i test e assembla il progetto in un file JAR. Il file JAR finale si troverà nel file target directory del progetto e denominata in base al file artifactId E version specificato nel 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

Tecniche avanzate di Maven per le dipendenze di packaging

Oltre alla configurazione di base per creare un JAR eseguibile con Maven, esistono tecniche aggiuntive che possono migliorare il processo di creazione. Una di queste tecniche prevede l'utilizzo di shade plugin invece del assembly collegare. Il plug-in Maven Shade offre funzionalità più avanzate per la creazione di uber-JAR (JAR con dipendenze incluse). Ti consente di rinominare i pacchetti per evitare conflitti di percorsi di classe e fornisce una migliore gestione per classi e risorse duplicate. Inoltre, offre un controllo dettagliato su quali dipendenze sono incluse nel JAR finale.

Un altro aspetto importante è la gestione delle dimensioni del file JAR. I file JAR di grandi dimensioni possono essere ingombranti e lenti da trasferire o caricare. IL maven-shade-plugin può aiutarti in questo permettendoti di escludere file e classi non necessari, riducendo così la dimensione del JAR finale. Puoi anche configurare il plugin per ridurre al minimo il JAR rimuovendo informazioni non essenziali come classi inutilizzate o risorse ridondanti. Queste configurazioni avanzate possono essere particolarmente utili quando si lavora su progetti di grandi dimensioni con numerose dipendenze.

Considerazioni conclusive sui JAR eseguibili Maven

La creazione di un JAR eseguibile con dipendenze utilizzando Maven semplifica il processo di distribuzione per le applicazioni Java. Configurando opportunamente il pom.xml file e utilizzando plugin come Maven Assembly Plugin o Maven Shade Plugin, gli sviluppatori possono racchiudere tutte le dipendenze necessarie in un singolo file JAR. Questo approccio garantisce che l'applicazione possa essere eseguita senza problemi in vari ambienti, semplificando la distribuzione e l'esecuzione. Seguire questi passaggi ti aiuterà a gestire le dipendenze del tuo progetto in modo efficace e a creare file JAR affidabili ed eseguibili.