观察者模式

简介

观察者模式，又叫 发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式 或 从属者（Dependents）模式。

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

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

主要解决

当系统一方行为依赖于另一方行为的变动时，可使用 [观察者模式]松耦合联动双方，使得一方的变动可以通知到感兴趣的另一方对象，从而让另一方对象对此做出响应。

优缺点

优点

• 观察者和被观察者是松耦合（抽象耦合）的，符合 依赖倒置原则；
• 分离了表示层（观察者）和数据逻辑层（被观察者），并且建立了一套触发机制，使得数据的变化可以响应到多个表示层上；
• 实现了一对多的通讯机制，支持事件注册机制，支持兴趣分发机制，当被观察者触发事件时，只有感兴趣的观察者可以接收到通知；

缺点

• 如果观察者数量过多，则事件通知会耗时较长；
• 事件通知呈线性关系，如果其中一个观察者处理事件卡壳，会影响后续的观察者接收该事件；
• 如果观察者和被观察者之间存在循环依赖，则可能造成两者之间的循环调用，导致系统崩溃；

使用场景

• 当一个抽象模型包含两个方面内容，其中一个方面依赖于另一个方面；
• 其他一个或多个对象的变化依赖于另一个对象的变化；
• 实现类似广播机制的功能，无需知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接收该广播；
• 多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知；

模式讲解

观察者模式通常基于Subject和Observer接口类来设计，下面是是类图：

image

从 UML 类图中，我们可以看到，[观察者模式]主要包含三种角色：

• 抽象主题（Subject）：指被观察的对象（Observable）。该角色是一个抽象类或接口，定义了增加、删除、通知观察者对象的方法；
• 具体主题（ConcreteSubject）：具体被观察者，当其内状态变化时，会通知已注册的观察者；
• 抽象观察者（Observer）：定义了响应通知的更新方法；
• 具体观察者（ConcrereObserver）：在得到状态更新时，会自动做出响应；

以下是 [观察者模式]的通用代码：

class Client {
    public static void main(String[] args) {
        // 被观察者
        ISubject<String> observable = new ConcreteSubject<>();
        // 观察者
        IObserver<String> observer = new ConcreteObserver<>();
        // 注册
        observable.addObserver(observer);
        // 通知
        observable.notifyObservers("hello");
    }

    //抽象观察者
    interface IObserver<E> {
        void update(E event);
    }

    //抽象主题者
    interface ISubject<E> {
        boolean addObserver(IObserver<E> observer);

        boolean deleteObservers(IObserver<E> observer);

        void notifyObservers(E event);
    }

    //具体观察者
    static class ConcreteObserver<E> implements IObserver<E> {

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

    //具体主题者
    static class ConcreteSubject<E> implements ISubject<E> {
        private List<IObserver<E>> mObservers = new ArrayList<>();

        @Override
        public boolean addObserver(IObserver<E> observer) {
            return !this.mObservers.contains(observer) && this.mObservers.add(observer);
        }

        @Override
        public boolean deleteObservers(IObserver<E> observer) {
            return this.mObservers.remove(observer);
        }

        @Override
        public void notifyObservers(E event) {
            for (IObserver<E> observer : this.mObservers) {
                observer.update(event);
            }
        }
    }
}

举个例子

例子：比如，我们每天都会设置闹钟，然后听到闹钟响时，就会自动起床，关闭闹钟，刷牙洗脸，开始新的一天。

分析：我们一听到闹钟响铃时，就会自动起床。按 [观察者模式]进行分析，我们相当于观察者（Observer），监听闹钟响铃。闹钟相当于被观察者（Observable），时间到的时间就会通过响铃通知我们。

以下是具体代码：

class Client {
    public static void main(String[] args) {
        //来一个闹钟
        IObservable<String> alarmClock = new AlarmClock();
        //我
        IObserver<String> me = new Me();
        //设置闹钟时间（注册监听）
        alarmClock.register(me);
        //闹钟响铃
        alarmClock.notify("ring! ring ! ring! time is up!");
    }

    interface IObserver<E> {
        void update(E event);
    }

    interface IObservable<E> {
        boolean register(IObserver<E> observer);

        boolean unRegister(IObserver<E> observer);

        void notify(E event);
    }

    static class Me implements IObserver<String> {

        @Override
        public void update(String event) {
            System.out.println("receive: " + event);
            System.out.println(this.getClass().getSimpleName()+": time to wake up!");
        }
    }

    static class AlarmClock implements IObservable<String> {
        private List<IObserver<String>> mObservers = new ArrayList<>();

        @Override
        public boolean register(IObserver<String> observer) {
            return !this.mObservers.contains(observer) && this.mObservers.add(observer);
        }

        @Override
        public boolean unRegister(IObserver<String> observer) {
            return this.mObservers.remove(observer);
        }

        @Override
        public void notify(String event) {
            for (IObserver<String> observer : this.mObservers) {
                observer.update(event);
            }
        }
    }
}

运行结果如下：

receive: ring! ring ! ring! time is up!
Me: time to wake up!