当Android遇上设计模式之观察者(Observer)模式_android observer

1. 观察者模式定义

 观察者模式又称发布-订阅模式，是行为型设计模式的一种，所谓行为型模式就是主要处理类或对象如何交互及如何分配职责。观察者模式经常在项目中被用到，它的定义为：定义对象间一种一对多的依赖关系，每当一个对象改变状态时，则所有依赖于它的对象都会得到通知并自动被更新。观察者模式UML类图如下：

UML类图角色说明：

• Subject：抽象主题，即抽象被观察者，它负责把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者。抽象主题提供了一个接口，可以增加和删除观察者对象。
• ConcreteSubject：具体主题，即具体被观察者，它负责将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
• Observer：抽象观察者，是观察者的抽象类。它定义了一个更新接口，便于主题更改通知时更新自己。
• ConcreteObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

2. 观察者模式实现

 在Android开发中，观察者模式是比较常用的一种设计模式，这种设计模式能够代码分工明确和能够对某种行为或事件进行监听，同时观察者和被观察者之间是抽象耦合，更容易扩展。有过阅读EventBus框架源码的朋友应该知道，这个框架就是基于观察者模式实现的，具体来说是事件总线模式，该模式可以说是观察者模式的一种扩展。我在开发中，通常会在处理网络请求时会用到观察者模式，因此，接下来，我们就基于这个场景来学习下观察者模式的实现。为了便于阅读和减少不必要的代码，这里就不考虑什么MVC、MVP架构了。

（1）Subject，抽象被观察者

/** 抽象主题(抽象被观察者)
 * author : jiangdg
 * date   : 2020/2/1 17:17
 * desc   : 声明新增/删除观察者(订阅者)和向订阅者发送更新消息接口
 * version: 1.0
 */
public interface IDtmOperator {
    // 增加订阅者,attach
    public void addObserver(String key, IDtmObserver observer);
    // 删除订阅者,detach
    public void removeObserver(String key);
    // 通知订阅者更新消息, notify
    public void retDtmOperator(String type, Bean bean);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（2）ConcreteSubject，具体被观察者

/** 具体主题类
 * author : jiangdg
 * date   : 2020/2/1 17:23
 * desc   : 单例模式创建DownloadOperator实例
 *      封装了观察者注册、注销、网络请求方法。持有观察者对象的引用。
 * version: 1.0
 */
public class DownloadOperator implements IDtmOperator {
    public static final String LOGINACK = "loginAck";
    public static final String DOWNLOADACK = "downloadAck";
    // 观察者列表
    private Map<String, IDtmObserver> mObservers = new ConcurrentHashMap<>();
    private static DownloadOperator instance;

    private DownloadOperator() {
    }

    public static DownloadOperator getInstance() {
        if(instance == null) {
            synchronized (DownloadOperator.class) {
                if(instance == null) {
                    instance = new DownloadOperator();
                }
            }
        }
        return instance;
    }

    @Override
    public void addObserver(String key, IDtmObserver observer) {
        if(key==null || observer==null) {
            return;
        }
        mObservers.put(key, observer);
    }

    @Override
    public void removeObserver(String key) {
        if(key == null) {
            return;
        }
        mObservers.remove(key);
    }

    @Override
    public void retDtmOperator(String type, Bean bean) {
        // 遍历观察者，将请求结果通知给观察者
        // 通过调用每个观察者的onReceived方法实现
        for (Map.Entry<String, IDtmObserver> entry : mObservers.entrySet()) {
            entry.getValue().onReceived(type, bean);
        }
    }
    
	//---------------------------------------------------------------------------
    
    /** 发起登录网络请求
     * 
     * @param account 账户名
     * @param password 密码
     */
    public synchronized void login(String account, String password) {
        // 发起登录请求
        ...
        // 将结果通知给订阅者
        // LoginAckBean实体类是Bean的子类，记录了登录响应数据
        retDtmOperator(LOGINACK, LoginAckBean);
    }
    
    /** 
     * 发起图片下载网络请求
     */
    public synchronized void downloadImage() {
        // 发起下载请求
        ...
        // 将响应结果通知给订阅者
        // DownloadAckBean实体类是Bean的子类，记录了下载响应数据
        retDtmOperator(DOWNLOADACK, DownloadAckBean);
    }
}
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

