设计模式-观察者模式(observer)

    设计模式-观察者模式(observer)

 

   概要 

   记忆关键词：通知、自动更新 

   定义：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 

   分析：观察者模式又叫做发布-订阅(Publish/Subscribe)模式。观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。这其实是依赖倒置原则的最佳体现。 

   类型：行为型 

   观察者模式结构图：

     

   一、能解决什么问题

   观察者模式适用于需要事件通知的场景。通过使用观察者模式，当某个事件发生时，主题对象会通知所有注册的观察者，观察者可以根据需要对事件做出反应。这种机制广泛应用于 GUI 框架、事件驱动编程和实时系统中。

   二、涉及的相关角色

   1. Subject  被观察者

abstract class Subject {
    private List<Observer> obs = new ArrayList<>();

    public void addObserver(Observer obs){
        this.obs.add(obs);
    }
    public void delObserver(Observer obs){
        this.obs.remove(obs);
    }
    protected void notifyObserver(){
        for(Observer o: obs){
            o.update();
        }
    }
    public abstract void doSomething();
}

    2. ConcreteSubject  具体被观察者

class ConcreteSubject extends Subject {
    public void doSomething(){
        System.out.println("被观察者事件发生改变");
        this.notifyObserver();
    }
}

   3. Observer类 观察者

interface Observer {
    public void update();
}

   4. Concreteobserver类  具体观察者

class ConcreteObserver1 implements Observer {
    public void update() {
        System.out.println("观察者1收到信息，并进行处理");
    }
}
class ConcreteObserver2 implements Observer {
    public void update() {
        System.out.println("观察者2收到信息，并进行处理");
    }
}

   5. 客户端

public class Client {
    public static void main(String[] args){
        Subject sub = new ConcreteSubject();
        sub.addObserver(new ConcreteObserver1()); //添加观察者1
        sub.addObserver(new ConcreteObserver2()); //添加观察者2
        sub.doSomething();
    }
}

//运行结果
被观察者事件发生改变
观察者1收到信息，并进行处理
观察者2收到信息，并进行处理

   三、推模型和拉模型

   1. 推模型

   在推模型中，当主题（Subject）发生变化时，它会主动将更新的数据或信息推送给所有的观察者（Observer）。每个观察者在接收到通知时都能直接获得更新的信息或数据。

   特点：

• 主动推送：主题主动推送更新给观察者。

• 简化观察者逻辑：观察者不需要请求数据，数据已由主题提供。

• 适用于数据量较小或更新频率较低的场景：由于每次通知都会推送完整的数据或信息，适合数据量小且更新频率不高的场景。

    代码示例：

interface Observer {
    void update(String data);
}

class ConcreteSubject {
    private List<Observer> observers = new ArrayList<>();
    private String data;

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(data);  // Push model: provide the data directly
        }
    }

    public void setData(String data) {
        this.data = data;
        notifyObservers();
    }
}

   2. 拉模型

   在拉模型中，当主题发生变化时，它会通知观察者有更新，但不直接提供数据。观察者需要主动请求主题获取更新的数据或信息。观察者在接收到通知后，通常会调用主题的方法以获取最新的数据。

   特点：

• 被动拉取：观察者主动拉取（请求）更新的数据。
• 更灵活：观察者可以根据需要选择是否拉取数据，或者以不同的方式处理数据。
• 适用于数据量较大或更新频率较高的场景：观察者只在需要时拉取数据，有助于减少不必要的数据传输。

   代码示例：

interface Observer {
    void update(ConcreteSubject subject);
}

class ConcreteSubject {
    private List<Observer> observers = new ArrayList<>();
    private String data;

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this);  // Pull model: notify observers to pull data
        }
    }

    public void setData(String data) {
        this.data = data;
        notifyObservers();
    }

    public String getData() {
        return data;
    }
}

class ConcreteObserver implements Observer {
    @Override
    public void update(ConcreteSubject subject) {
        String data = subject.getData();  // Pull the data from the subject
        System.out.println("Received data: " + data);
    }
}

   四、什么时候使用观察者模式？

   1.  当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。

   2. 当一个抽象模型有两方面，其中一方面依赖另一方面，这时用观察者模式可以将这两者封装在独立的对象中，使它们各自独立地改变和复用。

   比如下面这些情况下：

   1）订单支付成功后，会做各种动作，比如发送EMAIL，或者改变订单状态，发送短信给客户，修改优惠券，通知仓库订单号等等

   2）网站登录之后，修改登录时间，推送最新活动，让附近的人给他打招呼

   五、应用场景 

   1.  JDK中的观察者模式

   观察者模式在 Java 语言中的地位非常重要。在 JDK 的 java.util 包中，提供了 Observable 类以及 Observer 接口，它们构成了 JDK 对观察者模式的支持。but，在 Java9 被弃用了。

   java.util.Observer接口

package java.util;

public interface Observer {
    void update(Observable o, Object arg);
}

   java.util.Observable类

import java.util.Observer;
import java.util.Vector;

/**
 * 这里其实就是主题接口的角色，只不过 JDK 的实现很烂——竟然用类封装的，这是公认的槽点之一。
 */
public class Observable {
    private boolean changed = false;

    // 看到这里，其实也知道，这个API不仅太古老，而且还没人维护了，用的还是最老的，被淘汰的 Vector 实现的动态数组
    private Vector obs;

    public Observable() {
        obs = new Vector();
    }

    // 注册观察者，线程安全，这是优点之一，可以借鉴
    public synchronized void addObserver(Observer o) {
        if (o == null) // 提高代码健壮性
            throw new NullPointerException();
        if (!obs.contains(o)) { // 注册时会去重，自定义实现需要注意也去重
            obs.addElement(o);
        }
    }

    // 观察者取消注册
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    // 基于拉模型的通知方法
    public void notifyObservers() {
        notifyObservers(null);
    }

    // 基于推模型
    public void notifyObservers(Object arg) {
        // 一个临时数组，用于并发访问被观察者时，保存观察者列表的当前状态——这就是基于备忘录模式的简单应用。
        Object[] arrLocal;
        // 在获取到观察者列表之前，不允许其他线程改变观察者列表
        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            // 重置变化标记位为 false
            clearChanged();
        }

        // 主题类释放锁，但是并不影响线程安全，因为加锁之前已经将观察者列表复制到临时数组 arrLocal
        // 在通知时我们只通知数组中的观察者，当前删除和添加观察者，都不会影响我们通知的对象
        for (int i = arrLocal.length - 1; i >= 0; i--)
            ((Observer) arrLocal[i]).update(this, arg);
    }

    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

   2. Spring 中的观察者模式

   具体介绍请参考文章《Spring - 事件驱动模型》

   

 

   参考链接:

   https://www.cnblogs.com/study-hard-forever/p/13167161.html

   https://juejin.cn/post/6844904100459446285