Android Academy · Pelajaran

Sebab Memodulkan

Kelajuan binaan, pemilikan dan guna semula.

Pelajaran 1 daripada 413 langkah

Sebab Memodulkan ialah pelajaran Android Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Android Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Android Academy merangkumi sejumlah 4 pelajaran.

Masalah Monolit

Apabila aplikasi Android berkembang, semua kodnya sering berada dalam satu modul app. Ini ialah monolit. Pada mulanya keadaan ini mudah, tetapi lama-kelamaan menjadi menyusahkan: setiap perubahan melibatkan modul yang sama, binaan menjadi perlahan, dan ahli pasukan sentiasa mengganggu kerja satu sama lain.

Pemodulan bermaksud memecahkan satu modul besar itu kepada banyak modul Gradle yang lebih kecil dan berfokus. Dalam pelajaran ini, anda akan mempelajari sebab pasukan melakukan perkara ini dan manfaat nyata yang diperolehnya.

Apakah Sebenarnya Modul

Dalam Gradle, modul ialah unit kod yang boleh dibina secara berasingan dan mempunyai fail build.gradle.kts sendiri. Aplikasi anda sudah mempunyai sekurang-kurangnya satu: modul :app. Anda mengisytiharkan setiap modul dalam settings.gradle.kts.

Menambah modul semudah menyertakannya. Setiap modul menghasilkan output binaannya sendiri dan boleh bergantung pada modul lain.

// settings.gradle.kts
include(":app")
include(":core:designsystem")
include(":core:data")
include(":feature:home")
include(":feature:profile")

Manfaat 1: Binaan Lebih Pantas

Kelebihan praktikal terbesar ialah kelajuan binaan. Gradle boleh membina modul secara selari dan, yang penting, menyimpan dalam cache serta melangkau modul yang inputnya tidak berubah.

Jika anda hanya mengedit :feature:profile, Gradle menggunakan semula output yang telah dibina bagi setiap modul lain. Dalam monolit, sebarang perubahan boleh memaksa penyusunan semula seluruh aplikasi.

Pelaksanaan selari merentas modul
Binaan berperingkat: hanya bina semula perkara yang berubah
Kadar penggunaan cache jauh/binaan yang lebih baik

// gradle.properties
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.configuration-cache=true

Manfaat 2: Sempadan yang Jelas

Modul menguatkuasakan sempadan. Kod dalam satu modul hanya boleh melihat perkara yang sengaja didedahkan oleh modul lain. Ini mengelakkan kod berselirat seperti mi, apabila setiap kelas mencapai ke dalam kelas lain.

Anda mengawal keterlihatan dengan konfigurasi Gradle api berbanding implementation. implementation menjadikan kebergantungan itu peribadi kepada modul; pengguna tidak boleh menggunakannya secara tidak sengaja.

// feature/profile/build.gradle.kts
dependencies {
    // Exposed to whoever depends on :feature:profile
    api(project(":core:model"))

    // Private: hidden from consumers of this module
    implementation(project(":core:network"))
}

Manfaat 3: Guna Semula

Setelah logik berada dalam modul yang berfokus, anda boleh menggunakannya semula di mana-mana. Modul :core:designsystem yang mengandungi tema, warna dan composable boleh guna semula anda boleh dikongsi oleh setiap ciri.

Idea yang sama boleh digunakan untuk berbilang aplikasi: sebuah syarikat boleh berkongsi modul :core:network merentas beberapa produk dan bukannya menyalin kod.

// Any feature can pull in shared building blocks
// feature/home/build.gradle.kts
dependencies {
    implementation(project(":core:designsystem"))
    implementation(project(":core:data"))
}

Manfaat 4: Pemilikan Pasukan

Modul sepadan dengan pemilikan pasukan dengan baik. Pasukan pembayaran memiliki :feature:payments; pasukan profil memiliki :feature:profile. Mereka boleh bekerja secara selari dengan konflik gabungan yang lebih sedikit kerana kod mereka berada dalam folder dan fail binaan yang berasingan.

Alat seperti fail CODEOWNERS boleh meminta semakan secara automatik daripada pasukan yang betul berdasarkan laluan modul.

# .github/CODEOWNERS
/feature/payments/   @org/payments-team
/feature/profile/    @org/profile-team
/core/designsystem/  @org/platform-team

Manfaat 5: Pengkapsulan Melalui Keterlihatan

Dalam modul, pengubah suai internal Kotlin menjadi sangat berkuasa. Kelas atau fungsi internal kelihatan hanya dalam modulnya sendiri. Modul lain sama sekali tidak boleh merujuk kepadanya.

