观察者模式详解附有代码案例分析（包含观察者模式使用JDK方式实现）

一、观察者模式的概念与角色

（一）、观察者模式的概念

​ 观察者模式又叫做发布-订阅模式。定义一种一对多的依赖关系，一个主题对象可被多个观察者对象同时监听，使得每当主题对象状态变化时，所有依赖于它的对象都会得到通知并被自动更新。属于行为型模式。

​ 观察者模式的核心是将被观察者与观察者解耦，以类似于消息/广播发送的机制联动两者。使被观察者的变动能通知到感兴趣的观察者们，从而做出相应的响应。

（二）、观察者的角色

​ 1、抽象主题（Subject）：指被观察的对象（Observable）。该角色是一个抽象类或接口，定义了增加、删除、通知观察者对象的方法。

​ 2、具体主题（ConcreteSubject）：具体被观察者，当其内状态变化时，会通知已注册的观察者。

​ 3、抽象观察者（Observer）：定义了响应通知的更新方法。

​ 4、具体观察者（ConcreteObserver）：在得到状态更新时，会自动做出响应。

二、观察者模式的应用场景

​ 1、当一个抽象模型包含两个方面内容，其中一个方面依赖于另一个方面。

​ 2、其他一个或多个对象的变化依赖于另一个对象的变化。

​ 3、实现类似广播机制的功能，无需知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接受该广播。

​ 4、多层级嵌套使用，形成一种链式触发机制，使得事件跨域（跨越两种观察者类型）通知。

三、观察者模式的通用写法

抽象主题：Subject

public interface Subject<E> {

    boolean attach(Observer<E> observer);

    boolean detach(Observer<E> observer);

    void notify(E event);

}

抽象观察者：Observer

public interface Observer<E> {

    void update(E event);

}

具体主题：ConcreteSubject

public class ConcreteSubject<E> implements Subject<E> {

    private List<Observer<E>> observers = new ArrayList<Observer<E>>();

    @Override
    public boolean attach(Observer<E> observer) {
        return !this.observers.contains(observer) && this.observers.add(observer);
    }

    @Override
    public boolean detach(Observer<E> observer) {
        return this.observers.remove(observer);
    }

    @Override
    public void notify(E event) {
        for (Observer<E> observer : this.observers) {
            observer.update(event);
        }
    }

}

具体观察者：ConcreteObserver

public class ConcreteObserver<E> implements Observer<E> {

    @Override
    public void update(E event) {
        System.out.println("receive event: " + event);
    }

}

测试类：

public class Test {

    public static void main(String[] args) {
        // 被观察者
        Subject<String> observable = new ConcreteSubject<String>();
        // 观察者
        Observer<String> observer = new ConcreteObserver<String>();
        // 注册
        observable.attach(observer);
        // 通知
        observable.notify("hello");
    }

}

四、观察者模式的JDK代码示例——不建议使用（已过时）

Question：

public class Question {

    private String userName;
    private String content;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

}

Teacher：

public class Teacher implements Observer {

    private String name;

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

    public void update(Observable o, Object arg) {
        Web web = (Web)o;
        Question question = (Question)arg;
        System.out.println("======================");
        System.out.println(name + "老师，你好！\n" +
                "您收到了一个来自" + web.getName() + "的提问，希望您解答。问题内容如下：\n" +
                question.getContent() + "\n" +
                "提问者：" + question.getUserName());
    }
}

Web：

public class Web extends Observable {

    private String name = "提问网站";
    private static final Web web = new Web();

    private Web() {}

    public static Web getInstance(){
        return web;
    }

    public String getName() {
        return name;
    }

    public void publishQuestion(Question question){
        System.out.println(question.getUserName() + "在" + this.name + "上提交了一个问题。");
        setChanged();
        notifyObservers(question);
    }
}

测试类：

public class Test {

    public static void main(String[] args) {
        Web web = Web.getInstance();
        Teacher tom = new Teacher("A");
        Teacher jerry = new Teacher("B");

        web.addObserver(tom);
        web.addObserver(jerry);

        //用户行为
        Question question = new Question();
        question.setUserName("张三");
        question.setContent("观察者模式适用于哪些场景？");

        web.publishQuestion(question);
    }

}

五、观察者模式的优缺点

（一）、优点

​ 1、观察者和被观察者是松耦合（抽象耦合）的，符合依赖倒置原则。

​ 2、分离了表示层（观察者）和数据逻辑层（被观察者），并且建立了一套触发机制，使得数据的变化可以响应到多个表示层上。

