观察者模式

简述：

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

观察者模式适用场景

当一个抽象模型有两个方面，其中一个方面依赖于另一个方面。
当对一个对象的改变需要同时改变其它对象，而不知道具体有多少个对象待改变。
当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换句话说，你不希望这些对象是紧密耦合的，做到（松耦合，高内聚）

下面通过一个案例：传入一个状态，并执行相关的业务操作

代码实例：

定义一个抽象观察者类

public interface Observer {

    /**
     * 当观察者接收到状态时，执行update方法的业务逻辑
     * @param state
     */
    void update(String state);
}

实现两个具体的观察者

 ObserverA与ObserverB

public class ObserverA implements Observer{

    @Override
    public void update(String state) {
        System.out.println("ObserverA接收到状态："+state + ",实行相关的业务逻辑");
    }
}

public class ObserverB implements Observer{

    @Override
    public void update(String state) {
        System.out.println("ObserverB接收到状态："+state+",执行相关的业务逻辑");
    }
}

 定义抽象的主题，用于注册所有的观察者

public abstract class Subject {

    /**
     * 观察的集合
     */
    private List<Observer> list = new ArrayList<>();

    /**
     * 添加观察者对象（注册）
     * @param observer
     */
    public void addObserver(Observer observer){
        list.add(observer);
    }

    /**
     * 移除观察者
     * @param observer
     */
    public void removeObserver(Observer observer){
        list.remove(observer);
    }

    /**
     * 通知所有的观察者，
     * 并且观察者会依据这个通知执行自身相关的业务逻辑
     *
     * 其实就是调用所有观察者的具体行为
     * @param state
     */
    protected void notifyObserver(String state){
        for (Observer observer : list) {
            observer.update(state);
        }
    }
}

具体的主题，有一个独有的change()方法

public class SubjectA extends Subject{

    /**
     * 主题发生变化时，执行此方法
     */
    public void change(String state){
        notifyObserver(state);
    }
}

 测试(Main)类

public class Main {

    public static void main(String[] args) {
        //创建主题
        SubjectA a = new SubjectA();
        //创建观察者
        Observer o1 = new ObserverA();
        Observer o2 = new ObserverB();
        //注册所有的观察者
        a.addObserver(o1);
        a.addObserver(o2);

        a.change("create");
    }
}