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.

Comando	Descrizione
<plugin>	Definisce un plugin Maven da utilizzare durante il processo di compilazione. I plugin possono eseguire attività specifiche come la compilazione di codice o il confezionamento del progetto.
<groupId>	Specifica l'identificatore di gruppo per il progetto Maven, in genere un nome di dominio inverso.
<artifactId>	Definisce l'identificatore dell'artefatto, ovvero il nome del progetto.
<version>	Indica la versione corrente del progetto.
<build>	Contiene la configurazione di build per il progetto, inclusi plug-in e risorse.
<descriptorRef>	Fa riferimento a un descrittore predefinito da utilizzare per il plug-in Assembly Maven, ad esempio "jar-with-dependencies".
<mainClass>	Specifica la classe principale da eseguire quando viene eseguito il file JAR.
<execution>	Definisce un blocco di esecuzione all'interno di un plugin, specificando le attività da eseguire nelle diverse fasi di creazione.
mvn clean package	Comando per pulire il progetto e comprimerlo in un file JAR, incluse tutte le dipendenze.
java -jar target/...jar	Comando per eseguire il file JAR generato, specificando il percorso del JAR.

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 file, che contiene la configurazione del progetto. All'interno di questo file, il 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 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 tag all'interno del è essenziale in quanto indica a Maven quale classe contiene il metodo principale da eseguire quando viene eseguito il JAR.

IL block all'interno della configurazione del plugin è dove avviene l'azione. Specifica che l'obiettivo del plugin dovrebbe essere eseguito durante il 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 directory del progetto e denominata in base al file E 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 plugin invece del 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 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.

1. Come posso specificare la classe principale nel mio JAR?
2. È possibile specificare la classe principale utilizzando il file tag all'interno di sezione della configurazione del plugin Maven.
3. Come posso escludere dipendenze specifiche dal JAR finale?
4. Usa il tag all'interno della configurazione del plugin per specificare le dipendenze che non dovrebbero essere incluse nel JAR finale.
5. Cos'è un uber-JAR?
6. Un uber-JAR è un file JAR che contiene non solo il codice compilato ma anche tutte le sue dipendenze.
7. Come posso evitare conflitti di percorsi di classe nel mio JAR?
8. IL ti consente di rinominare il pacchetto con dipendenze per evitare conflitti.
9. Come gestisco le classi duplicate nelle dipendenze?
10. Configura il per gestire classi e risorse duplicate specificando come gestire i duplicati nel JAR finale.
11. Posso includere solo file specifici da una dipendenza?
12. Sì, puoi configurare il O per includere solo file specifici da una dipendenza.
13. Come si esegue il JAR confezionato?
14. Usa il comando seguito dal percorso del file JAR.
15. Come posso verificare il contenuto del mio file JAR?
16. Puoi usare il comando per elencare il contenuto del file JAR.
17. Cosa succede se il mio file JAR è troppo grande?
18. Usa il per escludere file non necessari e ridurre al minimo le dimensioni del JAR.

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