Mencipta JAR Boleh Laku dengan Ketergantungan Menggunakan Maven

Membungkus Projek Maven ke dalam JAR Boleh Laksana Tunggal

Apabila bekerja dengan projek Java, selalunya perlu untuk membungkus aplikasi anda ke dalam satu fail JAR boleh laku untuk pengedaran yang mudah. Maven, alat automasi binaan yang berkuasa, membolehkan pembangun memasukkan semua kebergantungan yang diperlukan dalam JAR keluaran tunggal ini.

Artikel ini akan membimbing anda melalui langkah-langkah yang diperlukan untuk mengkonfigurasi projek Maven anda untuk memasukkan semua JAR pergantungan ke dalam JAR boleh laku terakhir anda. Dengan mengikut arahan ini, anda akan memudahkan proses penggunaan dan memastikan aplikasi anda berjalan lancar merentas persekitaran yang berbeza.

Mencipta dan Menjalankan JAR Boleh Laku dengan Maven

Skrip yang disediakan di atas menunjukkan cara mengkonfigurasi projek Maven untuk membungkus semua kebergantungannya ke dalam satu fail JAR boleh laku. Skrip pertama ialah Maven pom.xml fail, yang mengandungi konfigurasi projek. Dalam fail ini, <plugin> tag digunakan untuk menentukan Maven Assembly Plugin. Pemalam ini penting untuk mencipta JAR boleh laku yang merangkumi semua kebergantungan. The <descriptorRefs> tag dalam konfigurasi pemalam menentukan penggunaan jar-with-dependencies deskriptor, yang memastikan bahawa semua kebergantungan projek dibungkus ke dalam fail JAR akhir. The <mainClass> tag di dalam <manifest> seksyen adalah penting kerana ia memberitahu Maven kelas mana yang mengandungi kaedah utama untuk dijalankan apabila JAR dilaksanakan.

The <execution> blok di dalam konfigurasi pemalam ialah tempat tindakan itu berlaku. Ia menyatakan bahawa matlamat pemalam single hendaklah dilaksanakan semasa package fasa kitaran hayat binaan. Inilah yang mencetuskan penciptaan fail JAR dengan kebergantungan. Skrip kedua ialah arahan baris arahan yang mudah: mvn clean package. Perintah ini membersihkan projek (mengalih keluar artifak binaan sebelumnya), menyusun kod sumber, menjalankan ujian dan membungkus projek ke dalam fail JAR. Fail JAR akhir akan terletak di target direktori projek dan dinamakan mengikut artifactId dan version dinyatakan dalam 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

Teknik Maven Lanjutan untuk Ketergantungan Pembungkusan

Di luar konfigurasi asas untuk mencipta JAR boleh laku dengan Maven, terdapat teknik tambahan yang boleh meningkatkan proses binaan anda. Satu teknik sedemikian melibatkan penggunaan shade pemalam dan bukannya assembly pasangkan. Maven Shade Plugin menawarkan ciri yang lebih maju untuk mencipta uber-JAR (JAR dengan kebergantungan disertakan). Ia membolehkan anda menamakan semula pakej untuk mengelakkan konflik laluan kelas dan menyediakan pengendalian yang lebih baik untuk kelas dan sumber pendua. Selain itu, ia menawarkan kawalan terperinci ke atas kebergantungan yang disertakan dalam JAR akhir.

Satu lagi aspek penting ialah mengurus saiz fail JAR anda. Fail JAR yang besar boleh menyusahkan dan lambat untuk dipindahkan atau dimuatkan. The maven-shade-plugin boleh membantu dengan ini dengan membenarkan anda mengecualikan fail dan kelas yang tidak perlu, sekali gus mengurangkan saiz JAR akhir. Anda juga boleh mengkonfigurasi pemalam untuk meminimumkan JAR dengan mengalih keluar maklumat yang tidak penting seperti kelas yang tidak digunakan atau sumber berlebihan. Konfigurasi lanjutan ini amat berguna apabila bekerja pada projek besar dengan banyak kebergantungan.

Menyimpulkan Pemikiran tentang JAR Boleh Laksana Maven

Mencipta JAR boleh laku dengan kebergantungan menggunakan Maven memudahkan proses penggunaan untuk aplikasi Java. Dengan mengkonfigurasi dengan betul pom.xml fail dan menggunakan pemalam seperti Maven Assembly Plugin atau Maven Shade Plugin, pembangun boleh membungkus semua kebergantungan yang diperlukan ke dalam satu fail JAR. Pendekatan ini memastikan bahawa aplikasi boleh berjalan dengan lancar dalam pelbagai persekitaran, menjadikan pengedaran dan pelaksanaan menjadi mudah. Mengikuti langkah ini akan membantu anda mengurus kebergantungan projek anda dengan berkesan dan mencipta fail JAR yang boleh dipercayai dan boleh dilaksanakan.