观察者模式

一句话定义

定义对象间一对多的依赖关系，状态发生改变所有依赖的对象都会收到通知并自动更新。

使用场景

1. 事件多级触发
2. 一个对象改变引起一系列改变发生。

实现要点

1. 将观察者和被观察者几乎完全解耦，弱化依赖关系
2. 避免循环调用

情景假设

简单的观察模式，被观察者绑定多个观察者，被观察者发出通知，通知所有观察者发生改变。

实现步骤

1. 创建抽象观察者类，提供自我更新方法接口

/**
 * 抽象观察者
 * 定义一个更新接口，被观察者更改时通知更新自己
 *
 * @author fengzhen
 * @version 1.0, 2017/2/9
 */
public abstract class Observer {
    /**
     * 更新方法
     */
    public abstract void update(String context);
}

2. 创建抽象主题类，创建存储观察者集合，提供添加、删除观察者方法与发出通知接口

/**
 * 抽象主题，即被观察者。
 * 将所有观察者的引用保存到集合，并提供添加、删除与通知观察者方法
 *
 * @author fengzhen
 * @version 1.0, 2017/2/9
 */
public abstract class Subject {
    // 所有观察者
    protected List<Observer> observers = new ArrayList<>();

    /**
     * 添加新的观察者
     * @param observer 新增观察者
     */
    public void attach(Observer observer){
        observers.add(observer);
    }

    /**
     * 删除绑定的观察者
     * @param observer 移除观察者
     */
    public void detach(Observer observer){
        if (observers.contains(observer)) {
            observers.remove(observer);
        }
    }

    /**
     * 通知方法，通知所有观察者
     * @param context 通知传递信息
     */
    public abstract void notifyObservers(String context);
}

3. 创建具体观察者， 具体自我更新

/**
 * 具体观察者
 * 重写更新方法，接收通知更新自己
 *
 * @author fengzhen
 * @version 1.0, 2017/2/9
 */
public class ConcreteObserver extends Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String context) {
        Log.i("info", "update: ==++ " + name + "接收到更新: " + context);
    }
}

4. 创建具体主题类，发出更新通知

/**
 * 具体主题
 * 通知更新
 *
 * @author fengzhen
 * @version 1.0, 2017/2/9
 */
public class ConcreteSubject extends Subject {
    @Override
    public void notifyObservers(String context) {
        for (Observer o :
                observers) {
            o.update(context);
        }
    }
}

5.具体实现

        // 观察者模式
        // 被观察者
        ConcreteSubject observable = new ConcreteSubject();
        // 观察者
        ConcreteObserver observerA = new ConcreteObserver("A");
        ConcreteObserver observerB = new ConcreteObserver("B");
        ConcreteObserver observerC = new ConcreteObserver("C");
        // 绑定观察者
        observable.attach(observerA);
        observable.attach(observerB);
        observable.attach(observerC);
        // 假设发生改变，进行通知
        observable.notifyObservers("下雨了！！！");