Dua Keputusan Saling Terkait yang Menentukan Skalabilitas Tim#
Pada Part 2 dari seri ini, kita telah membedah bagaimana setiap modul fitur di Holigo ditata ulang ke dalam tiga lapisan terisolasi: Presentation, Domain, dan Data. Namun, menetapkan batas-batas lapisan hanyalah separuh dari perjalanan. Agar lapisan-lapisan tersebut dapat berkomunikasi tanpa tergelincir kembali ke dalam keterikatan kode (spaghetti coupling), tim engineer harus menjawab dua pertanyaan arsitektur yang saling bergantung:
Bagaimana antarmuka layar mengomunikasikan mutasi data secara terprediksi di sepanjang siklus hidup asinkron? Dan bagaimana setiap lapisan menerima dependensi konkret yang dibutuhkannya tanpa menuliskan implementasi langsung di dalam widget antarmuka?
Di Holigo, kami memadukan pola BLoC (Business Logic Component) dengan get_it sebagai service locator untuk dependency injection. Di berbagai forum developer, state management dan dependency injection kerap diperdebatkan secara terpisah, padahal di lingkungan produksi keduanya saling mempengaruhi secara langsung. BLoC mengonsumsi Use Case di layer Domain, Use Case membutuhkan kontrak Repository, dan Repository bergantung pada Data Source tingkat rendah. Jika grafik dependensi rapuh, alur manajemen state aplikasi pasti akan goyah saat menghadapi beban skala besar.
Berikut adalah evaluasi jujur mengapa kami memilih kombinasi ini, bagaimana kami menyusunnya di puluhan modul, serta harga operasional yang secara sadar kami terima.
UI Dispatch Event
Presentation LayerWidget mengirim Event (misal SearchShipSchedule) ke BLoC tanpa menjalankan business logic.
Event Handler & Logic
BLoC ControllerBLoC menerima event, memicu state Loading, dan memanggil Domain Use Case yang bersangkutan.
Use Case Execution
Domain LayerUse Case memvalidasi aturan bisnis dan meminta data lewat repository contract murni.
Emit Immutable State
State EmissionBLoC memancarkan State baru (Success/Failure) yang langsung dirender secara reaktif oleh UI.
Unidirectional data flow memastikan setiap mutasi tampilan selalu meninggalkan jejak event dan state yang deterministik, memudahkan debugging dan uji otomatis.
Dari GetX ke BLoC: Mengembalikan Alur State yang Deterministik#
Pemicu utama kami meninggalkan GetX adalah kebutuhan mendesak akan alur mutasi state yang terprediksi dan mudah diaudit. Dalam aplikasi multi-layanan transaksional yang memproses pembayaran finansial dan pemesanan tiket perjalanan setiap hari, "magic reactivity" otomatis menyimpan risiko besar. Ketika perubahan state dapat dipicu secara implisit dari mana saja di dalam controller atau callback UI, melacak akar masalah dari anomali tampilan di layar pengguna berubah menjadi tebak-tebakan yang melelahkan.
BLoC memecahkan ketidakpastian itu melalui prinsip aliran data satu arah (unidirectional data flow) yang ketat:
Lapisan Presentation dilarang keras mengubah state secara langsung. Sebagai gantinya, widget UI memancarkan Event yang eksplisit (seperti SearchShipSchedule atau SelectBerthQuota). BLoC menangkap event tersebut, memperbarui status loading, mendelegasikan eksekusi ke Use Case Domain, dan memancarkan State baru yang tidak dapat diubah (immutable). State ini membawa data payload sekaligus enum status request yang jelas (initial, loading, success, failure).
Karena setiap state bersifat immutabel dan dikirim melalui Dart stream standar, setiap perubahan visual di layar selalu meninggalkan jejak audit yang nyata. Saat tim customer care menerima keluhan mengapa layar pemesanan menampilkan dialog gagal, engineer tidak perlu meraba-raba: mereka dapat merekonstruksi urutan event yang masuk dan memeriksa state yang dipancarkan secara deterministik.
Dependency Injection Modular dengan get_it#
Ketika sebuah fitur dipecah ke dalam tiga lapisan, satu layar antarmuka bergantung pada rangkaian abstraksi yang panjang: ShipScreen membutuhkan ShipBloc, yang memerlukan GetShipSchedulesUseCase, yang bergantung pada ShipRepository, yang kemudian membutuhkan ShipRemoteDataSource, ShipLocalDataSource, serta klien HTTP terpusat DioClient.
Jika seluruh dependensi ini dirakit secara manual di dalam constructor widget, lapisan UI akan penuh dengan baris kode perakitan (wiring boilerplate). Sebaliknya, jika semua pendaftaran dependensi ditumpuk di dalam satu file inisialisasi monolitik raksasa, konflik git merge akan langsung menghambat kecepatan tim setiap kali ada beberapa developer yang merilis fitur bersamaan.
Untuk menuntaskan dilema ini, kami memadukan get_it dengan pola Modular Feature Injector:
- Service Locator Terpusat: Fungsi sentral
setupLocator()dieksekusi saat aplikasi pertama kali melakukan bootstrap untuk mendaftarkan singleton global bersama: klien HTTP Dio, penyimpanan token aman, engine database, dan router navigasi. - Injector per Modul Fitur: Setiap modul bisnis (contohnya
features/ship/di/ship_injector.dart) memiliki berkas injector mandiri yang bertanggung jawab mendaftarkan data source lokal, implementasi repository, use case domain murni, serta factory untuk BLoC. - Pendaftaran Terisolasi: File sentral cukup memanggil injector dari tiap fitur secara berurutan saat startup, menjaga modul fitur tetap berdiri sebagai unit yang rapi dan terisolasi.
File sentral setupLocator() dipanggil saat aplikasi startup, kemudian memanggil konfigurasi injector mandiri milik tiap feature module.
- •Dio Client Wrapper: Klien HTTP terpusat dengan interceptor token dan error.
- •Storage Services: Akses penyimpanan terenkripsi dan cache key-value.
- •App Router: Routing terpusat go_router dengan auth middleware.
- •Data Sources & Repo: Remote & local data source terhubung ke repository implementation.
- •Domain Use Cases: Semua use case bisnis terdaftar secara mandiri.
- •BLoC Providers: Didaftarkan sebagai factory untuk menjamin state segar.
Memecah registrasi DI ke dalam injector per fitur mencegah file bootstrap membengkak menjadi ribuan baris kode spaghetti.
Struktur ini langsung memberikan efisiensi tinggi bagi tim. Widget UI cukup meminta BLoC yang diperlukannya dari locator tanpa perlu tahu detail bagaimana grafik dependensi internalnya dibangun. Selain itu, karena repository dan data source terdaftar berdasarkan antarmuka kontrak abstrak, mengganti implementasi nyata dengan implementasi tiruan (mock) saat pengujian unit test otomatis menjadi sangat mudah.
Cakupan State: BLoC Global di Akar App vs BLoC Scoped per Layar#
Salah satu keputusan desain paling berpengaruh dalam arsitektur BLoC adalah menentukan di mana sebuah BLoC diletakkan pada pohon widget (widget tree). Di Holigo, kami membagi cakupan siklus hidup state menjadi dua kategori:
BLoC Global di Akar Aplikasi: Sekelompok BLoC yang berumur panjang didaftarkan di tingkat paling atas aplikasi agar konteks sistem bersama dapat diakses secara instan dari seluruh penjuru layar. Ini mencakup preferensi tema visual, lokalisasi bahasa aktif, sesi login profil pengguna, badge notifikasi, serta master data pelabuhan kapal. Karena data ini dibutuhkan oleh banyak tab dan dialog modal, menyediakannya secara global mencegah pembacaan berulang ke penyimpanan lokal dan menghindari passing parameter yang rumit antar rute navigasi.
BLoC Scoped Khusus Layar: Sebaliknya, alur kerja transaksi (seperti pemilihan kursi penumpang, verifikasi pembayaran, atau pencarian jadwal pesawat) dibatasi secara ketat hanya pada siklus hidup layar bersangkutan. BLoC ini dibuat saat layar dibuka dan otomatis dihancurkan (disposed) dari memori perangkat ketika pengguna berpindah halaman.
- 01Tujuan: State yang dipakai hampir di seluruh aplikasi seperti Tema, Bahasa, Sesi User, dan Notifikasi.
- 02Kelebihan: Tersedia instan di mana saja tanpa perlu dipassing manual antar rute navigasi.
- 03Konsekuensi: State hidup terus di memory; jika terlalu banyak, keterikatan antar layar meningkat.
- 01Tujuan: Logika transaksi spesifik seperti Pencarian Kapal, Checkout Tiket, atau Input Penumpang.
- 02Kelebihan: Otomatis di-dispose saat user meninggalkan layar; tidak ada memory leak.
- 03Konsekuensi: Data layar ter-reset jika user keluar halaman kecuali dicache ke penyimpanan lokal.
Hanya state yang benar-benar dipakai bersama lintas layar yang layak dinaikkan ke akar app; selebihnya harus tetap terisolasi di scope layar fiturnya masing-masing.
Pemisahan ini menjaga konsumsi memori perangkat tetap hemat dan menjamin bahwa data formulir transaksi yang sudah usang tidak akan pernah terbawa secara tidak sengaja ke sesi pemesanan pengguna berikutnya.
Harga Nyata di Lapangan: Boilerplate, Registrasi Runtime, dan Disiplin#
Tidak ada arsitektur yang tanpa konsekuensi. Meskipun BLoC dan get_it memberikan kestabilan yang luar biasa, keduanya membawa beban kerja nyata yang wajib dikelola dengan disiplin tinggi oleh tim:
- Pertambahan Jumlah Berkas dan Boilerplate: Menambahkan satu tombol sederhana kini mengharuskan kita menyentuh file event, state, bloc handler, use case contract, hingga berkas injector. Untuk proses prototyping kilat, ritual ini terasa cukup berat.
- Kesalahan Pendaftaran Baru Muncul di Runtime: Tidak seperti framework dependency injection berbasis compile-time, kelupaan mendaftarkan sebuah dependensi di
get_itbaru akan meledak saat aplikasi berjalan dan mencoba memanggil instance tersebut. Untuk mengantisipasi risiko ini, kami menyusun automated smoke test dan checklist pull-request ketat guna memastikan seluruh injector terhubung sebelum merger kode. - Godaan Menumpuk State Global: BLoC global memiliki gravitasi yang menggoda: developer kerap tergiur memindahkan state khusus layar ke akar aplikasi semata-mata karena lebih mudah diakses. Tanpa pengawasan arsitektur yang konsisten, layer global state dapat dengan cepat berubah menjadi bottleneck yang saling terikat erat.
- Kemudahan Pengujian Hanyalah Prasyarat, Bukan Jaminan: Memisahkan arsitektur membuat kode mudah diuji, namun arsitektur tidak menuliskan tes untuk kita. Membangun fondasi yang rapi hanyalah langkah awal; mengejar cakupan pengujian unit test dan stream test di seluruh BLoC adalah pekerjaan rumah nyata yang terus kami kerjakan.
Apa yang Bisa Dibawa dari Cerita Ini#
Jika kamu sedang merancang arsitektur state management dan dependency injection untuk aplikasi mobile-mu, berikut adalah empat prinsip penting yang bisa langsung diterapkan:
- Pilih State Management Berdasarkan Kebutuhan Prediktabilitas: Kami memilih BLoC karena aliran data yang terarah dan mutasi state yang deterministik adalah kebutuhan mutlak untuk aplikasi finansial, bukan karena mengikuti tren industri.
- Pecah Registrasi DI per Modul Fitur: Jangan pernah menumpuk semua pendaftaran service ke dalam satu berkas raksasa. Injector modular per fitur memastikan developer baru dapat merawat modulnya tanpa memicu konflik git yang menyulitkan tim.
- Terapkan Batasan Cakupan State yang Ketat: Simpan akar aplikasi khusus untuk state global yang benar-benar berumur panjang. Jadikan BLoC yang di-scoped per layar sebagai pilihan standar utama untuk seluruh alur transaksi dan antarmuka.
- Siapkan Jaring Pengaman untuk Runtime Locator: Jika menggunakan service locator seperti
get_it, buat pengecekan otomatis saat proses build atau CI test suite untuk mendeteksi dependensi yang lupa didaftarkan jauh sebelum kode dirilis ke pengguna.
Penutup#
State management dan dependency injection adalah sistem saraf pusat dari setiap aplikasi Flutter berskala besar. Dengan mengadopsi alur event-state deterministik BLoC serta menata get_it ke dalam injector fitur yang modular, Holigo berhasil mengamankan stabilitas yang dibutuhkan untuk menopang pertumbuhan aplikasi multi-layanan lintas tim.
Pada Part 4 nanti, kita akan membahas arsitektur navigasi dan alur startup aplikasi: bagaimana go_router dan authentication middleware menjaga pintu masuk aplikasi tetap bersih, aman, dan tahan banting.
Terima kasih telah membaca :)
P.S. Seri ini ditulis di level keputusan desain arsitektur dan sistem rekayasa perangkat lunak, tanpa membuka kode atau data internal perusahaan. Jika kamu memiliki pertanyaan mengenai pengelolaan BLoC, strategi DI, atau ingin berbagi cerita migrasi di tim mobile-mu, mari berdiskusi!