博主介绍： ✌博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家✌

Java知识图谱点击链接：体系化学习Java（Java面试专题）

💕💕 感兴趣的同学可以收藏关注下 ，不然下次找不到哟💕💕

1、什么是观察者模式

观察者模式（Observer Pattern）是一种软件设计模式，它定义了对象之间的一对多依赖关系，使得当一个对象的状态发生改变时，所有依赖它的对象都会自动收到通知并进行相应的更新。

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

在观察者模式中，主题对象通常被称为被观察者或发布者，而观察者对象通常被称为观察者或订阅者。被观察者维护一个观察者列表，并提供注册、注销和通知等方法。观察者通过注册自己到被观察者来接收通知，并在收到通知后执行相应的操作。

观察者模式的核心思想是解耦，它能够使被观察者和观察者之间解耦，让它们可以独立地变化。被观察者只需要知道观察者接口，而不需要知道具体的观察者实现。这样可以方便地增加、删除和修改观察者对象，而不影响被观察者的代码。

2、观察者模式的优缺点

观察者模式的优点包括：

1. 解耦性：观察者模式可以将主题和观察者对象解耦，使它们可以独立地变化。主题对象不需要知道观察者的具体实现，只需要知道观察者接口即可。

2. 扩展性：通过添加新的观察者对象，可以轻松地扩展系统功能，而无需修改主题对象的代码。

3. 灵活性：观察者模式可以在运行时动态地添加、删除和通知观察者对象，使系统更加灵活。

观察者模式的缺点包括：

1. 内存泄漏：如果观察者对象没有正确地被移除，可能会导致内存泄漏问题。因为观察者对象与主题对象之间存在引用关系，如果观察者对象没有被正确地移除，即使观察者对象不再使用，也无法被垃圾回收。

2. 调试复杂性：由于观察者模式中存在多个对象之间的交互，调试可能会变得复杂。当出现问题时，需要仔细追踪和调试多个对象之间的交互流程。

综上所述，观察者模式具有很多优点，可以提高系统的灵活性和可扩展性。但是在使用时需要注意内存泄漏和调试复杂性的问题。

3、观察者模式的应用场景

观察者模式在实际应用中有很多场景可以使用，以下是一些常见的应用场景：

1. GUI事件处理：在图形用户界面中，当用户与界面进行交互时，可以使用观察者模式来处理事件。例如，当用户点击按钮时，按钮作为被观察者会通知所有注册的观察者来执行相应的操作。

2. 股票市场监测：在股票市场中，可以使用观察者模式来实现股票价格的监测和通知。股票价格作为被观察者，多个投资者作为观察者，当股票价格发生变化时，被观察者会通知所有的观察者来更新他们的投资策略。

3. 消息订阅系统：在消息订阅系统中，可以使用观察者模式来实现消息的发布和订阅。发布者作为被观察者，订阅者作为观察者，当发布者发布新消息时，被观察者会通知所有的观察者来接收和处理消息。

4. 游戏开发：在游戏开发中，可以使用观察者模式来处理游戏中的事件和状态变化。例如，当玩家完成某个任务时，游戏作为被观察者会通知所有的观察者来更新游戏的状态。

5. 消息推送系统：在消息推送系统中，可以使用观察者模式来实现消息的推送和接收。推送者作为被观察者，接收者作为观察者，当推送者有新消息时，被观察者会通知所有的观察者来接收和处理消息。

总的来说，观察者模式适用于任何需要一对多依赖关系的场景，其中一个对象的状态变化需要通知多个其他对象的情况。通过观察者模式，可以实现对象之间的解耦，提高系统的灵活性和可扩展性。

4、观察者模式的结构

观察者模式的结构包括以下几个角色：

1. Subject（主题）：也称为被观察者或发布者，它是一个抽象类或接口，定义了添加、删除和通知观察者的方法。主题维护了一个观察者列表，并在状态发生变化时通知观察者。

2. ConcreteSubject（具体主题）：具体主题是主题的实现类，它维护了一个状态，并在状态发生变化时通知观察者。

