Observer — konsep kunci pola langganan perubahan

Apa itu Observer: inti dari pola pengamat?

Observer (pengamat) — pola perilaku GoF yang mendefinisikan ketergantungan satu-ke-banyak antar objek. Ketika satu objek (Subject atau Observable) mengubah statusnya, semua objek yang bergantung (Observers) secara otomatis diberi tahu dan diperbarui. Pola ini mengimplementasikan kopling lemah: penerbit tidak mengetahui kelas konkret pelanggan — hanya bahwa mereka mengimplementasikan antarmuka Observer.

Struktur Observer mencakup antarmuka Subject dengan metode attach(), detach(), notify() dan antarmuka Observer dengan metode update(). ConcreteSubject menyimpan status dan daftar pelanggan. ConcreteObserver mengimplementasikan update() dan bereaksi terhadap perubahan. Dalam pengembangan seluler, implementasi klasik GoF jarang ditemukan — digantikan oleh mekanisme bawaan: NotificationCenter, Combine, Flow, LiveData, yang mengimplementasikan ide yang sama dengan API modern.

Model Push vs Pull — dalam model Push, Subject mengirim data ke semua pelanggan (NotificationCenter.post). Dalam model Pull, Subject hanya memberi tahu, dan pelanggan mengambil data sendiri. Android LiveData menggunakan Push (data diteruskan dalam observe()), RxJava/Flow mendukung kedua model. Pilihan tergantung pada tugas: Push lebih sederhana untuk pembaruan UI, Pull lebih efisien untuk volume data besar yang mungkin tidak ingin diterima pelanggan.

Observer di iOS: NotificationCenter, Combine dan KVO

NotificationCenter — mekanisme bawaan iOS/macOS untuk mengimplementasikan Observer. Penerbit mengirim Notification melalui NotificationCenter.default.post(name:, object:, userInfo:). Pelanggan mendaftar melalui addObserver(forName:, queue:, using:). NotificationCenter mendukung pemberitahuan bernama (Notification.Name) dan dapat meneruskan data apa pun di userInfo. UIKeyboardWillShowNotification, UIApplicationDidEnterBackgroundNotification — contoh sistem.

extension Notification.Name {
    static let userDidLogin = Notification.Name("userDidLogin")
}

// Penerbit
NotificationCenter.default.post(
    name: .userDidLogin,
    object: nil,
    userInfo: ["userId": "123"]
)

// Pelanggan
class ProfileViewModel {
    private var observers: [NSObjectProtocol] = []

    func startObserving() {
        let observer = NotificationCenter.default.addObserver(
            forName: .userDidLogin,
            object: nil,
            queue: .main
        ) { [weak self] notification in
            guard let userId = notification.userInfo?["userId"] as? String else { return }
            // Pelanggan bereaksi terhadap peristiwa
            self?.loadProfile(userId: userId)
        }
        observers.append(observer)
    }

    func stopObserving() {
        observers.forEach { NotificationCenter.default.removeObserver($0) }
        observers.removeAll()
    }
}

Combine framework — alternatif reaktif modern untuk NotificationCenter, tersedia sejak iOS 13. Publisher (NotificationCenter, URLSession.Timer) — penerbit, Subscriber (sink, assign) — pelanggan. Combine menambahkan operator (map, filter, combineLatest) untuk transformasi aliran data. @Published — property wrapper yang secara otomatis memberi tahu pelanggan tentang perubahan. Dalam MVVM dengan SwiftUI, Combine menggantikan NotificationCenter untuk menghubungkan ViewModel dan View.

KVO (Key-Value Observing) — mekanisme lama ObjC/Swift untuk mengamati properti individu objek. @objc dynamic var name: String — properti yang diamati. observe(.name) — langganan. KVO hanya berfungsi dengan kelas yang kompatibel dengan @objc dan warisan ObjC. Apple merekomendasikan Combine dan @Published daripada KVO di proyek baru. KVO tetap relevan untuk kompatibilitas UIKit di proyek hibrida.

Observer di Android: LiveData, StateFlow dan SharedFlow

LiveData — komponen Android Architecture Components untuk mengimplementasikan Observer. Kelas Observable yang memberi tahu pelanggan tentang perubahan data. LiveData memperhitungkan siklus hidup: pelanggan (LifecycleOwner) secara otomatis berhenti berlangganan saat dihancurkan. LiveData adalah model Push: data diteruskan dalam observe(). LiveData adalah blok bangunan dasar MVVM di Android sebelum pengenalan Jetpack Compose.

