Android 观察者模式浅析

一、基本概念

定义

观察者模式定义了一种一对多的依赖关系，当一个对象（被观察者）的状态发生改变时，所有依赖于它的对象（观察者）都会得到通知并自动更新。

核心思想

1. 发布-订阅：被观察者发布事件，观察者订阅事件
2. 松耦合：观察者和被观察者之间是松耦合的
3. 自动通知：被观察者状态变化时自动通知所有观察者

应用场景

• 事件处理系统
• 数据绑定
• 消息队列
• GUI事件监听
• MVC/MVVM架构中的模型-视图通信

二、基本结构

四个核心角色

// 1. Subject (被观察者接口)
interface Subject {
    fun registerObserver(observer: Observer)
    fun removeObserver(observer: Observer)
    fun notifyObservers()
}

// 2. ConcreteSubject (具体被观察者)
class WeatherStation : Subject {
    private val observers = mutableListOf<Observer>()
    private var temperature: Float = 0f
    private var humidity: Float = 0f
    private var pressure: Float = 0f
    
    override fun registerObserver(observer: Observer) {
        if (!observers.contains(observer)) {
            observers.add(observer)
        }
    }
    
    override fun removeObserver(observer: Observer) {
        observers.remove(observer)
    }
    
    override fun notifyObservers() {
        observers.forEach { observer ->
            observer.update(temperature, humidity, pressure)
        }
    }
    
    fun setMeasurements(temperature: Float, humidity: Float, pressure: Float) {
        this.temperature = temperature
        this.humidity = humidity
        this.pressure = pressure
        measurementsChanged()
    }
    
    private fun measurementsChanged() {
        notifyObservers()
    }
    
    // 其他业务方法
    fun getTemperature(): Float = temperature
    fun getHumidity(): Float = humidity
    fun getPressure(): Float = pressure
}

// 3. Observer (观察者接口)
interface Observer {
    fun update(temperature: Float, humidity: Float, pressure: Float)
}

// 4. ConcreteObserver (具体观察者)
class CurrentConditionsDisplay(private val subject: Subject) : Observer {
    private var temperature: Float = 0f
    private var humidity: Float = 0f
    
    init {
        subject.registerObserver(this)
    }
    
    override fun update(temperature: Float, humidity: Float, pressure: Float) {
        this.temperature = temperature
        this.humidity = humidity
        display()
    }
    
    fun display() {
        println("当前温度: ${temperature}℃, 湿度: ${humidity}%")
    }
    
    fun unsubscribe() {
        subject.removeObserver(this)
    }
}

class StatisticsDisplay(private val subject: Subject) : Observer {
    private val temperatures = mutableListOf<Float>()
    
    init {
        subject.registerObserver(this)
    }
    
    override fun update(temperature: Float, humidity: Float, pressure: Float) {
        temperatures.add(temperature)
        display()
    }
    
    fun display() {
        val avg = temperatures.average()
        val max = temperatures.maxOrNull() ?: 0f
        val min = temperatures.minOrNull() ?: 0f
        println("温度统计: 平均=${"%.1f".format(avg)}℃, 最高=$max℃, 最低=$min℃")
    }
}

// 客户端使用
fun main() {
    val weatherStation = WeatherStation()
    val currentDisplay = CurrentConditionsDisplay(weatherStation)
    val statsDisplay = StatisticsDisplay(weatherStation)
    
    // 模拟天气数据变化
    weatherStation.setMeasurements(25f, 65f, 1013f)
    weatherStation.setMeasurements(26f, 70f, 1012f)
    weatherStation.setMeasurements(24f, 90f, 1014f)
    
    // 取消订阅
    currentDisplay.unsubscribe()
    weatherStation.setMeasurements(23f, 85f, 1015f) // currentDisplay不会收到通知
}

三、Android中的观察者模式实现

1. LiveData - Android架构组件

// ViewModel
class UserViewModel : ViewModel() {
    // MutableLiveData 是被观察者
    private val _userName = MutableLiveData<String>()
    
    // LiveData 是观察者可以观察的不可变版本
    val userName: LiveData<String> = _userName
    