​ 3、实现了一对多的通讯机制，支持事件注册机制，支持兴趣分发机制，当被观察者触发事件时，只有感兴趣的观察者可以接收到通知。

（二）、缺点

​ 1、如果观察者数量过多，则事件通知会耗时较长。

​ 2、事件通知呈线性关系，如果其中一个观察者处理事件卡壳，会影响后续的观察者接收该事件。

​ 3、如果观察者和被观察者之间存在循环依赖，则可能造成两者之间的循环调用，倒置系统崩溃。

六、设计模式的相关博客文章链接

1、七大设计原则的简单解释（包含合成复用原则），简单理解、快速入门，具备案例代码

链接: 七大设计原则的简单解释（包含合成复用原则），简单理解、快速入门，具备案例代码.

2、工厂模式详解附有代码案例分析（简单工厂，工厂方法，抽象工厂）

链接: 工厂模式详解附有代码案例分析（简单工厂，工厂方法，抽象工厂）.

3、单例模式详解及代码案例与应用场景（饿汉式单例模式、懒汉式单例模式、注册式单例模式）

链接: 单例模式详解及代码案例与应用场景（饿汉式单例模式、懒汉式单例模式、注册式单例模式）.

4、原型模式详解附有代码案例分析（浅克隆和深克隆的相关解析）

链接: 原型模式详解附有代码案例分析（浅克隆和深克隆的相关解析）.

5、建造者模式详解附有代码案例分析（包含建造者模式与工厂模式的区别分析）

链接: 建造者模式详解附有代码案例分析（包含建造者模式与工厂模式的区别分析）.

6、门面模式详解附有代码案例分析

链接: 门面模式详解附有代码案例分析.

7、装饰者模式详解附有代码案例分析

链接: 装饰者模式详解附有代码案例分析.

8、享元模式详解附有代码案例分析（包含享元模式的源码应用分析——String中的享元模式应用、Integer中的享元模式应用）

链接: 享元模式详解附有代码案例分析（包含享元模式的源码应用分析——String中的享元模式应用、Integer中的享元模式应用）.

9、组合模式详解附有代码案例分析（包含透明组合模式、安全组合模式的代码示例）

链接: 组合模式详解附有代码案例分析（包含透明组合模式、安全组合模式的代码示例）.

10、桥接模式详解附有代码案例分析

链接: 桥接模式详解附有代码案例分析.

11、适配器模式详解附有代码案例分析（包含类适配器、对象适配器以及接口适配器的代码示例）

链接: 适配器模式详解附有代码案例分析（包含类适配器、对象适配器以及接口适配器的代码示例）.

12、委派模式详解附有代码案例分析（包含委派模式在JDK中的源码示例解析）

链接: 委派模式详解附有代码案例分析（包含委派模式在JDK中的源码示例解析）.

13、模板方法模式详解附有代码案例分析（包含模板方法模式重构JDBC操作业务代码示例）

链接: 模板方法模式详解附有代码案例分析（包含模板方法模式重构JDBC操作业务代码示例）.

14、策略模式详解附有代码案例分析（包含策略模式在源码中的应用以及代码示例）

链接: 策略模式详解附有代码案例分析（包含策略模式在源码中的应用以及代码示例）.

15、责任链模式详解附有代码案例分析（包含责任链模式与建造者模式的结合代码案例）

链接: 责任链模式详解附有代码案例分析（包含责任链模式与建造者模式的结合代码案例）.

16、迭代器模式详解附有代码案例分析（包含迭代器模式的源码应用分析）

链接: 迭代器模式详解附有代码案例分析（包含迭代器模式的源码应用分析）.

17、命令模式详解附有代码案例分析（包含命令模式的源码应用分析）

链接: 命令模式详解附有代码案例分析（包含命令模式的源码应用分析）.

18、状态模式详解附有代码案例分析（包含状态模式与其他相关设计模式的对比）

链接: 状态模式详解附有代码案例分析（包含状态模式与其他相关设计模式的对比）.

19、备忘录模式详解附有代码案例分析

链接: 备忘录模式详解附有代码案例分析.

20、中介者模式详解附有代码案例分析

链接: 中介者模式详解附有代码案例分析.

21、解释器模式详解附有代码案例分析

链接: 解释器模式详解附有代码案例分析.

22、观察者模式详解附有代码案例分析（包含观察者模式使用JDK方式实现）

链接: 观察者模式详解附有代码案例分析（包含观察者模式使用JDK方式实现）.

23、访问者模式详解附有代码案例分析

链接: 访问者模式详解附有代码案例分析.