 实际上，为了使设计的代码更加符合设计模式中的单一职责原则，我们可以根据业务创建多个IDtmOperator的子类，每个子类封装类似的业务，比如有关账户管理的功能(登录、退出、切换账户等)可以将这类请求封装在AccountDtmOperator类，有关文件上传、下载等网络请求可以将这类请求封装在FileDtmOperator类等等，当然，AccountDtmOperator、FileDtmOperator等这些类均继承于IDtmOperator。

（3）Observer，抽象观察者

/** 抽象观察者
 * author : jiangdg
 * date   : 2020/1/31 10:23
 * desc   : 声明一个更新接口，所有的具体观察者需要实现该接口
 * 便于网络请求完毕后，具体观察者根据请求结果更新自己的状态
 * version: 1.0
 */
public interface IDtmObserver {
	void onReceived(String msgType, Bean bean);
}
1
2
3
4
5
6
7
8
9
10

（4）ConcreteObserver，具体观察者

• 登录界面

/** 登录界面
 * author : jiangdg
 * date   : 2020/2/1 17:03
 * desc   : 订阅DownloadOperator
 * version: 1.0
 */
public class LoginActivity extends AppCompatActivity implements IDtmObserver {

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

    @Override
    protected void onResume() {
        super.onResume();
        // 订阅DownloadOperator
        DownloadOperator.getInstance()
            .addObserver(LoginActivity.class.getSimpleName(), LoginActivity.this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 取消订阅DownloadOperator
        DownloadOperator.getInstance()
            .removeObserver(LoginActivity.class.getSimpleName());
    }

    /** 发起账户登录请求
     *
     * @param view 登录button
     */
    public void onLoginClick(View view) {
        DownloadOperator.getInstance().login("jiangdongguo", "888888");
    }

    @Override
    public void onReceived(String msgType, Bean bean) {
        // 接收到DownloadOperator发送的通知
        if(msgType.equalWith(DownloadOperator.LOGINACK)) {
            // 登录请求网络响应数据
            // 然后根据响应数据更新登录界面状态
            if(bean instanceof LoginAckBean) {
                LoginAckBean loginAckBean = (LoginAckBean)bean;
                ...
            }
        }
    }
}
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

• 下载网络图片界面

/** 图片加载界面
 * author : jiangdg
 * date   : 2020/2/1 17:03
 * desc   : 订阅DownloadOperator
 * version: 1.0
 */
public class DownloadActivity extends AppCompatActivity implements IDtmObserver {

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

    @Override
    protected void onResume() {
        super.onResume();
        // 订阅DownloadOperator
        DownloadOperator.getInstance()
            .addObserver(DownloadActivity.class.getSimpleName(), 
                         DownloadActivity.this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 取消订阅DownloadOperator
        DownloadOperator.getInstance()
            .removeObserver(DownloadActivity.class.getSimpleName());
    }

    /** 发起下载请求
     *
     * @param view 下载button
     */
    public void onDownloadClick(View view) {
        DownloadOperator.getInstance().downloadImage();
    }

    @Override
    public void onReceived(String msgType, Bean bean) {
        // 接收到DownloadOperator发送的通知
        if(msgType.equalWith(DownloadOperator.DOWNLOADACK)) {
            // 获取图片下载响应数据
            if(bean instanceof DownloadAckBean) {
                DownloadAckBean loginAckBean = (DownloadAckBean)bean;
                ...
            }
        }
    }
}
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

 从上面的代码可知，DownloadOperator有两个订阅者，即LoginActivity和DownloadActivity，当DownloadOperator完成相应的网络请求后，就会将响应数据通知给它们，而对于它们来说，只需要在其onReceived方法中获取通知数据即可。

3. 观察者模式使用场景

3.1 优点

• 观察者与被观察者之间是抽象耦合，更容易扩展；
• 方便建立一套触发机制

3.2 缺点

 由于观察者模式是一对多形式，即一个被观察者被多个观察者订阅，当观察者非常多的情况下，开发、调试时会比较复杂，可能会影响开发效率。另外，消息的通知一般是顺序执行的，如果一个观察者出现卡顿，则会影响整体的执行效率，因此在这种情况下，一般会采用异步方式。

3.3 使用场景

• 某个行为或事件监听；
• 事件多级触发场景；
• 跨系统的消息交换场景，如消息队列、事件总线的处理机制。