3. Observer（观察者）：观察者是一个抽象类或接口，定义了接收和处理主题通知的方法。

4. ConcreteObserver（具体观察者）：具体观察者是观察者的实现类，它实现了接收和处理主题通知的方法。

5、观察者模式的原理

观察者模式的工作流程如下：

1. 主题对象维护了一个观察者列表，并提供了添加、删除和通知观察者的方法。

2. 具体主题对象维护了一个状态，并在状态发生变化时调用通知方法，通知观察者。

3. 观察者对象通过实现观察者接口，定义了接收和处理主题通知的方法。

4. 具体观察者对象实现了观察者接口，并在接收到主题通知时执行相应的操作。

当主题对象的状态发生变化时，它会遍历观察者列表，并调用每个观察者的接收和处理方法。这样，观察者就能够及时获得主题的状态变化，并进行相应的处理。

观察者模式的目的是实现对象之间的一对多依赖关系，当一个对象的状态发生变化时，它的所有依赖对象都会得到通知。这种松耦合的设计可以提高系统的灵活性和可维护性。

6、观察者模式的代码案例

下面是一个简单的Java代码示例，演示了观察者模式的实现：

package com.pany.camp.design.principle.observer;

/**
 *
 * @description:  主题接口
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-06-28 15:18
 */
public interface Subject {
   
   

    void registerObserver(Observer observer);

    void removeObserver(Observer observer);

    void notifyObservers();
}

package com.pany.camp.design.principle.observer;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @description:  具体主题类
 * @copyright: @Copyright (c) 2022 
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0 
 * @createTime: 2023-06-28 15:17
 */
public class ConcreteSubject implements Subject {
   
   

    private List<Observer> observers = new ArrayList<>();

    private int state;

    public void setState(int state) {
   
   
        this.state = state;
        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(state);
        }
    }
}

package com.pany.camp.design.principle.observer;

/**
 *
 * @description: 观察者接口
 * @copyright: @Copyright (c) 2022 
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0 
 * @createTime: 2023-06-28 15:16
 */
public interface Observer {
   
   
    void update(int state);
}

package com.pany.camp.design.principle.observer;

/**
 *
 * @description:  具体观察者类
 * @copyright: @Copyright (c) 2022 
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0 
 * @createTime: 2023-06-28 15:17
 */
public class ConcreteObserver implements Observer {
   
   

    private int observerState;

    @Override
    public void update(int state) {
   
   
        observerState = state;
        System.out.println("观察者状态更新为: " + observerState);
    }
}

package com.pany.camp.design.principle.observer;

/**
 *
 * @description:  客户端
 * @copyright: @Copyright (c) 2022 
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0 
 * @createTime: 2023-06-28 15:17
 */
public class Client {
   
   

    public static void main(String[] args) {
   
   
        ConcreteSubject subject = new ConcreteSubject();

        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.setState(10);
        subject.setState(20);

        subject.removeObserver(observer2);

        subject.setState(30);
    }
}

Subject 接口定义了注册观察者、移除观察者和通知观察者的方法。 ConcreteSubject 类是具体的主题类，实现了 Subject 接口，并维护了一个观察者列表和一个状态变量。当状态发生变化时，会调用 notifyObservers 方法通知所有观察者。

Observer 接口定义了观察者的方法 update ，具体观察者类 ConcreteObserver 实现了 Observer 接口，并在 update 方法中更新观察者的状态。

在测试类 ObserverPatternExample 中，创建了一个具体主题对象和两个具体观察者对象。通过调用主题对象的 registerObserver 方法注册观察者，然后通过调用 setState 方法改变主题的状态，观察者会收到通知并更新自身的状态。最后，可以通过调用 removeObserver 方法移除观察者。

输出结果如下：

观察者状态更新为: 10
观察者状态更新为: 10
观察者状态更新为: 20
观察者状态更新为: 20
观察者状态更新为: 30

Process finished with exit code 0

💕💕 本文由激流原创，原创不易，感谢支持
💕💕喜欢的话记得点赞收藏啊