设计模式之观察者模式

1. 观察者模式概述

我们不断提到软件系统解耦的重要性，当减少依赖关系时，我们可以扩展、开发和测试不同的模块，而无需了解其他模块的实现，只需要知道它们实现的抽象。尽管如此，在实践中，模块是需要协同工作的，一个对象往往能够知道另一个对象的变化。例如某种商品的物价上涨时会导致部分商家高兴，而消费者会伤心。

观察者模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新，这种模式有时又被称为发布-订阅模式、模型视图模式。

观察者模式的优点：

• 降低了目标和观察者之间的耦合关系，两者直接是抽象的耦合关系，符合依赖倒置原则。
• 目标与观察者建立了一种触发机制。

观察者模式的缺点：

• 目标与观察者之间的依赖关系并没有完全解耦，而且有可能出现循环引用。
• 当观察者很多的时候，通知的发布会花费很长时间，影响程序的效率。

观察者模式类图如下：

• 抽象主题(Subject)：也叫抽象目标类，它提供一个用于保存观察者对象的容器，可以增加、删除观察者，以及通知所有观察者的抽象方法。
• 具体主题(ConcreteSubject)：也叫具体目标类，它实现抽象目标中的通知方法，当主题内部状态发生改变时，通知所有注册了的观察者对象。
• 抽象观察者(Observer)：它是一个抽象类或接口，包含一个响应方法用来对主题内部状态发生改变时做出对应的反应。
• 具体观察者(ConcreteObserver)：实现抽象观察者中定义的抽象方法，以便在得到目标的更改时及时做出自己对应的反应。

2. 观察者模式案例

模拟观察者模式，当主题变更时，不同的观察者输出自己观察到主题发生变化。

2.1 抽象观察者

新建一个抽象观察者接口，定义观察者的反应行为方法，接口名称为Observer，内容如下：

public interface Observer {

    /**
     * 观察者的反应
     */
    void reponse();
}

2.2 具体观察者

新建具体观察者1实现抽象观察者接口，类名称为ConcreteObserver1，内容如下：

public class ConcreteObserver1 implements Observer {
    
    @Override
    public void reponse() {
        System.out.println("我是观察者1，观察到主题的变化......");
    }
    
}

类似的新建具体观察者2实现抽象观察者接口，类名称为ConcreteObserver2，内容如下：

public class ConcreteObserver2 implements Observer {
    
    @Override
    public void reponse() {
        System.out.println("我是观察者2，观察到主题的变化......");
    }
    
}

2.3 抽象主题

新建抽象主题类用来定义主题的行为，包括注册观察者、注销观察者、发布通知，类名称为Subject，内容如下：

public abstract class Subject {

    /**
     * 订阅列表
     */
    protected List<Observer> observers = new ArrayList<>();

    /**
     * 注册观察者
     */
    protected void attach(Observer observer){
        observers.add(observer);
    }

    /**
     * 注销观察者
     */
    protected void detach(Observer observer){
        observers.remove(observer);
    }

    /**
     * 通知观察者
     */
    protected abstract void notifyObserver();
}

2.4 具体主题

新建具体主题类继承抽象主题类，完成发布通知方法，类名称为ConcreteSubject，内容如下：

public class ConcreteSubject extends Subject {

    @Override
    protected void notifyObserver() {
        for (Observer observer : observers) {
            observer.reponse();
        }
    }
}

2.5 客户端

新建客户端进行测试，内容如下：

public class Client {
    public static void main(String[] args) {
        // 创建一个主题
        Subject subject = new ConcreteSubject();

        // 注册观察者1
        subject.attach(new ConcreteObserver1());

        // 注册观察者2
        subject.attach(new ConcreteObserver2());

        // 通知观察者主题发生变化，观察者做出对应的反应
        subject.notifyObserver();
    }
}

3. 观察者模式应用

观察者模式普遍应用在事件监听上，当某个事件发生时事件监听者就会相应做出反应，例如上课铃声响了，老师和学生听到了会做出不同的响应。JAVA中的事件处理主要包含三种角色：

