Membuat JAR yang Dapat Dieksekusi dengan Dependensi Menggunakan Maven

Mengemas Proyek Maven ke dalam JAR Tunggal yang Dapat Dieksekusi

Saat bekerja dengan proyek Java, sering kali aplikasi Anda perlu dikemas ke dalam satu file JAR yang dapat dieksekusi untuk memudahkan distribusi. Maven, alat otomatisasi pembangunan yang kuat, memungkinkan pengembang untuk memasukkan semua dependensi yang diperlukan dalam JAR keluaran tunggal ini.

Artikel ini akan memandu Anda melalui langkah-langkah yang diperlukan untuk mengonfigurasi proyek Maven Anda untuk menyertakan semua JAR ketergantungan ke dalam JAR akhir yang dapat dieksekusi. Dengan mengikuti petunjuk ini, Anda akan menyederhanakan proses penerapan dan memastikan aplikasi Anda berjalan lancar di berbagai lingkungan.

Membuat dan Menjalankan JAR yang Dapat Dieksekusi dengan Maven

Skrip yang disediakan di atas menunjukkan cara mengonfigurasi proyek Maven untuk mengemas semua dependensinya ke dalam satu file JAR yang dapat dieksekusi. Skrip pertama adalah Maven pom.xml file, yang berisi konfigurasi proyek. Di dalam file ini, file <plugin> tag digunakan untuk mendefinisikan Plugin Majelis Maven. Plugin ini sangat penting untuk membuat JAR yang dapat dieksekusi yang mencakup semua dependensi. Itu <descriptorRefs> tag dalam konfigurasi plugin menentukan penggunaan jar-with-dependencies deskriptor, yang memastikan bahwa semua dependensi proyek dikemas ke dalam file JAR akhir. Itu <mainClass> menandai di dalam <manifest> bagian ini penting karena memberitahu Maven kelas mana yang berisi metode utama yang akan dijalankan ketika JAR dijalankan.

Itu <execution> blok di dalam konfigurasi plugin adalah tempat tindakan terjadi. Ini menentukan tujuan plugin single harus dieksekusi selama package fase siklus hidup pembangunan. Hal inilah yang memicu pembuatan file JAR dengan dependensi. Skrip kedua adalah instruksi baris perintah sederhana: mvn clean package. Perintah ini membersihkan proyek (menghapus artefak build sebelumnya), mengkompilasi kode sumber, menjalankan pengujian, dan mengemas proyek ke dalam file JAR. File JAR terakhir akan ditempatkan di target direktori proyek dan diberi nama sesuai dengan artifactId Dan version ditentukan 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 Tingkat Lanjut untuk Ketergantungan Pengemasan

Selain konfigurasi dasar untuk membuat JAR yang dapat dieksekusi dengan Maven, ada teknik tambahan yang dapat meningkatkan proses pembangunan Anda. Salah satu teknik tersebut melibatkan penggunaan shade plugin, bukannya assembly plugin. Plugin Maven Shade menawarkan fitur yang lebih canggih untuk membuat uber-JAR (termasuk JAR dengan dependensi). Ini memungkinkan Anda mengganti nama paket untuk menghindari konflik classpath dan memberikan penanganan yang lebih baik untuk kelas dan sumber daya duplikat. Selain itu, ia menawarkan kontrol menyeluruh atas dependensi mana yang disertakan dalam JAR akhir.

Aspek penting lainnya adalah mengatur ukuran file JAR Anda. File JAR berukuran besar bisa jadi rumit dan lambat untuk ditransfer atau dimuat. Itu maven-shade-plugin dapat membantu dalam hal ini dengan memungkinkan Anda mengecualikan file dan kelas yang tidak diperlukan, sehingga mengurangi ukuran JAR akhir. Anda juga dapat mengonfigurasi plugin untuk meminimalkan JAR dengan menghapus informasi yang tidak penting seperti kelas yang tidak digunakan atau sumber daya yang berlebihan. Konfigurasi tingkat lanjut ini bisa sangat berguna ketika mengerjakan proyek besar dengan banyak ketergantungan.

Kesimpulan Pemikiran tentang JAR yang Dapat Dieksekusi Maven

Membuat JAR yang dapat dieksekusi dengan dependensi menggunakan Maven menyederhanakan proses penerapan aplikasi Java. Dengan mengkonfigurasi dengan benar pom.xml file dan memanfaatkan plugin seperti Maven Assembly Plugin atau Maven Shade Plugin, pengembang dapat mengemas semua dependensi yang diperlukan ke dalam satu file JAR. Pendekatan ini memastikan bahwa aplikasi dapat berjalan dengan lancar di berbagai lingkungan, membuat distribusi dan eksekusi menjadi mudah. Mengikuti langkah-langkah ini akan membantu Anda mengelola dependensi proyek Anda secara efektif dan membuat file JAR yang andal dan dapat dieksekusi.