    private val _userAge = MutableLiveData<Int>()
    val userAge: LiveData<Int> = _userAge
    
    private val _loading = MutableLiveData<Boolean>()
    val loading: LiveData<Boolean> = _loading
    
    private val _error = MutableLiveData<String?>()
    val error: LiveData<String?> = _error
    
    fun loadUserData(userId: String) {
        viewModelScope.launch {
            _loading.value = true
            _error.value = null
            
            try {
                val user = userRepository.getUser(userId)
                _userName.value = user.name
                _userAge.value = user.age
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _loading.value = false
            }
        }
    }
    
    fun updateUserName(name: String) {
        _userName.value = name
    }
}

// Activity/Fragment中观察
class UserActivity : AppCompatActivity() {
    private lateinit var viewModel: UserViewModel
    private lateinit var binding: ActivityUserBinding
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityUserBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        viewModel = ViewModelProvider(this)[UserViewModel::class.java]
        
        // 观察用户名变化
        viewModel.userName.observe(this) { name ->
            binding.tvUserName.text = name
            binding.etUserName.setText(name)
        }
        
        // 观察用户年龄变化
        viewModel.userAge.observe(this) { age ->
            binding.tvUserAge.text = age.toString()
        }
        
        // 观察加载状态
        viewModel.loading.observe(this) { isLoading ->
            binding.progressBar.isVisible = isLoading
            binding.btnSave.isEnabled = !isLoading
        }
        
        // 观察错误信息
        viewModel.error.observe(this) { errorMessage ->
            errorMessage?.let {
                Toast.makeText(this, it, Toast.LENGTH_SHORT).show()
            }
        }
        
        // 按钮点击更新数据
        binding.btnSave.setOnClickListener {
            val name = binding.etUserName.text.toString()
            viewModel.updateUserName(name)
        }
        
        // 加载用户数据
        val userId = intent.getStringExtra(EXTRA_USER_ID) ?: "1"
        viewModel.loadUserData(userId)
    }
}

// 自定义LiveData示例
class ConnectivityLiveData(private val context: Context) : LiveData<Boolean>() {
    private val connectivityManager = 
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    
    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) {
            postValue(true)
        }
        
        override fun onLost(network: Network) {
            postValue(false)
        }
    }
    
    override fun onActive() {
        super.onActive()
        // 注册网络状态回调
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            connectivityManager.registerDefaultNetworkCallback(networkCallback)
        } else {
            // 兼容旧版本实现
            val networkInfo = connectivityManager.activeNetworkInfo
            postValue(networkInfo?.isConnected == true)
        }
    }
    
    override fun onInactive() {
        super.onInactive()
        // 注销回调
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            connectivityManager.unregisterNetworkCallback(networkCallback)
        }
    }
}

2. View的点击事件监听

// Android中View的事件监听是观察者模式的典型应用
class MyActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        val button = findViewById<Button>(R.id.my_button)
        val textView = findViewById<TextView>(R.id.my_text)
        val editText = findViewById<EditText>(R.id.my_edit)
        
        // 1. 传统的观察者模式实现
        button.setOnClickListener(object : View.OnClickListener {
            override fun onClick(v: View?) {
                Toast.makeText(this@MyActivity, "按钮被点击", Toast.LENGTH_SHORT).show()
            }
        })
        
        // 2. Kotlin Lambda简化
        button.setOnClickListener {
            textView.text = "按钮被点击了"
        }
        
        // 3. 添加多个观察者（监听器）
        button.setOnClickListener {
            Log.d("MyActivity", "第一个监听器")
        }
        
        // 注意：这种方式会替换前一个监听器
        button.setOnClickListener {
            Log.d("MyActivity", "第二个监听器")
        }
        
        // 4. TextWatcher - 观察文本变化
        editText.addTextChangedListener(object : TextWatcher {
            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
                // 文本变化前
            }
            
            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
                // 文本变化时
                textView.text = "输入: $s"
            }
            
            override fun afterTextChanged(s: Editable?) {
                // 文本变化后
            }
        })
        
        // 5. 使用扩展函数简化
        editText.afterTextChanged { text ->
            button.isEnabled = text.length >= 6
        }
    }
}

