Tworzenie wykonywalnego pliku JAR z zależnościami przy użyciu Mavena

Pakowanie projektów Maven w pojedynczy plik wykonywalny JAR

Podczas pracy z projektami w języku Java często konieczne jest spakowanie aplikacji w jeden wykonywalny plik JAR, aby ułatwić dystrybucję. Maven, potężne narzędzie do automatyzacji kompilacji, pozwala programistom uwzględnić wszystkie niezbędne zależności w jednym wyjściowym pliku JAR.

Ten artykuł poprowadzi Cię przez kroki niezbędne do skonfigurowania projektu Maven tak, aby zawierał wszystkie pliki JAR zależności w ostatecznym pliku wykonywalnym JAR. Postępując zgodnie z tymi instrukcjami, uprościsz proces wdrażania i zapewnisz płynne działanie aplikacji w różnych środowiskach.

Komenda	Opis
<plugin>	Definiuje wtyczkę Maven do użycia podczas procesu kompilacji. Wtyczki mogą wykonywać określone zadania, takie jak kompilacja kodu lub pakowanie projektu.
<groupId>	Określa identyfikator grupy dla projektu Maven, zwykle jest to odwrotna nazwa domeny.
<artifactId>	Definiuje identyfikator artefaktu, którym jest nazwa projektu.
<version>	Wskazuje aktualną wersję projektu.
<build>	Zawiera konfigurację kompilacji projektu, w tym wtyczki i zasoby.
<descriptorRef>	Odwołuje się do predefiniowanego deskryptora wtyczki Maven Assembly, takiego jak „jar-with-dependents”.
<mainClass>	Określa klasę główną, która ma zostać wykonana po uruchomieniu pliku JAR.
<execution>	Definiuje blok wykonawczy we wtyczce, określając zadania do wykonania na różnych etapach kompilacji.
mvn clean package	Polecenie wyczyszczenia projektu i spakowania go do pliku JAR, łącznie ze wszystkimi zależnościami.
java -jar target/...jar	Polecenie uruchomienia wygenerowanego pliku JAR, podając ścieżkę do pliku JAR.

Tworzenie i uruchamianie wykonywalnego pliku JAR za pomocą Mavena

Powyższe skrypty pokazują, jak skonfigurować projekt Maven tak, aby spakować wszystkie jego zależności w jeden wykonywalny plik JAR. Pierwszy skrypt to Maven plik zawierający konfigurację projektu. W tym pliku tag służy do definiowania wtyczki Maven Assembly. Ta wtyczka ma kluczowe znaczenie przy tworzeniu wykonywalnego pliku JAR zawierającego wszystkie zależności. The tag w konfiguracji wtyczki określa użycie jar-with-dependencies deskryptor, który gwarantuje, że wszystkie zależności projektu zostaną spakowane w końcowym pliku JAR. The tag wewnątrz sekcja jest niezbędna, ponieważ mówi Mavenowi, która klasa zawiera główną metodę do uruchomienia po wykonaniu pliku JAR.

The blok wewnątrz konfiguracji wtyczki jest miejscem, w którym dzieje się akcja. Określa, że ​​celem wtyczki należy wykonać w trakcie faza cyklu życia kompilacji. To właśnie powoduje utworzenie pliku JAR z zależnościami. Drugi skrypt to prosta instrukcja wiersza poleceń: mvn clean package. To polecenie czyści projekt (usuwając artefakty poprzedniej kompilacji), kompiluje kod źródłowy, uruchamia testy i pakuje projekt do pliku JAR. Ostateczny plik JAR będzie znajdować się w folderze katalog projektu i nazwany zgodnie z I określone w 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

Zaawansowane techniki Mavena dla zależności pakowania

Oprócz podstawowej konfiguracji tworzenia wykonywalnego pliku JAR za pomocą Mavena istnieją dodatkowe techniki, które mogą usprawnić proces kompilacji. Jedna z takich technik polega na użyciu wtyczka zamiast podłącz. Wtyczka Maven Shade oferuje bardziej zaawansowane funkcje tworzenia plików Uber-JAR (pliki JAR z dołączonymi zależnościami). Umożliwia zmianę nazw pakietów, aby uniknąć konfliktów ścieżek klas i zapewnia lepszą obsługę zduplikowanych klas i zasobów. Dodatkowo oferuje precyzyjną kontrolę nad zależnościami zawartymi w końcowym pliku JAR.

Kolejnym ważnym aspektem jest zarządzanie rozmiarem pliku JAR. Duże pliki JAR mogą być kłopotliwe i powolne w przesyłaniu lub ładowaniu. The może w tym pomóc, umożliwiając wykluczenie niepotrzebnych plików i klas, zmniejszając w ten sposób rozmiar końcowego pliku JAR. Możesz także skonfigurować wtyczkę tak, aby minimalizowała plik JAR poprzez usuwanie nieistotnych informacji, takich jak nieużywane klasy lub zbędne zasoby. Te zaawansowane konfiguracje mogą być szczególnie przydatne podczas pracy nad dużymi projektami z wieloma zależnościami.

1. Jak określić klasę główną w moim pliku JAR?
2. Możesz określić klasę główną za pomocą tag w sekcja konfiguracji wtyczki Maven.
3. Jak mogę wykluczyć określone zależności z końcowego pliku JAR?
4. Użyj tag w konfiguracji wtyczki, aby określić zależności, które nie powinny być uwzględniane w końcowym pliku JAR.
5. Co to jest uber-JAR?
6. Uber-JAR to plik JAR, który zawiera nie tylko skompilowany kod, ale także wszystkie jego zależności.
7. Jak mogę uniknąć konfliktów ścieżek klas w moim pliku JAR?
8. The umożliwia zmianę nazw pakietów w ramach zależności, aby uniknąć konfliktów.
9. Jak radzić sobie z duplikatami klas w zależnościach?
10. Skonfiguruj do zarządzania zduplikowanymi klasami i zasobami poprzez określenie sposobu obsługi duplikatów w końcowym pliku JAR.
11. Czy mogę uwzględnić tylko określone pliki z zależności?
12. Tak, możesz skonfigurować Lub aby uwzględnić tylko określone pliki z zależności.
13. Jak uruchomić spakowany plik JAR?
14. Użyj polecenie, po którym następuje ścieżka do pliku JAR.
15. Jak mogę zweryfikować zawartość mojego pliku JAR?
16. Możesz skorzystać z polecenie, aby wyświetlić zawartość pliku JAR.
17. Co się stanie, jeśli mój plik JAR jest za duży?
18. Użyj aby wykluczyć niepotrzebne pliki i zminimalizować rozmiar pliku JAR.

Końcowe przemyślenia na temat wykonywalnych plików JAR Mavena

Tworzenie wykonywalnego pliku JAR z zależnościami przy użyciu Mavena upraszcza proces wdrażania aplikacji Java. Dzięki prawidłowej konfiguracji i korzystając z wtyczek, takich jak Maven Assembly Plugin lub Maven Shade Plugin, programiści mogą spakować wszystkie niezbędne zależności w jeden plik JAR. Takie podejście zapewnia płynne działanie aplikacji w różnych środowiskach, co ułatwia dystrybucję i wykonanie. Wykonanie tych kroków pomoże Ci skutecznie zarządzać zależnościami projektu i tworzyć niezawodne, wykonywalne pliki JAR.