安卓常见设计模式12------观察者模式（Kotlin版、Livedata、Flow）

1. W1 是什么，什么是观察者模式？​

1. 观察者模式（Observer Pattern）是一种行为型设计模式，用于实现组件间的松耦合通信。
2. 主要对象有观察者接口（Observer）和可观察对象（Observable）。

2. W2 为什么，为什么需要使用观察者模式，能给我们编码带来什么好处？​

1. 解耦性（Decoupling）：观察者模式可以降低组件之间的耦合度。观察者和被观察者之间是松散耦合的关系，它们之间只通过定义的接口进行通信。这样一来，当一个被观察者发生变化时，它并不关心具体观察者是谁以及观察者的数量和类型。同样，一个观察者也不需要关心被观察者的具体实现。这种解耦性使得代码更加灵活、可维护和可扩展。

2. 可重用性（Reusability）：通过使用观察者模式，可以将观察者和被观察者分开，使它们可以独立地进行重用。这使得我们可以在不同的上下文中重复使用同一个观察者和被观察者，而无需修改它们的实现。这提高了代码的重用性，减少了重复编写相似功能的工作量。

3. 扩展性（Extensibility）：观察者模式使得系统更易于扩展。当需要添加新的观察者或被观察者时，只需实现相应的接口即可，而无需修改现有的代码。这种扩展性使得系统能够灵活地适应变化和需求的增加，而不会影响已有的功能和模块。

4. 即时通知（Immediate Notification）：通过观察者模式，当被观察者的状态发生变化时，观察者可以立即获得通知。这样可以实现实时的数据更新和反馈，提供良好的用户体验。观察者可以根据自身的需求和逻辑对接收到的数据进行处理，例如更新UI、执行特定操作等。

5. 多态性（Polymorphism）：观察者模式利用了多态性的特性。观察者可以是不同类的实例，只要它们遵循相同的观察者接口。这种多态性使得我们可以在运行时动态地添加、删除和替换观察者，而无需修改现有的代码。这种灵活性和可扩展性使得系统更具适应性和可配置性。

3. W3，如何使用？下面是代码示例：

定义观察者接口（Observer）：

interface Observer {
    fun update(data: Any)
}
1
2
3

定义可观察对象（Observable）：

class Observable {
    private val observers: MutableList<Observer> = mutableListOf()

    fun addObserver(observer: Observer) {
        observers.add(observer)
    }

    fun removeObserver(observer: Observer) {
        observers.remove(observer)
    }

    fun notifyObservers(data: Any) {
        for (observer in observers) {
            observer.update(data)
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

实现观察者：

class MyObserver : Observer {
    override fun update(data: Any) {
        // 处理接收到的数据
        println("Received data: $data")
    }
}
1
2
3
4
5
6

示例代码：

fun main() {
    val observable = Observable()
    val observer1 = MyObserver()
    val observer2 = MyObserver()

    observable.addObserver(observer1)
    observable.addObserver(observer2)

    // 模拟发送数据
    observable.notifyObservers("Hello, World!")

    observable.removeObserver(observer2)

    // 再次发送数据
    observable.notifyObservers("Hi!")

    // 输出：
    // Received data: Hello, World!
    // Received data: Hello, World!
    // Received data: Hi!
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

平时开发过程中我们一般使用一些封装好了的Observer，下面是一些例子：

1. 使用LiveData

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData

object XXXXController {
    private val _data = MutableLiveData<String>()
    val data: LiveData<String> = _data

    fun updateData(data: String) {
        _data.value = data
    }
}

fun main() {
	XXXXController.data.observe(this@XXXActivity){
	    // 处理接收到的数据
	    println("Received data: $it")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2. 使用Flow

import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow

object XXXXController {
    private val _data = MutableStateFlow<String>("")
    val data: StateFlow<String> = _data

    fun updateData(data: String) {
        _data.value = data
    }
}


fun main() {
	lifecycleScope.launch {
	    XXXXController.data.collect { data ->
	        // 处理接收到的数据
	        println("Received data: $data")
	    }
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Thank you for your reading, best regards!