当前位置：首页 > news >正文

23种设计模式-观察者(Observer)设计模式

news 来源：原创 2025/5/29 2:53:59

观察者设计模式

🚩什么是观察者模式？
🚩观察者设计模式的特点
🚩观察者设计模式的结构
🚩观察者设计模式的优缺点
🚩观察者设计模式的Java实现
🚩代码总结
🚩总结

🚩什么是观察者模式？

观察者模式（Observer Pattern） 是一种 行为型设计模式，它定义了一种 一对多的依赖关系，使得 一个对象（被观察者） 的状态发生变化时，所有依赖它的 观察者 都会收到通知并自动更新。

使用场景

事件驱动系统（如 GUI 事件监听）
消息订阅-发布系统
数据同步更新（如缓存更新、数据库同步等）
MVC 设计模式中的视图更新

🚩观察者设计模式的特点

解耦观察者与被观察者：被观察者只关心自身状态的变化，不关心谁在监听它。
自动通知：状态变更后，所有观察者都会收到通知。
动态注册和取消：观察者可以随时订阅或取消订阅。

🚩观察者设计模式的结构

观察者模式主要由以下角色组成：

Subject（被观察者）：维护观察者列表，并在状态变化时通知所有观察者。
ConcreteSubject（具体被观察者）：实际的被观察对象，实现 Subject 接口。
Observer（观察者接口）：定义一个 update() 方法，用于接收被观察者的通知。
ConcreteObserver（具体观察者）：实现 Observer 接口，接收通知并更新自身状态。

🚩观察者设计模式的优缺点

✅ 优点

解耦被观察者和观察者，提高代码的灵活性。
支持动态扩展，可以在运行时添加或移除观察者。
符合开闭原则，可以增加新的观察者而无需修改被观察者。

❌ 缺点

可能会有性能问题，如果观察者过多，通知开销可能较大。
通知顺序不可控，多个观察者的执行顺序可能会有影响。

🚩观察者设计模式的Java实现

代码地址：GitHub

先创建Observer（观察者）接口

/**
 * @author hanso
 * @description: 观察者接口
 * @date 2025-03-25 23:40:16
 * @version: 1.0
 */
public interface Observer { // 观察者接口
    public void update(); // 收到通知 更新观察者的状态
}

创建被观察者接口Subject

/**
 * @author hanso
 * @description: 被观察者接口
 * @date 2025-03-25 23:39:08
 * @version: 1.0
 */
public interface Subject {// 目标
    public void Attach(Observer observer);// 添加观察者
    public void Detach(Observer observer);// 删除观察者
    public void Notify();// 状态改变后 通知所有观察者
    public void setState(String state);// 设置状态（改变状态）
    public String getState();// 获取状态
}

创建具体的被观察者类（目标类）实现Subject接口

/**
 * @author hanso
 * @description: 具体被观察者
 * @date 2025-03-25 23:41:58
 * @version: 1.0
 */
public class ConcreteSubject implements Subject {
    private String name;
    private String state;

    private List<Observer> observerList;

    public ConcreteSubject(String name) {
        state = "未更新";
        this.name = name;

        observerList = new ArrayList<Observer>();
    }

    @Override
    public void Attach(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void Detach(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void Notify() {
        // for (遍历对象类型 对象名 : 遍历对象)
        for (Observer observer : observerList) {
            observer.update();
        }
    }

    @Override
    public void setState(String state) {
        this.state = state;

        System.out.println(name + "的状态发生变化，变化后的状态为：" + state);
        Notify();
    }

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

创建具体的观察者类ConcreteObserver实现Observer接口

/**
 * @author hanso
 * @description: 具体观察者
 * @date 2025-03-25 23:44:32
 * @version: 1.0
 */
public class ConcreteObserver implements Observer {
    private String name;
    private String state;

    private Subject subject;

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

        this.subject = subject;
        subject.Attach(this);

        state = subject.getState();
    }

    @Override
    public void update() {
        System.out.println(name + "收到通知");
        state = subject.getState(); // 让当前观察者的状态 和 改变了状态之后的目标的状态保持一致

        System.out.println(name + "改变后的状态为：" + state);
    }
}

测试观察者设计模型

/**
 * @author hanso
 * @description: 测试观察者模式
 * @date 2025-03-25 23:46:15
 * @version: 1.0
 */
public class ObserverPattern {
    public static void main(String[] args) {
        Subject subjectA = new ConcreteSubject("目标A");

        ConcreteObserver observerB = new ConcreteObserver("张三", subjectA);
        ConcreteObserver observerC = new ConcreteObserver("李四", subjectA);
        ConcreteObserver observerD = new ConcreteObserver("王五", subjectA);

        subjectA.setState("更新了");

        System.out.println("======================================");

        subjectA.Detach(observerD);

        subjectA.setState("停更了");
    }
}