设计模式之观察者模式

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

Subject类，抽象通知者，一般用一个抽象类或接口实现。

interface ITongZhiZhe {

    void addObserver(IObserver observer);
    void removeObserver(IObserver observer);
    void notifyObserver();
    void setState(String state);
    String getState();
}

Observer类，抽象观察者，一般用一个抽象类或接口实现，在得到通知者通知时更新自己。更新接口通常包含一个update()方法，这个方法叫做更新方法。

interface IObserver {

    void update();
}

ConcreteSubject类，具体通知者，将有关状态存入具体观察者对象；当通知者内部状态改变时，给所有登记过的观察者发出通知。

public class QianTaiTongZhiZhe implements ITongZhiZhe {

    private List<IObserver> mObservers = new ArrayList<IObserver>();
    private String mState;

    @Override
    public void addObserver(IObserver observer) {
        mObservers.add(observer);
    }

    @Override
    public void removeObserver(IObserver observer) {
        mObservers.remove(observer);
    }

    @Override
    public void notifyObserver() {
        for (IObserver item : mObservers) {
            item.update();
        }
    }

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

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

}

ConcreteObserver类，具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与通知者的状态相协调。具体观察者可以保存一个指向具体通知者对象的引用。

public class NBAObserver implements IObserver {

    private String mName;
    private ITongZhiZhe mTongzhizhe;

    public NBAObserver(String name, ITongZhiZhe tongzhizhe) {
        mName = name;
        mTongzhizhe = tongzhizhe;
    }

    @Override
    public void update() {
        System.out.println(mName + mTongzhizhe.getState());
    }

}

public class StockObserver implements IObserver {

    private String mName;
    private ITongZhiZhe mTongzhizhe;

    public StockObserver(String name, ITongZhiZhe tongzhizhe) {
        mName = name;
        mTongzhizhe = tongzhizhe;
    }

    @Override
    public void update() {
        System.out.println(mName + mTongzhizhe.getState());
    }

}

调用：

QianTaiTongZhiZhe tongZhiZhe = new QianTaiTongZhiZhe();
StockObserver stockObserver = new StockObserver("张三", tongZhiZhe);
NBAObserver nbaObserver = new NBAObserver("李四", tongZhiZhe);
tongZhiZhe.addObserver(stockObserver);
tongZhiZhe.addObserver(nbaObserver);
tongZhiZhe.removeObserver(stockObserver);

tongZhiZhe.setState("老板来了");

tongZhiZhe.notifyObserver();

输出结果：

李四，老板来了

什么时候使用观察者模式：

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

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

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