观察者模式

模式定义

观察者模式又叫做发布-订阅（Publish/Subscribe）模式。

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

模式结构

模式实现

Subject : 主题类，保存所有订阅此主题的观察者，观察者的数量是任意的。定义添加观察者（Attach）和删除观察者 (Detach) 的接口。

abstract class Subject {
    protected String name;
    protected String state;
    protected List<Observer> observers = new ArrayList<Observer>();

    public abstract String getState();    
    public abstract void setState(String state);
    public abstract void Notify();

    public Subject(String name) {
        this.name = name;
    }
    
    public void Attach(Observer observer) {
        observers.add(observer);
    }
    
    public void Detach(Observer observer) {
        observers.remove(observer);
    }
}

ConcreteSubject : 具体主题类，存储对于这个主题感兴趣的所有观察者。当内部状态发生变化时，应通知所有登记的观察者 (Notify)。

class ConcreteSubject extends Subject {
    public ConcreteSubject(String name) {
        super(name);
    }

    @Override
    public String getState() {
        return state;
    }

    @Override
    public void setState(String state) {
        this.state = state;
    }

    @Override
    public void Notify() {
        System.out.println("======= " + this.name + "主题发布新消息 =======");
        for (Observer observer : observers) {
            observer.Update();
        }
    }
}

Observer : 观察者类，定义更新接口 (Update)，当收到 Subject 的通知时，Observer 需要同步更新信息。

abstract class Observer {
    protected String name;
    protected Subject subject;
    public Observer(String name, Subject subject) {//持有被观察者对象
        this.name = name;
        this.subject = subject;
    }
    public abstract void Update();//主要方法
}

ConcreteObserver : 具体观察者类，实现 Observer 的更新接口 (Update)，以便和 Subject 同步状态信息。

class ConcreteObserver extends Observer {
    private String state;
    public ConcreteObserver(String name, Subject subject) {
        super(name, subject);
    }

    @Override
    public void Update() {
        state = subject.getState();
        System.out.println(this.name + "收到当前状态：" + state);
    }
}

测试代码

public class ObserverPattern {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject("天气");    
        ConcreteObserver observer1 = new ConcreteObserver("张三", subject);
        ConcreteObserver observer2 = new ConcreteObserver("李四", subject);
        ConcreteObserver observer3 = new ConcreteObserver("王五", subject);

        subject.Attach(observer1);
        subject.Attach(observer2);
        subject.Attach(observer3);    

        subject.setState("今天下雨");

        subject.Notify();

        subject.Detach(observer2);

        subject.setState("明天天晴");

        subject.Notify();

    }
}

输出：

======= 天气主题发布新消息 =======

张三收到当前状态：今天下雨

李四收到当前状态：今天下雨

王五收到当前状态：今天下雨

======= 天气主题发布新消息 =======

张三收到当前状态：明天天晴

王五收到当前状态：明天天晴

使用场景

1. 当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象需要改变时，应该考虑使用观察者模式。
2. 一个抽象模型有两个方面，其中一方面依赖于另一方面，这时候观察者模式可以将这两者封装在独立的对象中使它们各自独立的改变和复用。

观察者模式特点

用观察者模式的动机是什么呢？

将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。而观察者模式的关键对象时主体Subject和观察者Observer，一个Subject可以有任意数目的依赖它的Observer，一旦Subject的状态发生了改变，所有的Observer都可以得到通知。Subject发出通知时并不需要知道谁是它的观察者，也就是说，具体观察者是谁，它根本不需要知道。而任何一个具体观察者不知道也不需要知道其他观察者的存在。

那么什么时候考虑使用观察者模式呢？

当一个对象的改变需要同时改变其他对象的时候。而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。

一个抽象模型有两个方面，其中一方面依赖于另一方面，这时候观察者模式可以将这两者封装在独立的对象中使它们各自独立的改变和复用。

观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。

所以其实上面的Observer也是可以使用接口来做的：

interface Observer {
	void update();
}

观察者模式的不足

1. 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2. 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。