// 扩展函数：简化TextWatcher使用
fun EditText.afterTextChanged(afterTextChanged: (String) -> Unit) {
    this.addTextChangedListener(object : TextWatcher {
        override fun afterTextChanged(editable: Editable?) {
            afterTextChanged.invoke(editable.toString())
        }
        
        override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) { /* 忽略 */ }
        override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) { /* 忽略 */ }
    })
}

3. BroadcastReceiver - 系统广播观察者

// 1. 动态注册广播接收器
class NetworkActivity : AppCompatActivity() {
    private lateinit var networkReceiver: BroadcastReceiver
    private lateinit var batteryReceiver: BroadcastReceiver
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_network)
        
        // 网络状态变化观察者
        networkReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) 
                    as ConnectivityManager
                
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                    val network = connectivityManager.activeNetwork
                    val capabilities = connectivityManager.getNetworkCapabilities(network)
                    
                    val isConnected = capabilities != null && (
                        capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) ||
                        capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
                    )
                    
                    updateUI(isConnected)
                }
            }
        }
        
        // 电池状态变化观察者
        batteryReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                val level = intent?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1
                val scale = intent?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1
                val batteryPercent = if (level >= 0 && scale > 0) {
                    level * 100 / scale
                } else {
                    0
                }
                
                findViewById<TextView>(R.id.tv_battery).text = "电量: $batteryPercent%"
            }
        }
    }
    
    override fun onResume() {
        super.onResume()
        // 注册网络状态观察者
        val filter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
        registerReceiver(networkReceiver, filter)
        
        // 注册电池状态观察者
        val batteryFilter = IntentFilter(Intent.ACTION_BATTERY_CHANGED)
        registerReceiver(batteryReceiver, batteryFilter)
    }
    
    override fun onPause() {
        super.onPause()
        // 注销观察者
        unregisterReceiver(networkReceiver)
        unregisterReceiver(batteryReceiver)
    }
    
    private fun updateUI(isConnected: Boolean) {
        findViewById<TextView>(R.id.tv_network).text = 
            if (isConnected) "网络已连接" else "网络未连接"
    }
}

// 2. 静态注册广播接收器（在AndroidManifest.xml中）
class BootCompletedReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
            // 设备启动完成，执行初始化操作
            startService(Intent(context, MyService::class.java))
        }
    }
}

// AndroidManifest.xml配置
/*
<receiver
    android:name=".BootCompletedReceiver"
    android:enabled="true"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
</receiver>
*/

四、观察者模式的变体

1. 事件总线 (EventBus)

// 简单事件总线实现
object EventBus {
    private val subscribers = mutableMapOf<Class<*>, MutableList<(Any) -> Unit>>()
    
    fun <T : Any> subscribe(eventType: Class<T>, subscriber: (T) -> Unit) {
        val subscribersList = subscribers.getOrPut(eventType) { mutableListOf() }
        subscribersList.add { event -> subscriber(event as T) }
    }
    
    fun <T : Any> unsubscribe(eventType: Class<T>, subscriber: (T) -> Unit) {
        subscribers[eventType]?.removeIf { it == subscriber }
    }
    
    fun <T : Any> post(event: T) {
        val eventType = event::class.java
        subscribers[eventType]?.forEach { subscriber ->
            try {
                subscriber(event)
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }
}

// 定义事件类
data class UserLoginEvent(val userId: String, val userName: String)
data class NetworkStateEvent(val isConnected: Boolean)
data class MessageReceivedEvent(val message: String)

// 使用
class MainActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 订阅事件
        EventBus.subscribe(UserLoginEvent::class.java) { event ->
            runOnUiThread {
                Toast.makeText(this, "用户登录: ${event.userName}", Toast.LENGTH_SHORT).show()
                updateUserInfo(event.userId)
            }
        }
        
        EventBus.subscribe(NetworkStateEvent::class.java) { event ->
            runOnUiThread {
                showNetworkStatus(event.isConnected)
            }
        }
    }
    
