Creació d'un JAR executable amb dependències mitjançant Maven

Empaquetar projectes Maven en un únic JAR executable

Quan es treballa amb projectes Java, sovint és necessari empaquetar l'aplicació en un únic fitxer JAR executable per facilitar la distribució. Maven, una potent eina d'automatització de compilació, permet als desenvolupadors incloure totes les dependències necessàries dins d'aquest JAR de sortida únic.

Aquest article us guiarà a través dels passos necessaris per configurar el vostre projecte Maven per incloure tots els JAR de dependència al vostre JAR executable final. Si seguiu aquestes instruccions, simplificareu el procés de desplegament i us garantireu que la vostra aplicació funcioni sense problemes en diferents entorns.

Comandament	Descripció
<plugin>	Defineix un connector Maven per utilitzar durant el procés de creació. Els connectors poden executar tasques específiques com ara compilar codi o empaquetar el projecte.
<groupId>	Especifica l'identificador de grup per al projecte Maven, normalment un nom de domini invers.
<artifactId>	Defineix l'identificador de l'artefacte, que és el nom del projecte.
<version>	Indica la versió actual del projecte.
<build>	Conté la configuració de compilació del projecte, inclosos els connectors i els recursos.
<descriptorRef>	Fa referència a un descriptor predefinit per utilitzar el connector d'assemblatge de Maven, com ara "jar-with-dependencies".
<mainClass>	Especifica la classe principal que s'ha d'executar quan s'executa el fitxer JAR.
<execution>	Defineix un bloc d'execució dins d'un connector, especificant les tasques que s'han de realitzar en diferents fases de construcció.
mvn clean package	Ordre per netejar el projecte i empaquetar-lo en un fitxer JAR, incloses totes les dependències.
java -jar target/...jar	Ordre per executar el fitxer JAR generat, especificant el camí al JAR.

Creació i execució d'un JAR executable amb Maven

Els scripts proporcionats anteriorment mostren com configurar un projecte Maven per empaquetar totes les seves dependències en un únic fitxer JAR executable. El primer guió és un Maven fitxer, que conté la configuració del projecte. Dins d'aquest fitxer, el L'etiqueta s'utilitza per definir el connector d'assemblatge de Maven. Aquest connector és crucial per crear un JAR executable que inclogui totes les dependències. El dins de la configuració del connector especifica l'ús de la jar-with-dependencies descriptor, que garanteix que totes les dependències del projecte estiguin empaquetades al fitxer JAR final. El etiqueta dins del La secció és essencial, ja que li indica a Maven quina classe conté el mètode principal per executar-se quan s'executa el JAR.

El bloc dins de la configuració del connector és on es produeix l'acció. Especifica que l'objectiu del connector s'ha d'executar durant el fase del cicle de vida de la construcció. Això és el que desencadena la creació del fitxer JAR amb dependències. El segon script és una instrucció de línia d'ordres senzilla: mvn clean package. Aquesta ordre neteja el projecte (elimina artefactes de construcció anteriors), compila el codi font, executa proves i empaqueta el projecte en un fitxer JAR. El fitxer JAR final es trobarà al fitxer directori del projecte i nomenat segons el i especificat en el 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

Tècniques avançades de Maven per a les dependències d'embalatge

Més enllà de la configuració bàsica per crear un JAR executable amb Maven, hi ha tècniques addicionals que poden millorar el vostre procés de creació. Una d'aquestes tècniques consisteix a utilitzar el connector en lloc del connectar. El connector Maven Shade ofereix funcions més avançades per crear uber-JAR (JAR amb dependències incloses). Us permet canviar el nom dels paquets per evitar conflictes en els camins de classe i proporciona un millor maneig de classes i recursos duplicats. A més, ofereix un control detallat sobre quines dependències s'inclouen al JAR final.

Un altre aspecte important és gestionar la mida del fitxer JAR. Els fitxers JAR grans poden ser complicats i lents per transferir-se o carregar. El pot ajudar amb això permetent-vos excloure fitxers i classes innecessaris, reduint així la mida del JAR final. També podeu configurar el connector per minimitzar el JAR eliminant informació no essencial, com ara classes no utilitzades o recursos redundants. Aquestes configuracions avançades poden ser especialment útils quan es treballa en projectes grans amb nombroses dependències.

1. Com puc especificar la classe principal al meu JAR?
2. Podeu especificar la classe principal utilitzant etiqueta dins del secció de la configuració del connector Maven.
3. Com puc excloure dependències específiques del JAR final?
4. Utilitzar el dins de la configuració del connector per especificar les dependències que no s'han d'incloure al JAR final.
5. Què és un uber-JAR?
6. Un uber-JAR és un fitxer JAR que conté no només el vostre codi compilat, sinó també totes les seves dependències.
7. Com puc evitar conflictes de classpath al meu JAR?
8. El us permet canviar el nom dels paquets dins de les dependències per evitar conflictes.
9. Com puc gestionar les classes duplicades a les dependències?
10. Configura el per gestionar les classes i recursos duplicats especificant com s'han de gestionar els duplicats al JAR final.
11. Puc incloure només fitxers específics d'una dependència?
12. Sí, podeu configurar el o per incloure només fitxers específics d'una dependència.
13. Com executo el JAR empaquetat?
14. Utilitzar el ordre seguida de la ruta del vostre fitxer JAR.
15. Com puc verificar el contingut del meu fitxer JAR?
16. Podeu utilitzar el comanda per llistar el contingut del fitxer JAR.
17. Què passa si el meu fitxer JAR és massa gran?
18. Utilitzar el per excloure fitxers innecessaris i minimitzar la mida del JAR.

Pensaments finals sobre els JAR executables de Maven

La creació d'un JAR executable amb dependències mitjançant Maven simplifica el procés de desplegament d'aplicacions Java. Configurant correctament el i utilitzant complements com el connector Maven Assembly o el connector Maven Shade, els desenvolupadors poden empaquetar totes les dependències necessàries en un únic fitxer JAR. Aquest enfocament garanteix que l'aplicació es pugui executar sense problemes en diversos entorns, fent que la distribució i l'execució siguin senzilles. Seguir aquests passos us ajudarà a gestionar les dependències del vostre projecte de manera eficaç i a crear fitxers JAR fiables i executables.