• 事件源：产生事件的源头，即发生事件的组件，例如按钮、下拉框等。
• 事件：一个组件某种同类型操作动作的集合，例如按钮的单击事件、按钮的双击事件。
• 事件监听器：对发生的事件做出的反应者，是事件处理中的核心。

JAVA中事件的根抽象是EventObject，而EventListener是事件监听器的顶层抽象。

扩展观察者模式来实现事件处理过程，铃声事件源会发出上课铃事件和下课铃事件，事件监听者老师和学生会做出不同的反应。

3.1 铃声事件

新建铃声事件类继承EventObject类，类名称为RingEvent，内容如下：

public class RingEvent extends EventObject {

    /**
     * 事件特性：是否是上课铃声
     */
    private Boolean isSound;

    public RingEvent(Object source, boolean isSound) {
        super(source);
        this.isSound = isSound;
    }

    /**
     * 获取事件状态
     */
    public Boolean isSound(){
        return this.isSound;
    }
}

3.2 事件监听器

新建铃声事件监听器接口，继承EventListener接口，定义铃声事件处理的行为，接口名称为BellEventListener，内容如下：

public interface BellEventListener extends EventListener {

    /**
     * 铃声事件处理
     */
    void handleBell(RingEvent ringEvent);
}

新建具体铃声事件监听器老师，实现铃声事件监听器接口，完成老师听到老师后做出的反应，类名称为TeacherListener，内容如下：

public class TeacherListener implements BellEventListener{

    @Override
    public void handleBell(RingEvent ringEvent) {
        if (ringEvent.isSound()){
            // 上课
            System.out.println("老师：上课了，带上课件，走向教室......");
        } else {
            // 下课
            System.out.println("老师：下课了，我们下节课再讲......");
        }
    }
}

类似的新建学生铃声事件监听器，类名称为StudentListener，内容如下：

public class StudentListener implements BellEventListener{
    @Override
    public void handleBell(RingEvent ringEvent) {
        if (ringEvent.isSound()){
            // 上课
            System.out.println("学生：上课了，认真听课.......");
        } else {
            // 下课
            System.out.println("学生：下课了，上厕所吗？");
        }
    }
}

3.3 事件源

新建铃声事件源，它应该包含注册事件监听器、注销事件监听器、触发事件、通知事件监听器等行为，类名称为BellEventSource，内容如下：

public class BellEventSource {
    /**
     * 监听者列表
     */
    private List<BellEventListener> listeners;

    public BellEventSource(){
        this.listeners = new ArrayList<>();
    }

    /**
     * 注册监听者
     */
    public void registerListener(BellEventListener bellEventListener){
        listeners.add(bellEventListener);
    }

    /**
     * 注销监听者
     */
    public void removeListener(BellEventListener bellEventListener){
        listeners.remove(bellEventListener);
    }

    /**
     * 触发事件
     */
    public void ring(boolean isSound){
        System.out.println(String.format("叮叮叮......，%s了", isSound ? "上课" : "下课"));
        RingEvent event = new RingEvent(this, isSound);
        notifyListener(event);
    }

    /**
     * 通知监听者
     */
    private void notifyListener(RingEvent ringEvent){
        for (BellEventListener listener : listeners) {
            listener.handleBell(ringEvent);
        }
    }
}

3.4 客户端

新建客户端测试，内容如下：

public class Client {
    public static void main(String[] args) {
        // 创建一个事件源
        BellEventSource bellEventSource = new BellEventSource();

        // 给这个事件源注册一个教师监听器
        bellEventSource.registerListener(new TeacherListener());
        // 给这个事件源注册一个学生监听器
        bellEventSource.registerListener(new StudentListener());

        // 铃声响了，触发上课事件
        bellEventSource.ring(true);
        System.out.println("-----------------------------------------------");

        // 铃声响了，触发下课事件
        bellEventSource.ring(false);
    }
}