    override fun onDestroy() {
        super.onDestroy()
        // 取消订阅（简单实现中需要手动管理）
    }
    
    fun onLoginSuccess(userId: String, userName: String) {
        // 发布事件
        EventBus.post(UserLoginEvent(userId, userName))
    }
}

// Android中成熟的事件总线库：
// 1. LiveEventBus (基于LiveData)
// 2. EventBus (GreenRobot)
// 3. RxBus (基于RxJava)

2. 响应式编程 (RxJava)

// RxJava是观察者模式的扩展
class RxJavaExample {
    
    fun demonstrate() {
        // 创建被观察者
        val observable = Observable.create<String> { emitter ->
            try {
                emitter.onNext("数据1")
                emitter.onNext("数据2")
                emitter.onNext("数据3")
                emitter.onComplete()
            } catch (e: Exception) {
                emitter.onError(e)
            }
        }
        
        // 创建观察者
        val observer = object : Observer<String> {
            override fun onSubscribe(d: Disposable) {
                println("开始订阅")
            }
            
            override fun onNext(t: String) {
                println("收到数据: $t")
            }
            
            override fun onError(e: Throwable) {
                println("发生错误: ${e.message}")
            }
            
            override fun onComplete() {
                println("数据流完成")
            }
        }
        
        // 订阅
        observable.subscribe(observer)
        
        // 使用操作符链式调用
        Observable.interval(1, TimeUnit.SECONDS) // 每秒发射一个数字
            .take(5) // 只取前5个
            .map { it * 2 } // 转换
            .filter { it % 4 == 0L } // 过滤
            .subscribeOn(Schedulers.io()) // 在IO线程执行
            .observeOn(AndroidSchedulers.mainThread()) // 在主线程观察
            .subscribe(
                { value -> println("值: $value") },
                { error -> println("错误: $error") },
                { println("完成") }
            )
    }
    
    // Android网络请求示例
    fun loadUserData(userId: String) {
        apiService.getUser(userId)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnSubscribe {
                // 显示加载中
                showLoading()
            }
            .doOnTerminate {
                // 隐藏加载中
                hideLoading()
            }
            .subscribe(
                { user ->
                    // 更新UI
                    updateUserInfo(user)
                },
                { error ->
                    // 显示错误
                    showError(error.message)
                }
            )
    }
}

3. Kotlin Flow

// Kotlin协程中的Flow
class FlowExample {
    
    suspend fun demonstrate() {
        // 创建流（被观察者）
        val flow = flow {
            for (i in 1..5) {
                delay(1000) // 模拟耗时操作
                emit("值 $i") // 发射数据
            }
        }
        
        // 收集流（观察者）
        flow.collect { value ->
            println("收到: $value")
        }
        
        // 使用操作符
        flow
            .map { it.length } // 转换
            .filter { it > 3 } // 过滤
            .catch { e -> emit(-1) } // 异常处理
            .collect { length ->
                println("长度: $length")
            }
    }
    
    // Android中的使用
    class UserViewModel : ViewModel() {
        private val _userState = MutableStateFlow<UserState>(UserState.Loading)
        val userState: StateFlow<UserState> = _userState
        
        fun loadUser(userId: String) {
            viewModelScope.launch {
                _userState.value = UserState.Loading
                
                try {
                    val user = userRepository.getUser(userId)
                    _userState.value = UserState.Success(user)
                } catch (e: Exception) {
                    _userState.value = UserState.Error(e.message ?: "未知错误")
                }
            }
        }
        
        // 共享流
        val usersFlow = userRepository.getUsersFlow()
            .stateIn(
                scope = viewModelScope,
                started = SharingStarted.WhileSubscribed(5000),
                initialValue = emptyList()
            )
    }
    
    sealed class UserState {
        object Loading : UserState()
        data class Success(val user: User) : UserState()
        data class Error(val message: String) : UserState()
    }
}

4. 回调接口 (Callback)

// 回调是观察者模式的简化形式
interface DownloadCallback {
    fun onProgress(progress: Int)
    fun onSuccess(filePath: String)
    fun onFailure(error: String)
}

