设计模式之《观察者模式》_android观察者模式

什么是观察者模式

观察者模式是一种行为型模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象，当主题对象状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

为什么用观察者模式

观察者模式可以方便地实现对象之间的松耦合，提高系统的可维护性和可扩展性。例如，当一个对象的状态发生变化时，我们可以通过观察者模式来避免紧耦合的代码，可以让多个观察者对象独立地对主题对象的状态变化做出响应。

工作中用在哪里

在Android开发中，观察者模式经常用在以下场景：

1)当用户点击一个按钮时，多个控件需要同时更新显示，此时可以使用观察者模式，让这些控件成为主题对象的观察者，当主题对象的状态发生变化时，通知观察者更新自己。

2)当用户需要实时获取某个数据时，可以将该数据作为主题对象，多个观察者监听该主题对象，当该数据发生变化时，主题对象通知所有观察者对象更新自己，这样可以实现实时更新数据。

3)当用户需要实现事件总线的功能时，可以使用观察者模式，通过注册观察者来监听事件的发生，当事件发生时，通知所有观察者处理相应的逻辑。

设计思路

在观察者模式中，主要包含以下几个角色：

1)抽象主题：定义了主题对象的接口，其中包含了添加、删除、通知观察者的方法。

2)具体主题：实现了抽象主题的接口，同时保存了观察者列表，并在状态发生变化时，通知所有观察者。

3)抽象观察者：定义了观察者的接口，其中包含了更新自己的方法。

4)具体观察者：实现了抽象观察者的接口，具体实现自己的更新逻辑。

观察者模式的代码实现

以观察者模式实现事件总线为例，代码实现如下：
1、抽象主题

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(Object obj);
}
1
2
3
4
5

2、具体主题

public class EventBus implements Subject{
    private List<Observer> observerList = new ArrayList<>();
    
    @Override
    public void registerObserver(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void notifyObservers(Object obj) {
        for (Observer observer : observerList) {
            observer.update(obj);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3、抽象观察者

public interface Observer {
    void update(Object obj);
}
1
2
3

4、具体观察者

public class MainObserver implements Observer {

    public MainObserver(Subject subject) {
        subject.registerObserver(this);
    }

    @Override
    public void update(Object obj) {
        //处理逻辑
    }
}
1
2
3
4
5
6
7
8
9
10
11

5、使用示例

EventBus eventBus = new EventBus();
MainObserver mainObserver = new MainObserver(eventBus);
//事件发生时，通知所有观察者
eventBus.notifyObservers(obj);
1
2
3
4

Android SDK中用到的观察者

在Android SDK中，一个经典的例子是使用观察者模式来监听网络连接状态的变化。Android提供了一个名为ConnectivityManager的类，该类可以用来监测设备的网络连接状态。它使用了观察者模式来通知应用程序网络连接状态的变化。
下面是一个简化的示例代码，展示了如何使用ConnectivityManager和观察者模式来监听网络连接状态的变化：

// 实现一个观察者接口
interface NetworkStatusObserver {
    void onNetworkStatusChanged(boolean isConnected);
}

// 创建具体的观察者类
class NetworkStatusObserverImpl implements NetworkStatusObserver {
    @Override
    public void onNetworkStatusChanged(boolean isConnected) {
        if (isConnected) {
            System.out.println("网络已连接");
        } else {
            System.out.println("网络已断开");
        }
    }
}

// 在Activity中使用观察者模式监听网络连接状态的变化
public class MainActivity extends AppCompatActivity {
    private ConnectivityManager connectivityManager;
    private NetworkStatusObserver observer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

        observer = new NetworkStatusObserverImpl();

        // 注册观察者，监听网络连接状态变化
        connectivityManager.registerDefaultNetworkCallback(new ConnectivityManager.NetworkCallback() {
            @Override
            public void onAvailable(@NonNull Network network) {
                observer.onNetworkStatusChanged(true);
            }

            @Override
            public void onLost(@NonNull Network network) {
                observer.onNetworkStatusChanged(false);
            }
        });

        // 模拟网络连接状态变化
        boolean isConnected = checkNetworkStatus();
        observer.onNetworkStatusChanged(isConnected);
    }

    // 检查网络连接状态
    private boolean checkNetworkStatus() {
        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
        return activeNetworkInfo != null && activeNetworkInfo.isConnected();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

在这个例子中，我们定义了一个NetworkStatusObserver接口作为观察者，NetworkStatusObserverImpl是具体的观察者类。在MainActivity中，我们通过使用ConnectivityManager来监听网络连接状态的变化。通过注册ConnectivityManager.NetworkCallback回调接口，当网络连接状态发生变化时，会通过观察者模式通知观察者对象。NetworkStatusObserverImpl实现onNetworkStatusChanged方法来处理网络连接状态的变化。

这个例子展示了Android SDK中如何使用观察者模式来监听网络连接状态的变化。通过使用观察者模式，我们可以方便地将网络连接状态的变化通知给观察者，实现相应的操作。

EventBus中的观察者模式

EventBus是一个广播/订阅事件总线库，它通过观察者模式来实现事件的发布和订阅。在EventBus中，有以下几个关键角色：

1. 事件：表示一个特定的动作、状态或消息。
2. 发布者：负责发布事件。
3. 订阅者：负责订阅感兴趣的事件。
4. 观察者模式的实现：EventBus使用观察者模式来实现事件的发送和接收。

下面是一个简单的使用EventBus的示例：

1、定义事件类：

public class MessageEvent {
    private String message;

    public MessageEvent(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}
1
2
3
4
5
6
7
8
9
10
11

2、注册订阅者：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 注册订阅者
        EventBus.getDefault().register(this);
    }

    // 订阅事件处理方法
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEvent(MessageEvent event) {
        // 处理接收到的事件
        String message = event.getMessage();
        // ...
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 取消注册订阅者
        EventBus.getDefault().unregister(this);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3、发布事件：

// 在需要的地方发布事件
EventBus.getDefault().post(new MessageEvent("Hello, EventBus!"));
1
2

在上述示例中，MessageEvent表示一个事件，即包含一条消息的事件。MainActivity作为订阅者，通过使用@Subscribe注解的方法onMessageEvent来处理接收到的事件。

在onCreate方法中，我们通过调用EventBus.getDefault().register(this)来注册订阅者。这样，在onMessageEvent方法中对接收到的事件进行处理。

在onDestroy方法中，我们通过调用EventBus.getDefault().unregister(this)来取消注册订阅者，避免可能的内存泄漏。

通过调用EventBus.getDefault().post(new MessageEvent("Hello, EventBus!"))来发布事件。

在观察者模式中，EventBus使用订阅者模式的原理，即订阅者通过注册方法将自己注册到事件总线，然后事件总线在有事件发布时通知所有已注册的订阅者。订阅者通过注解和特定的方法来接收和处理感兴趣的事件。

因此，在EventBus中，观察者模式体现在订阅者通过注册方法将自己注册到事件总线，然后在需要的地方发布事件，事件总线会将事件通知给已注册的订阅者以进行处理。

总结

观察者模式是一种常用的设计模式，它可以实现对象之间的松耦合，提高系统的可维护性和可扩展性。在Android开发中，观察者模式经常用于实现事件总线、多控件协作等功能。通过学习观察者模式，我们可以更好的理解面向对象设计的思想和原则，提高我们的设计水平和编码能力。