当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);
}

(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);
    }
}

 实际上,为了使设计的代码更加符合设计模式中的单一职责原则,我们可以根据业务创建多个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);
}

(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;
                ...
            }
        }
    }
}
  • 下载网络图片界面

/** 图片加载界面
 * 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;
                ...
            }
        }
    }
}

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

3. 观察者模式使用场景

3.1 优点

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

3.2 缺点

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

3.3 使用场景

  • 某个行为或事件监听;
  • 事件多级触发场景;
  • 跨系统的消息交换场景,如消息队列、事件总线的处理机制。
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 黑客帝国 设计师:白松林 返回首页