class FileDownloader(private val callback: DownloadCallback) {
    
    fun downloadFile(url: String, destination: String) {
        // 模拟下载过程
        Thread {
            for (i in 1..100 step 10) {
                Thread.sleep(500)
                callback.onProgress(i)
            }
            
            // 模拟下载成功
            callback.onSuccess(destination)
        }.start()
    }
}

// 使用回调
class MainActivity : AppCompatActivity(), DownloadCallback {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        val downloader = FileDownloader(this)
        downloader.downloadFile("http://example.com/file.zip", "/storage/file.zip")
    }
    
    override fun onProgress(progress: Int) {
        runOnUiThread {
            progressBar.progress = progress
            tvProgress.text = "$progress%"
        }
    }
    
    override fun onSuccess(filePath: String) {
        runOnUiThread {
            Toast.makeText(this, "下载完成: $filePath", Toast.LENGTH_SHORT).show()
        }
    }
    
    override fun onFailure(error: String) {
        runOnUiThread {
            Toast.makeText(this, "下载失败: $error", Toast.LENGTH_SHORT).show()
        }
    }
}

五、观察者模式的优缺点

✅ 优点

1. 松耦合：观察者和被观察者之间是抽象耦合
2. 支持广播通信：被观察者可以通知多个观察者
3. 开闭原则：可以随时增加新的观察者
4. 自动通知：状态变化时自动通知所有观察者
5. 灵活性：观察者可以动态地订阅和取消订阅

❌ 缺点

1. 内存泄漏风险：观察者持有被观察者引用可能导致内存泄漏
2. 通知顺序问题：观察者收到通知的顺序可能不确定
3. 性能问题：观察者数量多时，通知所有观察者可能影响性能
4. 循环依赖：可能导致循环引用和通知循环
5. 调试困难：事件流可能难以跟踪和调试

六、Android中的最佳实践

1. 避免内存泄漏

// 正确使用LiveData
class SafeActivity : AppCompatActivity() {
    private lateinit var viewModel: UserViewModel
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        viewModel = ViewModelProvider(this)[UserViewModel::class.java]
        
        // LifecycleOwner自动管理观察者生命周期
        viewModel.userName.observe(this) { name ->
            // 当Activity销毁时，观察者会自动移除
            updateUserName(name)
        }
    }
}

// 错误示例：使用匿名内部类持有Activity引用
class LeakyActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 错误：匿名内部类隐式持有Activity引用
        someGlobalObject.setCallback(object : SomeCallback {
            override fun onDataChanged(data: String) {
                // 如果someGlobalObject生命周期比Activity长，会导致内存泄漏
                updateUI(data)
            }
        })
    }
}

// 正确做法：使用弱引用或Lifecycle
class SafeCallback(private val lifecycleOwner: LifecycleOwner) : SomeCallback {
    private var isActive: Boolean = false
    
    init {
        lifecycleOwner.lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                isActive = event == Lifecycle.Event.ON_RESUME ||
                          event == Lifecycle.Event.ON_START ||
                          event == Lifecycle.Event.ON_CREATE
            }
        })
    }
    
    override fun onDataChanged(data: String) {
        if (isActive) {
            // 只在Activity活跃时更新UI
            updateUI(data)
        }
    }
}

2. 事件处理策略

// 1. SingleLiveEvent - 避免重复通知
class SingleLiveEvent<T> : MutableLiveData<T>() {
    private val pending = AtomicBoolean(false)
    
    @MainThread
    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        super.observe(owner) { t ->
            if (pending.compareAndSet(true, false)) {
                observer.onChanged(t)
            }
        }
    }
    
    @MainThread
    override fun setValue(t: T?) {
        pending.set(true)
        super.setValue(t)
    }
    
    fun call() {
        value = null
    }
}

// 2. EventWrapper - 包装事件防止重复消费
open class Event<out T>(private val content: T) {
    private var hasBeenHandled = false
    
    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }
    
    fun peekContent(): T = content
}

