观察者模式

什么是观察者模式

有人这么说

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。

这个主题对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己。

还有人这么说

观察者模式是关于多个对象想知道一个对象中数据变化情况的一种成熟模式。观察者模式中有一个称作“主题”的对象和若干个称作“观察者”的对象，“主题”和“观察者”之间是一种一对多的依赖关系。

当“主题”的状态发生变化时，所有“观察者”都得到通知。

日常生活中，最容易理解的例子就是微信公众号。我们用微信订阅的微信公共号就是这里所说的主题，而我们 每一个关注这个微信号的人就是这里的观察者。公众号每天有更新，所有订阅者都会收到。

观察者模式类图

应用场景

此种模式通常被用来实现事件处理系统。

观察者模式组成

从定义可以看到，该模式必须包含两个角色：观察者和被观察对象（主题）。

从代码实现的角度，我们又可以分为以下四种角色：

• 抽象主题角色： 把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

• 抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

• 具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

• 具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

实现观察者模式

我们就按照上面提到的4中角色，依次实现：

• 抽象主题角色

主题接口规定了具体主题需要实现的添加，删除及通知观察者更新数据的方法

/**
 * 抽象主题，被观察者
 *
 */
public interface Subject {
    /**
     * 添加观察者
     * 
     * @param observer
     */
    void addObserver(Observer observer);

    /**
     * 移除指定的观察者
     * 
     * @param observer
     */
    void removeObserver(Observer observer);

    /**
     * 移除所有的观察者
     */
    void removeAll();

    /**
     * data 是要通知给观察者的数据 因为Object是所有类的父类，可以使用多态，当然 你也可以使用 泛型
     * 
     * @param data
     */
    void notifyAllObserver(Object data);

    /**
     * 单独 通知某一个观察者
     * 
     * @param observer
     * @param data
     *            data 是要通知给观察者的数据 因为Object是所有类的父类，可以使用多态，当然 你也可以使用 泛型
     */
    void notify(Observer observer, Object data);

}

• 抽象观察者角色

观察者接口规定了具体观察者用来更新数据的方法

/**
 * 抽象观察者接口
 */
public interface Observer {
    /**
     * 
     * @param subject 被观察者
     * @param data    被观察者传递给观察者的 数据
     */
    void update(Subject subject,Object data);
}

• 具体主题角色

public class ConcreteSubject implements Subject {

    //观察者集合，用于管理所有的观察者
    List<Observer> mList = new ArrayList<>();

    @Override
    public void addObserver(Observer observer) {
        // TODO Auto-generated method stub
        // 确保相同的观察者只含有一个
        if (observer == null) {
            throw new NullPointerException("observer == null");
        }

        if (!mList.contains(observer)) {
            mList.add(observer);
        }
    }

    @Override
    public void removeObserver(Observer observer) {
        // TODO Auto-generated method stub
        mList.remove(observer);
    }

    @Override
    public void removeAll() {
        // TODO Auto-generated method stub
        mList.clear();
    }

    @Override
    public void notifyAllObserver(Object data) {
        // TODO Auto-generated method stub
        for (Observer observer : mList) {
            observer.update(this, data);
        }
    }

    @Override
    public void notify(Observer observer, Object data) {
        // TODO Auto-generated method stub
        if (observer != null) {
            observer.update(this, data);
        }
    }

}

• 具体的观察者角色

这里我们可以定义多个具体的观察者角色

观察者One

public class ObserverOne implements Observer {

    @Override
    public void update(Subject subject, Object data) {
        // TODO Auto-generated method stub
        System.err
                .println("the messge from subject to-->" + this.getClass().getName() + "<---is " + data.toString());
    }

}

观察者Two

public class ObserverTwo implements Observer {

    @Override
    public void update(Subject subject, Object data) {
        // TODO Auto-generated method stub
        System.err
        .println("the messge from subject to-->" + this.getClass().getName() + "<---is " + data.toString());
    }

}

观察者Three

public class ObserverThree implements Observer {

    @Override
    public void update(Subject subject, Object data) {
        // TODO Auto-generated method stub
        System.err
        .println("the messge from subject to-->" + this.getClass().getName() + "<---is " + data.toString());
    }

}

好了，到了这里我们就完成了所有角色的定义。写个方法测试一下：

• 测试类

public class TestObservePattern {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ConcreteSubject concreteSubject = new ConcreteSubject();
        ObserverOne observerOne=new ObserverOne();
        ObserverTwo observerTwo=new ObserverTwo();
        ObserverThree observerThree=new ObserverThree();

        concreteSubject.addObserver(observerOne);
        concreteSubject.addObserver(observerTwo);
        concreteSubject.addObserver(observerThree);


        //通知所有的观察者
        concreteSubject.notifyAllObserver("wake up,wake up");
        //通知某个特定的观察者OberverTwo
        concreteSubject.notify(observerTwo, "Specila msg  for you");
        //观察者ObserveThree 决定不再订阅主题
        concreteSubject.removeObserver(observerThree);
        //通知所有的观察者
        concreteSubject.notifyAllObserver("new Message come ");
    }

}

运行程序后输入日志如下：

通过日志可以看到：

• 主题内容更新后，所有的观察者将接收到更新结果。
• 某个特定的观察者取消对主题的订阅后，自身不再接收到主题的更新，而且也不影响主题的实现。

和设置监听器机制的区别

初次看到观察者模式的定义时，感觉这种套路似曾相识。思前想后才发现，观察者模式其实和平时给Button设置点击事件的实现方式有些类似。都是作为主题（Button）发生变化（被用户点击），观察者（OnClickListener）接收到通知，并作出响应（onClick回调方法执行）。

看到很多地方将观察者模式和设置监听器模式（机制）归为同一种模式，个人感觉是不太恰当的。

• 首先，观察者模式中，抽象观察者角色以接口的形式存在，注定了所有的具体观察者角色实现更新（如此处的update）时，方法是唯一的，只有update。 而设置监听器机制中，为主题（事件源）设置不同的观察者（监听器），主题（事件源）发生变化后，观察者所需实现的方法也是不唯一的。我们这里以Button的click事件和Longclick事件为例：

可以看到，不同的观察者所需实现的方法是完全不一样的。

• 其次，观察者某事中，被观察者发生变化时，所有观察者将被动接受通知 。所有具体的观察者根本无法区分到底是发生了怎样的变化。当然，也可以通过在主题发送通知时根据不同的状态分别通知不同的观察者。但是，这样就使得被观察和观察者之间有了联系，这是不好的思路。而监听器机制，通过设置不同的监听器（即不同的观察者），便解决了这个问题。

所以，监听器机制相较于严格的观察者模式还是有区别的。

观察者模式优缺点

以下内容摘抄自网络

观察者模式有以下的优点：

第一、观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表，每一个具体观察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。如果被观察者和观察者都被扔到一起，那么这个对象必然跨越抽象化和具体化层次。

第二、观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知，

观察者模式有下面的缺点：

第一、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

第二、如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察者模式是要特别注意这一点。

第三、如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。

第四、虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。

---