1. 定义

定义了对象之间的一对多依赖，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有依赖者都会收到通知并更新

2. 案例

主题对象：Subject

class Subject {
    //容器
    private List<Observer> container = new ArrayList<>();
    // add
    public void addObserver(Observer observer) {
        container.add(observer);
    }
    //remove
    public void remove(Observer observer) {
        container.remove(observer);
    }
    //notify
    public void notifyObserver(Object object) {
        for (Observer observer : container) {
            observer.update(object);
        }
    }
}

观察者：Observer

interface Observer {
    void update(Object object);
}

依赖着：Task1、Task2

class Task1 implements Observer {
    @Override
    public void update(Object object) {
        System.out.println("task1 received: " + object);
    }
}
class Task2 implements Observer {
    @Override
    public void update(Object object) {
        System.out.println("task2 received: " + object);
    }
}

使用

    public static void main(String[] args) {
        Subject subject = new Subject();
        Task1 task1 = new Task1();
        Task2 task2 = new Task2();
        subject.addObserver(task1);
        subject.addObserver(task2);
        subject.notifyObserver("xxxxxx");
        //task1 received: xxxxxx
        //task2 received: xxxxxx
        subject.remove(task1);
        subject.notifyObserver("yyyyy");
        //task2 received: yyyyy
    }

3. 应用场景

当更改一个对象的状态可能需要更改其他对象，并且实际的对象集事先 未知或动态更改时，请使用观察者模式。

4. 优点

1. 符合开闭原则
2. 可以在运行时建立对象之间的关系

   5. JDK&Spring源码中的应用

   JDK:
   java.util.Observable
   Spring:
   org.springframework.context.ApplicationListene