// ViewModel — penerbit
class UserViewModel : ViewModel() {
    private val _user = MutableLiveData<User?>(null)
    val user: LiveData<User?> = _user

    fun loadUser(id: String) {
        viewModelScope.launch {
            val result = userRepository.getUser(id)
            _user.value = result
        }
    }
}

// Fragment — pelanggan
class UserFragment : Fragment() {
    private val viewModel: UserViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        viewModel.user.observe(viewLifecycleOwner) { user ->
            // Pelanggan bereaksi terhadap perubahan
            userName.text = user?.name
            userEmail.text = user?.email
        }
    }
}

StateFlow dan SharedFlow — tipe reaktif dari Kotlin Coroutines yang menggantikan LiveData di Jetpack Compose. StateFlow — observable state holder dengan nilai saat ini tetap. SharedFlow — hot flow yang dapat dikonfigurasi tanpa status, cocok untuk peristiwa satu kali (navigasi, toast). Kedua tipe terintegrasi erat dengan Compose: collectAsState(), collectAsEffect(). StateFlow wajib digunakan di proyek Android modern dengan Compose.

LiveData vs StateFlow — LiveData terikat pada Android Lifecycle, StateFlow independen platform. StateFlow mendukung coroutines, operator (map, filter) dan diuji tanpa dependensi Android. LiveData lebih sederhana untuk kompatibilitas Java. Google merekomendasikan StateFlow untuk proyek baru dengan Kotlin + Compose, LiveData — untuk mendukung proyek lama atau kode Java.

Mengelola langganan dan kebocoran memori

Kebocoran memori (memory leaks) — masalah utama Observer tanpa pengelolaan langganan yang benar. Jika pelanggan (Activity, Fragment, UIViewController) dihancurkan tetapi tidak berhenti berlangganan, penerbit tetap memegang referensi ke sana, dan garbage collector tidak dapat membebaskan memori. Di Android, LifecycleOwner (Activity/Fragment) harus memanggil removeObserver() atau menggunakan observe(viewLifecycleOwner). Di iOS — removeObserver di deinit atau disposeBag di Combine.

Referensi lemah (weak reference) pada pelanggan — di blok langganan gunakan [weak self] di Swift dan rujuk ke lifecycle scope di Kotlin. LiveData secara otomatis mengelola langganan melalui LifecycleOwner — langganan hanya aktif ketika Lifecycle dalam status STARTED atau RESUMED. StateFlow di Compose menggunakan collectAsState() dengan mempertimbangkan lifecycle. NotificationCenter di iOS memerlukan [weak self] eksplisit, karena closure mereferensikan self secara kuat.

Observer vs Publisher-Subscriber: apa perbedaannya

Observer (GoF) dan Publisher-Subscriber (PubSub) — pola yang mirip tetapi berbeda. Di Observer, penerbit langsung memberi tahu pelanggan dengan memanggil metode mereka. Penerbit mengetahui pelanggan (menyimpan daftar). Di PubSub, penerbit dan pelanggan tidak saling mengetahui — ada perantara (Event Bus, Message Queue, NotificationCenter) di antara mereka. Penerbit mengirim pesan ke saluran, pelanggan mendengarkan saluran. PubSub memberikan kopling yang lebih longgar.

Contoh PubSub dalam pengembangan seluler — NotificationCenter di iOS dapat dianggap PubSub: penerbit tidak mengenal pelanggan — hanya memposting pemberitahuan. EventBus atau Otto di Android (usang). SharedFlow dengan BroadcastChannel — PubSub di dunia Kotlin. Dalam sistem terdistribusi, PubSub diimplementasikan melalui RabbitMQ, Kafka, Google PubSub. Untuk pengembangan seluler, PubSub berguna dalam arsitektur modular, di mana modul tidak boleh bergantung satu sama lain.

Apa yang harus dipilih — untuk pembaruan UI (ViewModel → View) gunakan Observer (LiveData, StateFlow, @Published). Untuk peristiwa antar modul (otorisasi, logout, perubahan tema) — PubSub (SharedFlow, NotificationCenter, EventBus). Observer lebih sederhana dan efisien dalam satu layar, PubSub lebih fleksibel untuk peristiwa global tetapi lebih sulit di-debug karena dependensi implisit.