Ini membolehkan anda mendedahkan permukaan awam yang kecil dan menyembunyikan butiran pelaksanaan, sesuatu yang mustahil dikuatkuasakan dalam satu modul gergasi.

// In :core:data
// Public API other modules may use
fun interface UserRepository {
    suspend fun loadUser(id: String): User
}

// Hidden from other modules
internal class DefaultUserRepository(
    private val api: UserApi
) : UserRepository {
    override suspend fun loadUser(id: String) = api.fetch(id).toUser()
}

Kosnya: Sedikit Overhed

Pemodulan bukan percuma. Setiap modul menambah satu build.gradle.kts untuk diselenggara, dan anda mesti memikirkan modul yang memiliki setiap bahagian kod. Pemodulan berlebihan untuk aplikasi kecil mewujudkan kerja tambahan tanpa manfaat.

Peraturan amnya: lakukan pemodulan apabila masa binaan menjadi masalah, apabila pasukan bertembung, atau apabila anda mempunyai lapisan yang jelas dan boleh diguna semula. Aplikasi hobi hujung minggu jarang memerlukan 30 modul.

Susun Atur Modul Biasa

Struktur yang biasa dan boleh diskalakan membahagikan modul kepada lapisan app, feature dan core. Modul :app menyambungkan semuanya; ciri mengandungi skrin yang dihadapi pengguna; modul teras mengandungi infrastruktur dikongsi.

// Conceptual project tree
// app/                  <- single entry point, wires features
// feature/
//   home/
//   profile/
//   settings/
// core/
//   designsystem/       <- theme + reusable composables
//   data/               <- repositories
//   network/            <- Retrofit/Ktor
//   model/              <- shared data classes

Pemalam Konvensyen Mengekalkan Keteraturan

Dengan banyak modul, menyalin dan menampal persediaan Gradle yang sama di merata tempat ialah perangkap. Pasukan mengekstrak konfigurasi dikongsi ke dalam pemalam konvensyen (dalam modul build-logic). Setiap modul sebenar kemudiannya menggunakan satu pemalam dan bukannya mengulangi berpuluh-puluh baris.

Anda akan melihat corak ini dalam aplikasi sumber terbuka besar seperti Now in Android. Buat masa ini, ketahui sahaja matlamatnya: pastikan fail binaan kecil dan konsisten.

// feature/home/build.gradle.kts
plugins {
    // One convention plugin sets up Android + Compose + Kotlin
    id("myapp.android.feature")
}

android { namespace = "com.myapp.feature.home" }

Pemikiran: Fikirkan dalam Lapisan

Model mental yang paling berguna: kebergantungan hendaklah mengalir ke bawah. Ciri bergantung pada teras; teras tidak bergantung pada ciri. Modul :app berada di paling atas dan bergantung pada segala yang diperlukannya untuk memasang aplikasi.

Jika anda mengekalkan arah ini secara konsisten, graf modul anda kekal kemas dan anda mengelakkan kitaran, yang akan anda terokai dalam pelajaran akan datang.

// Allowed:  app -> feature -> core
// Forbidden: core -> feature (upward) or feature -> feature (sideways)
// app/build.gradle.kts
dependencies {
    implementation(project(":feature:home"))
    implementation(project(":feature:profile"))
}

Semakan Pantas

Manakah antara berikut merupakan manfaat harian paling nyata yang diperoleh pasukan apabila memodulkan aplikasi Android yang semakin berkembang?

Jawab dalam pelajaran interaktif

Imbas Kembali: Sebab Melakukan Pemodulan

Anda telah mempelajari sebab pasukan memecahkan monolit kepada modul:

Binaan lebih pantas melalui pelaksanaan selari dan pencachean berperingkat
Sempadan yang jelas menggunakan api/implementation dan internal
Guna semula lapisan teras seperti sistem reka bentuk dan rangkaian
Pemilikan pasukan dengan konflik gabungan yang lebih sedikit

Anda juga telah melihat kosnya (fail binaan tambahan) dan peraturan utama: kebergantungan mengalir ke bawah, app -> feature -> core. Seterusnya, anda akan melukis sempadan sebenar antara modul ciri dan teras.

Percuma untuk bermula

Pelajari Kotlin dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 36
Pelajaran: 152

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Sebab Memodulkan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Android Academy, termasuk “Sebab Memodulkan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Android Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Sebab Memodulkan”?

Kelajuan binaan, pemilikan dan guna semula. Anda berlatih Android Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Android Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Android Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Sebab Memodulkan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Android Academy ini?

Ya. Setiap pelajaran Android Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Android Academy