java/android 设计模式学习笔记（2）---观察者模式

　　这篇来讲一下观察者模式，观察者模式在实际项目中使用的也是非常频繁的，它最常用的地方是GUI系统、订阅——发布系统等。因为这个模式的一个重要作用就是解耦，使得它们之间的依赖性更小，甚至做到毫无依赖。以GUI系统来说，应用的UI具有易变性，尤其是前期随着业务的改变或者产品的需求修改，应用界面也经常性变化，但是业务逻辑基本变化不大，此时，GUI系统需要一套机制来应对这种情况，使得UI层与具体的业务逻辑解耦，观察者模式此时就派上用场了。
　　转载请注明出处：http://blog.csdn.net/self_study/article/details/51346849。
　　PS：对技术感兴趣的同鞋加群544645972一起交流。

设计模式总目录

　　java/android 设计模式学习笔记目录

特点

　　观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象状态发生改变时，它的所有依赖者都会收到通知并自动更新。它实现了 Subject 和 Observer 之间的松耦合，Subject只知道观察者实现了 Observer 接口，主题不需要知道具体的类是谁、做了些什么或其他任何细节。任何时候我们都可以增加新的观察者。因为主题唯一依赖的东西是一个实现Observer 接口的对象列表，所以我们可以随时增加观察者，同样的，也可以在任何时候删除观察者，当然更不用去关心观察者的类型，只要实现了Observer接口即可，Subject 最后只会发通知给实现了 Observer 接口的观察者。Subject 和 Observer 之间实现松耦合之后，双方代码的修改都不会影响到另外一方，当然前提是双方得遵守接口的规范（接口隔离原则）。
　　观察者模式使用的场景：

• 关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系；
• 事件多级触发场景；
• 跨系统的消息交换场景，如消息队列、事件总线的处理机制。

EventBus 框架就是一个使用观察者模式的典型例子。

UML类图

　　
　　观察者模式的uml类图如上图所示，一般基本由4个角色构成

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

　　有几点需要注意的是

1. Subject 和 Observer 是一个一对多的关系，也就是说观察者只要实现 Observer 接口并把自己注册到 Subject 中就能够接收到消息事件；
2. Java API有内置的观察者模式类：java.util.Observable 类和 java.util.Observer 接口，这分别对应着 Subject 和 Observer 的角色；
3. 使用 Java API 的观察者模式类，需要注意的是被观察者在调用 notifyObservers() 函数通知观察者之前一定要调用 setChanged() 函数，要不然观察者无法接到通知；
4. 使用 Java API 的缺点也很明显，由于 Observable 是一个类，java 只允许单继承的缺点就导致你如果同时想要获取另一个父类的属性时，你只能选择适配器模式或者是内部类的方式，而且由于 setChanged() 函数为 protected 属性，所以你除非继承 Observable 类，否则你根本无法使用该类的属性，这也违背了设计模式的原则：多用组合，少用继承。

示例与源码

　　观察者模式写法有很多种，只要遵循将被观察者和观察者解耦思想的方法都是可以的，列举三种我在开发中常见的方法，以 firstmoduel 作为 secondmodule1 和 secondmodule2 的父 module ，最后 application 以 secondmoduel1 和secondmodule2 作为父 module，形成一个菱形的关系为例：

Java API

　　使用Java API的写法其实就是使用 java.util.Observable 类和 java.util.Observer 接口，根据 uml 类图构造观察者，我们简单实现一个在 secondmodule2 中通知 secondmodule1有数据源的改变，并且让 secondmodule1 打印出对应日志的功能。因为 secondmodule1 和 secondmodule2 是一个同级关系，所以无法相互调用，只能通过 firstmodule 作为主题使用观察者模式进行通信。
　　Subject 在使用 Java API 时其实就是 Observable 类，所以我们要在 firstmodule 中继承该类实现一个 ConcreteSubject 用来保存所有的观察者，接着在 secondmodule1 中实现 Observer 接口来生成一个观察者，最后在secondmodule2 中通知 firstmodule 数据源改变，最后通过 firstmodule 通知到 secondmodule1 ，代码如下：
firstmoduel/DataObservable.class 中利用单例模式进行观察者的管理和通知：

public class DataObservable extends Observable{

    private static volatile DataObservable instance;
    private DataObservable() {}

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

    public void notifyDataChanged(DataBean data) {
        setChanged();
        notifyObservers(data);
    }
}

firstmoduel/DataBean.class 数据类：

public class DataBean {
    public int temperature;
}

secondmodule1/DataObserver.class 中判断如果为正确的 Observerable 则打印日志：

public class DataObserver implements Observer {
    private static final String TAG = "DataObserver";

    @Override
    public void update(Observable observable, Object data) {
        if (observable instanceof DataObservable){
            if (data instanceof DataBean){
                Log.e(TAG, ((DataBean)data).temperature+"");
            }
        }
    }
}

secondmodule2/DataNotify.class

public class DataNotify {
    public static void notifyDataChanged(){
        DataBean bean = new DataBean();
        bean.temperature = (int) (Math.random() * 40);
        DataObservable.getInstance().notifyDataChanged(bean);
    }
}

最后在 MainActivity 中调用 DataNotify 类的相应方法通知 DataObserver 温度数据变更即可：

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
    DataObservable.getInstance().addObserver(new DataObserver());
}

@Override
protected void onDestroy() {
    super.onDestroy();
    DataObservable.getInstance().deleteObserver(new DataObserver());
}
...
public void onClick(View v) {
    if (v.getId() == R.id.btn_data_change_1){
        DataNotify.notifyDataChanged();
    }
    ...
}

最后能够成功打印出正确日志，也就是实现了 android 中两个同级 module 之间的通信。
　　当然如果觉得麻烦不使用 Java API 的这两个类，自己去实现的话也是完全可以的，而且有时可操纵性会比 Java API 更好一些。

multi Observer

　　有时候我们不一定全部要实现自同一个 Observer 接口，根据实际情况我们可以在完全解耦的情况下将多个 Observer 注册到 Subject 中，并且根据情况只通知到我们想要通知的一个 Observer 中，听起来很乱，其实看一张 uml 图就清楚了：
　　
　　这种方式其实最重要的就是 Subject 这个角色了，他承担了大部分的工作量，我们先实现若干个 Observer 的角色：
firstmodule/IDataListenerOne.class

public interface IDataListenerOne {
    void OnDataChanged(DataBean data);
}

firstmodule/IDataListenerTwo.class

public interface IDataListenerTwo {
    void OnDataChanged(DataBean data);
}

非常简单的几个接口，用来在 secondmodule1 和 secondmodule2 之间进行通信。接着是最重要的 Subject 和 ConcreteSubject 角色：
firstmodule/IMultiDataObservable.class

public interface IMultiDataObservable {
    /**
     * 增加观察者
     */
    void addObserver(Object observer);

    /**
     * 删除观察者
     */
    void deleteObserver(Object observer) throws IllegalArgumentException;

    /**
     * 查找观察者
     */
    ArrayList findObserver(Class clazz);
}

firstmodule/MultiDataObservable.class

public class MultiDataObservable implements IMultiDataObservable {

    private static volatile MultiDataObservable instance;
    private ArrayList