Futtatható JAR létrehozása függőségekkel a Maven segítségével

A Maven projektek csomagolása egyetlen végrehajtható JAR-ba

Java-projektekkel végzett munka során gyakran szükséges egyetlen végrehajtható JAR-fájlba csomagolni az alkalmazást az egyszerű terjesztés érdekében. A Maven, egy hatékony építési automatizálási eszköz, lehetővé teszi a fejlesztők számára, hogy minden szükséges függőséget belefoglaljanak ebbe az egyetlen kimeneti JAR-ba.

Ez a cikk végigvezeti Önt a Maven-projekt konfigurálásához szükséges lépéseken, hogy az összes függőségi JAR-t belefoglalja a végső végrehajtható JAR-ba. Ha követi ezeket az utasításokat, leegyszerűsíti a telepítési folyamatot, és biztosítja, hogy alkalmazása zökkenőmentesen futjon a különböző környezetekben.

Parancs	Leírás
<plugin>	Meghatároz egy Maven beépülő modult, amelyet az építési folyamat során kell használni. A beépülő modulok speciális feladatokat hajthatnak végre, például kódfordítást vagy a projekt csomagolását.
<groupId>	Megadja a Maven projekt csoportazonosítóját, általában fordított tartománynevet.
<artifactId>	Meghatározza a műtermék azonosítóját, amely a projekt neve.
<version>	A projekt aktuális verzióját jelzi.
<build>	Tartalmazza a projekt összeállítási konfigurációját, beleértve a beépülő modulokat és az erőforrásokat.
<descriptorRef>	A Maven Assembly Plugin előre meghatározott leírójára hivatkozik, például "jar-with-dependencies".
<mainClass>	Megadja a JAR fájl futtatásakor végrehajtandó fő osztályt.
<execution>	Meghatároz egy végrehajtási blokkot a beépülő modulon belül, meghatározva a különböző összeállítási fázisokban végrehajtandó feladatokat.
mvn clean package	Parancs a projekt tisztítására és JAR-fájlba való csomagolására, beleértve az összes függőséget.
java -jar target/...jar	Parancs a generált JAR fájl futtatásához, megadva a JAR elérési útját.

Futtatható JAR létrehozása és futtatása a Maven segítségével

A fent megadott szkriptek bemutatják, hogyan lehet egy Maven-projektet úgy beállítani, hogy az összes függőségét egyetlen végrehajtható JAR-fájlba csomagolja. Az első forgatókönyv egy Maven fájl, amely a projekt konfigurációját tartalmazza. Ezen a fájlon belül a címke a Maven Assembly Plugin meghatározására szolgál. Ez a beépülő modul kulcsfontosságú az összes függőséget tartalmazó végrehajtható JAR létrehozásához. A címke a beépülő modul konfigurációjában határozza meg a jar-with-dependencies leíró, amely biztosítja, hogy a projekt összes függősége a végső JAR-fájlba kerüljön. A címke belsejében szakasz elengedhetetlen, mivel megmondja a Mavennek, hogy melyik osztály tartalmazza a JAR végrehajtásakor futtatandó fő metódust.

A blokk a bővítmény konfigurációjában, ahol a művelet történik. Meghatározza, hogy a bővítmény célja alatt kell végrehajtani az építési életciklus fázisa. Ez váltja ki a függőségekkel rendelkező JAR-fájl létrehozását. A második szkript egy egyszerű parancssori utasítás: mvn clean package. Ez a parancs megtisztítja a projektet (eltávolítja a korábbi összeállítási melléktermékeket), lefordítja a forráskódot, teszteket futtat, és a projektet JAR-fájlba csomagolja. A végső JAR-fájl a következő helyen található: a projekt címtárát, és a szerint nevezik el és pontjában meghatározott 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

Speciális Maven-technikák a csomagolásfüggőségekhez

A végrehajtható JAR Maven segítségével történő létrehozásának alapvető konfigurációján túl további technikák is javíthatják az összeállítási folyamatot. Az egyik ilyen technika magában foglalja a plugin helyett a csatlakoztat. A Maven Shade beépülő modul fejlettebb funkciókat kínál az uber-JAR-ok (függőségekkel rendelkező JAR-ok) létrehozásához. Lehetővé teszi a csomagok átnevezését az osztályútvonal-ütközések elkerülése érdekében, és jobb kezelést biztosít az ismétlődő osztályok és erőforrások számára. Ezenkívül finoman szabályozható, hogy mely függőségek szerepeljenek a végső JAR-ban.

Egy másik fontos szempont a JAR-fájl méretének kezelése. A nagy JAR-fájlok átvitele vagy betöltése nehézkes és lassú lehet. A segíthet ebben azáltal, hogy lehetővé teszi a szükségtelen fájlok és osztályok kizárását, így csökkentve a végső JAR méretét. A beépülő modult úgy is beállíthatja, hogy minimalizálja a JAR-t a nem alapvető információk, például a nem használt osztályok vagy a redundáns erőforrások eltávolításával. Ezek a speciális konfigurációk különösen hasznosak lehetnek, ha nagy, számos függőséggel rendelkező projekteken dolgozik.

1. Hogyan adhatom meg a fő osztályt a JAR-ban?
2. A fő osztályt a segítségével adhatja meg címke a részben a Maven beépülő modul konfigurációjában.
3. Hogyan zárhatok ki bizonyos függőségeket a végső JAR-ból?
4. Használja a címkét a beépülő modul konfigurációjában, hogy megadja azokat a függőségeket, amelyek nem szerepelhetnek a végső JAR-ban.
5. Mi az uber-JAR?
6. Az uber-JAR egy JAR-fájl, amely nemcsak a lefordított kódot tartalmazza, hanem annak összes függőségét is.
7. Hogyan kerülhetem el az osztályútvonal-ütközéseket a JAR-ban?
8. A lehetővé teszi a függőségeken belüli csomagok átnevezését az ütközések elkerülése érdekében.
9. Hogyan kezelhetem az ismétlődő osztályokat a függőségekben?
10. Konfigurálja a az ismétlődő osztályok és erőforrások kezeléséhez a duplikátumok kezelési módjának megadásával a végső JAR-ban.
11. Csak bizonyos fájlokat vehetek fel egy függőségből?
12. Igen, beállíthatja a vagy hogy csak bizonyos fájlok szerepeljenek egy függőségből.
13. Hogyan futtathatom a csomagolt JAR-t?
14. Használja a parancsot, majd a JAR-fájl elérési útját.
15. Hogyan ellenőrizhetem a JAR-fájlom tartalmát?
16. Használhatja a parancsot a JAR fájl tartalmának listázásához.
17. Mi a teendő, ha a JAR fájlom túl nagy?
18. Használja a a szükségtelen fájlok kizárására és a JAR méretének minimalizálására.

Befejező gondolatok a Maven végrehajtható JAR-okról

Függőségekkel rendelkező végrehajtható JAR létrehozása a Maven használatával leegyszerűsíti a Java-alkalmazások telepítési folyamatát. Megfelelő beállításával a fájlt, és olyan bővítményeket használva, mint a Maven Assembly Plugin vagy a Maven Shade Plugin, a fejlesztők az összes szükséges függőséget egyetlen JAR-fájlba csomagolhatják. Ez a megközelítés biztosítja, hogy az alkalmazás zökkenőmentesen futhasson különféle környezetekben, egyszerűvé téve a terjesztést és a végrehajtást. Az alábbi lépések követésével hatékonyan kezelheti projektje függőségeit, és megbízható, végrehajtható JAR-fájlokat hozhat létre.