Kebergantungan Antara Projek

Dalam binaan Gradle berbilang projek, projek kecil yang berbeza sering perlu bekerjasama. Satu projek kecil mungkin menghasilkan pustaka yang digunakan oleh projek kecil yang lain.

Di sinilah kebergantungan antara projek digunakan! Kebergantungan ini mentakrifkan cara projek kecil saling bergantung, serta memastikan susunan binaan dan perkongsian artifak yang betul.

• Kebergantungan antara projek: Cara satu projek kecil menggunakan kod atau output daripada projek kecil yang lain.
• Penting untuk aplikasi bermodul.

Mengisytiharkan bahawa satu projek kecil bergantung pada projek kecil yang lain adalah mudah dalam Gradle. Anda menggunakan fungsi project() dalam blok dependencies anda.

Contohnya, jika projek kecil app anda memerlukan kod daripada projek kecil lib, tambahkan perkara berikut pada app/build.gradle:

// app/build.gradle
dependencies {
    implementation project(':lib')
}

Bahagian :lib merujuk kepada laluan projek kecil lib berbanding akar.

Mari kita bayangkan persediaan berbilang projek yang mudah. Kita akan mempunyai projek akar, projek kecil app dan projek kecil lib.

settings.gradle anda akan kelihatan seperti ini:

// settings.gradle
rootProject.name = 'my-multi-project'
include 'app', 'lib'

Ini memberitahu Gradle tentang dua projek kecil kita, iaitu app dan lib.

Apabila mengisytiharkan kebergantungan antara projek, anda biasanya menggunakan konfigurasi seperti implementation atau api.

• implementation: Pilihan yang paling biasa. Kebergantungan digunakan secara dalaman oleh projek kecil dan tidak didedahkan kepada pengguna projek kecil tersebut.
• api: Mendedahkan kebergantungan kepada pengguna. Jika app bergantung pada lib melalui api, dan otherApp bergantung pada app, maka otherApp juga akan melihat API lib.

Untuk kegunaan dalaman antara projek kecil, implementation biasanya lebih digemari kerana enkapsulasi yang lebih baik dan binaan yang lebih pantas.

Mula-mula, mari cipta kelas mudah dalam projek kecil lib kita yang akan digunakan oleh projek kecil app. Kelas ini akan menyediakan utiliti asas.

Dalam lib/src/main/groovy/com/coddykit/LibUtils.groovy:

Sekarang, mari jadikan projek kecil app kita menggunakan kelas LibUtils daripada projek kecil lib. Ingat, kita telah mengisytiharkan implementation project(':lib') dalam app/build.gradle.

Cuba jalankan contoh ini:

Salah satu kelebihan terbesar mengisytiharkan kebergantungan antara projek ialah Gradle menentukan susunan binaan yang betul secara automatik.

• Jika app bergantung pada lib, Gradle memastikan lib dikompil dan artifaknya tersedia sebelum app memulakan kompilasinya.
• Ini menjimatkan usaha anda untuk mengurus urutan binaan secara manual, terutamanya dalam persediaan berbilang projek yang kompleks.

Apabila anda menjalankan gradle build dari akar, Gradle akan membina lib terlebih dahulu, kemudian app.

Bagaimana jika projek kecil lib anda sendiri bergantung pada projek kecil lain, katakan common?

// lib/build.gradle
dependencies {
    implementation project(':common')
}

// app/build.gradle
dependencies {
    implementation project(':lib')
}

Jika app bergantung pada lib, dan lib bergantung pada common, Gradle akan memastikan common turut dibina dan artifaknya tersedia secara transitif pada classpath app untuk kompilasi, tetapi tidak semestinya tersedia untuk APInya jika implementation digunakan untuk lib.

Untuk memastikan binaan berbilang projek anda mudah diurus dan cekap, ikuti amalan terbaik berikut:

• Kebergantungan Minimum: Isytiharkan hanya kebergantungan pada projek kecil yang benar-benar anda perlukan.
• Gunakan implementation: Utamakan implementation berbanding api untuk kebergantungan projek kecil dalaman bagi meningkatkan enkapsulasi dan mengurangkan binaan semula.
• Sempadan yang Jelas: Reka projek kecil anda dengan tanggungjawab yang jelas untuk mengelakkan kebergantungan bulat.
• Elakkan Laluan Panjang: Pastikan laluan projek kecil ringkas (contohnya, :module:submodule adalah sesuai, tetapi elakkan laluan yang terlalu panjang).

Syabas! Dalam pelajaran ini, anda telah mempelajari cara mengurus kebergantungan antara projek kecil dalam binaan Gradle berbilang projek.

• Kita membincangkan cara mengisytiharkan kebergantungan menggunakan project(':subproject').
• Kita membincangkan kepentingan implementation untuk kegunaan dalaman.
• Anda melihat cara Gradle mengendalikan susunan binaan secara automatik.
• Kita meneroka amalan terbaik untuk pengurusan kebergantungan yang bersih.

Penguasaan kebergantungan antara projek penting untuk membina aplikasi besar dan bermodul dengan cekap menggunakan Gradle!