// 在ViewModel中使用
class MyViewModel : ViewModel() {
    private val _snackbarMessage = MutableLiveData<Event<String>>()
    val snackbarMessage: LiveData<Event<String>> = _snackbarMessage
    
    fun showSnackbar(message: String) {
        _snackbarMessage.value = Event(message)
    }
}

// 在Activity中观察
viewModel.snackbarMessage.observe(this) { event ->
    event.getContentIfNotHandled()?.let { message ->
        Snackbar.make(rootView, message, Snackbar.LENGTH_SHORT).show()
    }
}

3. 组合观察者模式

// 结合多个观察者模式
class CompositeObservable {
    private val liveDataObservers = mutableListOf<LiveData<*>>()
    private val rxDisposables = CompositeDisposable()
    private val flowJobs = mutableListOf<Job>()
    
    fun <T> observe(liveData: LiveData<T>, observer: (T) -> Unit) {
        liveData.observeForever { observer(it) }
        liveDataObservers.add(liveData)
    }
    
    fun <T> subscribe(observable: Observable<T>, observer: (T) -> Unit) {
        val disposable = observable
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                { observer(it) },
                { error -> Log.e("CompositeObservable", "Error", error) }
            )
        rxDisposables.add(disposable)
    }
    
    fun <T> collect(flow: Flow<T>, collector: (T) -> Unit) {
        val job = CoroutineScope(Dispatchers.Main).launch {
            flow.collect { collector(it) }
        }
        flowJobs.add(job)
    }
    
    fun clear() {
        // 清理所有观察者
        liveDataObservers.forEach { it.removeObservers { } }
        liveDataObservers.clear()
        
        rxDisposables.clear()
        
        flowJobs.forEach { it.cancel() }
        flowJobs.clear()
    }
}

// 在ViewModel或Presenter中使用
class MyPresenter {
    private val compositeObservable = CompositeObservable()
    
    fun setupObservers() {
        compositeObservable.observe(viewModel.userName) { name ->
            // 处理用户名变化
        }
        
        compositeObservable.subscribe(rxApi.getData()) { data ->
            // 处理RxJava数据
        }
        
        compositeObservable.collect(dataFlow) { value ->
            // 处理Flow数据
        }
    }
    
    fun onDestroy() {
        compositeObservable.clear()
    }
}

七、与其他模式的对比

观察者模式 vs 中介者模式

// 观察者模式：一对多，被观察者直接通知观察者
class Button {
    private val listeners = mutableListOf<ClickListener>()
    
    fun addClickListener(listener: ClickListener) {
        listeners.add(listener)
    }
    
    fun click() {
        listeners.forEach { it.onClick() }
    }
}

// 中介者模式：多对多，通过中介者协调
class Mediator {
    private val components = mutableMapOf<String, Component>()
    
    fun notify(sender: String, event: String, data: Any) {
        // 中介者决定如何转发事件
        when (event) {
            "click" -> handleClick(sender, data)
            "change" -> handleChange(sender, data)
        }
    }
}

八、总结

观察者模式是Android开发中最常用、最重要的设计模式之一，几乎无处不在：

核心应用

1. LiveData：Android架构组件中的核心
2. View事件监听：OnClickListener、TextWatcher等
3. BroadcastReceiver：系统广播监听
4. 事件总线：组件间通信
5. 响应式编程：RxJava、Kotlin Flow

关键要点

1. 生命周期管理：Android中必须注意观察者的生命周期
2. 避免内存泄漏：使用弱引用、Lifecycle-aware组件
3. 线程安全：确保观察者通知的线程安全
4. 事件去重：避免重复通知和事件风暴

选择建议

• 简单UI更新 → LiveData
• 复杂异步流 → RxJava/Kotlin Flow
• 组件间通信 → EventBus/LiveEventBus
• 系统事件 → BroadcastReceiver
• 简单回调 → 接口回调

观察者模式是构建响应式、解耦的Android应用的基础，合理使用可以显著提高代码的可维护性和可测试性。掌握观察者模式及其在Android中的各种实现方式，是每个Android开发者必备的核心技能。