[设计模式] 行为型：观察者模式（Observer Pattern）

什么是观察者模式

顾名思义，观察者就是要对目标进行观察，当目标行为有所变动时，自己及时作出反应。

观察的具体方法有很多种，从编程的角度来理解，观察者要达到观察的目的，主要有两种策略：

1. 观察者主动观察目标状态，实时或半实时的对目标对象进行监听，属于面向过程的编程思想
2. 观察者被动接收消息，当目标状态发生改变时，目标对象主动通知观察者，属于面向对象的编程思想

我将第一种策略称之为主动观察者模式，第二种策略称之为被动观察者模式，名字是我随便取的，读者理解意思就好。

设计模式里面的观察者模式，通常指的都是第二种策略，被动观察者模式。

设计与实现

主动观察者模式

因为观察者要时刻监听目标对象，那么目标对象就必须要暴露某个状态，提供给观察者监听。

所以，通常程序代码大概如下所示：

// 被观察者接口
public interface Observable {
    Integer getState(); // 暴露目标状态
}

// 被观察者
public class ObservableImpl implements Observable {
    private volatile Integer state;

    @Override
    public Integer getState() {
        return state;
    }

    public void change1() {
        System.out.println("目标发生 change1 变化");
        this.state = 1;
    }

    public void change2() {
        System.out.println("目标发生 change2 变化");
        this.state = 2;
    }
}

// 观察者接口
public interface Observer {
    void response(String info); //反应
    void listening(); // 开始观察
}

// 观察者
public class ObserverImpl implements Observer {
    private Observable observable; // 观察目标

    public ObserverImpl(Observable observable) {
        this.observable = observable;
    }

    @Override
    public void response(String info) {
        System.out.println("观察到目标变化：" + info);
    }

    @Override
    public void listening() {
        new Thread(() -> {
            Integer bak = null;
            while (true) { // 持续观察
                Integer state = observable.getState();
                if (state != bak) {
                    this.response("观察到目标变化：state = " + state);
                    bak = state;
                }
            }
        }).start();
    }
}

// 测试方法
public static void main(String[] args) throws InterruptedException {
    ObservableImpl target = new ObservableImpl();
    Observer observer = new ObserverImpl(target);
    observer.listening(); // 开始监听 target
    target.change1();
    Thread.sleep(1000);
    target.change2();
}

主动观察策略，实现起来容易，但是也有其致命的缺点：

1. 时刻观察目标，非常耗费资源，通常都需要创建一个始终存活的线程任务，来完成观察目的
2. 主动观察者可能会遗漏目标非常短暂的状态变化，比如说目标在极短的时间内发生变化，又在极短时间内切换回原状态，观察者就可能看不到这个变化

正因为有这样不容忽视的缺点，主动观察策略不常使用，如果选择使用，一定要评估以上缺点造成的代价能否接受。

被动观察者模式

被动观察者模式通常又叫发布订阅模式，也就是目标主动发布消息，观察者被动接收消息。

从消息的角度看，这里又可细分为两种策略：

1. 目标直接将消息发布给观察者，观察者直接接收
2. 目标将消息发布给第三方，观察者监听第三方获取消息，最常见的第三方就是各种消息队列中间件

利用消息队列中间件完成观察者模式的方法就不说了，这里仅通过第一种策略，理解被动观察模式的代码实现方法。

代码大致如下：

// 观察者接口
public interface Observer {
    void response(String info); //反应
}

// 具体观察者
public class ObserverImpl implements Observer {
    @Override
    public void response(String info) {
        System.out.println("观察到目标变化：" + info);
    }
}

// 被观察者接口
public interface Observable {
    void addObserve(Observer observer); // 增加观察者
    void deleteObserve(Observer observer); // 删除观察者
    void notifyObserves(String info); // 通知所有观察者
}

// 被观察者，具体的观察目标
public class ObservableImpl implements Observable {
    private List<Observer> list = new ArrayList<>();

    @Override
    public void addObserve(Observer observer) {
        this.list.add(observer);
    }
    
    @Override
    public void deleteObserve(Observer observer) {
        this.list.remove(observer);
    }
    
    @Override
    public void notifyObserves(String info) {
        for (Observer observer : list) observer.response(info);
    }
    
    public void change1() {
        System.out.println("目标发生 change1 变化");
        this.notifyObserves("change1");
    }
    
    public void change2() {
        System.out.println("目标发生 change2 变化");
        this.notifyObserves("change2");
    }
}

// 测试方法
public static void main(String[] args) {
    Observer observer = new ObserverImpl();
    ObservableImpl target = new ObservableImpl();
    target.addObserve(observer);
    target.change1();
    target.change2();
}

被动观察模式和主动观察模式相比较，不存在那两个缺点，既没有长时间存活的线程耗费资源，也不会丢失目标的状态变化。

但是，以上代码实现方法也有自身的缺点：

1. 如果目标对象的观察者太多，主动通知过程就会很耗费时间，影响目标自身的运行时效
2. 目标直接通知观察者，如果观察者挂掉了，通知消息就会立即丢失。

这两个缺点相对来说，都有比较容易的解决办法：

1. 主动通知过程可以异步进行，不影响目标运行时效
2. 消息通知可以增加反馈机制，或者异常处理机制，确保消息观察者接收到消息