🧑‍💻作者：猫十二懿

🏡账号：CSDN 、个人博客 、Github

🎊公众号：猫十二懿

观察者模式

1、观察者模式介绍

观察者模式是一种行为型设计模式，也被称为发布-订阅模式，它定义了一种一对多的依赖关系，当一个对象状态发生改变时，其所有的依赖对象都会得到通知并自动更新。也就是说让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

1.1 观察者模式结构图

1. Subject类，可翻译为主题或抽象通知者，一般用一个抽象类或者一个接口实现。它把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
2. Observer类，抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫作更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个update()更新方法。
3. ConcreteSubject类，叫作具体主题或具体通知者，将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个具体子类实现。
4. ConcreteObserver类，具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。具体观察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。

抽象例子如下：

Subject类：

/**
 * @author Shier
 * CreateTime 2023/4/26 22:48
 * 抽象通知者类
 */
public abstract class Subject {
    protected String subjectState;

    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }

    private ArrayList<Observer> list = new ArrayList<Observer>();

    /**
     * 增加观察者
     *
     * @param observer
     */
    public void attach(Observer observer) {
        list.add(observer);
    }

    /**
     * 减少观察者
     *
     * @param observer
     */
    public void detach(Observer observer) {
        list.remove(observer);
    }

    /**
     * 通知观察者
     */
    public void notifyObserver() {
        for (Observer observer : list) {
            observer.update();
        }
    }
}

Observer类：

/**
 * @author Shier
 * CreateTime 2023/4/26 22:49
 * 抽象观察者
 */
public abstract class Observer {
    public abstract void update();
}

ConcreteObserver类：

/**
 * @author Shier
 * CreateTime 2023/4/26 22:55
 */
public class ConcreteObserver extends Observer{
    private String name;
    private Subject subject;

    public ConcreteObserver(String name, Subject subject) {
        this.name = name;
        this.subject = subject;
    }

    @Override
    public void update() {
        System.out.println("观察者"+this.name+"的最新状态是"+this.subject.subjectState);
    }
}

ConcreteSubject类：

/**
 * @author Shier
 * CreateTime 2023/4/26 22:54
 * 具体通知者
 */
public class ConcreteSubject extends Subject {
    // 具体的通知方法
}

测试类：

/**
 * @author Shier
 * CreateTime 2023/4/26 22:57
 */
public class ObserverTest {
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        subject.attach(new ConcreteObserver("shier1", subject));
        subject.attach(new ConcreteObserver("shier2", subject));
        subject.attach(new ConcreteObserver("shier3", subject));
        subject.attach(new ConcreteObserver("shier4", subject));
        subject.setSubjectState("睡觉了");
        // 通知其他观察者
        subject.notifyObserver();
    }
}

测试结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yZOg9QDW-1685960128875)(…/…/…/…/AppData/Roaming/Typora/typora-user-images/image-20230426230307411.png)]

tSubjectState(“睡觉了”);
// 通知其他观察者
subject.notifyObserver();
}
}

## 2、观察者模式具体例子

> 假设我们有一个电商平台，用户可以在该平台上购买商品。在这个场景下，我们可以使用观察者模式来实现购物车功能

首先，我们需要定义两个角色：主题（Subject）和观察者（Observer）。主题就是购物车，而观察者就是用户。

```java
// 主题接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 观察者接口
interface Observer {
    void update(String itemName);
}

// 购物车类作为主题实现Subject接口
class ShoppingCart implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private List<String> items = new ArrayList<>();

    public void addItem(String itemName) {
        items.add(itemName);
        notifyObservers();
    }

    public void removeItem(String itemName) {
        items.remove(itemName);
        notifyObservers();
    }

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

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(items.get(items.size() - 1));
        }
    }
}

// 用户类作为观察者实现Observer接口
class User implements Observer {
    private String name;

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

    @Override
    public void update(String itemName) {
        System.out.println(name + " 收到通知：购物车中添加了商品 " + itemName);
    }
}

// 测试代码
public class ObserverPatternExample {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        User user1 = new User("Alice");
        User user2 = new User("Bob");

        cart.registerObserver(user1);
        cart.registerObserver(user2);

        cart.addItem("手机");
        cart.addItem("电视");

        cart.removeItem("手机");
    }
}

在上面的示例中，购物车（ShoppingCart）作为主题实现了Subject接口。它维护了一个观察者列表，并提供了注册、移除和通知观察者的方法。

用户（User）作为观察者实现了Observer接口。每当购物车的状态发生改变时，购物车会通知所有注册的观察者，观察者接收到通知后可以执行相应的操作。

在测试代码中，我们创建了一个购物车对象（cart），以及两个用户对象（user1和user2）。首先，我们将两个用户注册为购物车的观察者。然后，我们通过调用addItem方法向购物车中添加商品，购物车会通知所有观察者。观察者收到通知后会打印相应的信息。最后，我们通过调用removeItem方法从购物车中移除商品，购物车再次通知观察者。

3、观察者模式总结

观察者模式的优点：

1. 解耦性：观察者模式可以将观察者和主题对象解耦。主题对象只知道观察者的接口，而不需要知道具体观察者的实现。这使得主题对象和观察者可以独立地进行修改和扩展，互不影响。
2. 可扩展性：通过添加新的观察者，可以方便地扩展系统的功能。新的观察者可以在不修改现有代码的情况下加入到系统中。
3. 面向对象设计的灵活性：观察者模式符合面向对象设计的原则，可以实现低耦合、高内聚的设计。

观察者模式的缺点：

1. 如果观察者过多或者观察者的处理逻辑复杂，会导致通知过程的效率降低。
2. 观察者模式可能会导致循环引用的问题。当观察者和主题对象相互引用时，需要注意处理引用关系，避免出现内存泄漏的情况。

观察者模式适用于以下场景：

1. 当一个对象的改变需要同时通知多个其他对象时，可以使用观察者模式。例如，当一个数据模型改变时，需要通知多个视图进行更新。
2. 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面，而且这两个方面都需要独立地改变和扩展时，可以使用观察者模式。例如，一个股票市场的模型中，股票价格的变化会影响到显示股票价格的数字和显示股票价格的图形等多个视图。
3. 当一个对象的改变需要触发其他多个对象的更新操作时，可以使用观察者模式。例如，一个订单对象状态的改变需要触发库存管理、支付系统、通知系统等多个模块的更新。