java观察者模式是怎样工作的

Java 中的观察者模式（Observer Pattern）是一种行为型设计模式，用来在对象之间建立“一对多”的依赖关系：当一个对象状态发生变化时，所有依赖它的对象都会自动收到通知并更新。

下面从 核心角色、工作流程、Java 自带实现、手写示例 四个方面说明它是怎样工作的。

一、核心角色

观察者模式通常包含两类角色：

1. 被观察者（Subject / Observable）

• 维护一组观察者
• 提供注册、移除观察者的方法
• 状态改变时通知所有观察者

2. 观察者（Observer）

• 定义一个更新接口
• 被通知时执行相应逻辑

二、工作流程（原理）

1. 观察者向被观察者 注册（subscribe）
2. 被观察者状态发生变化
3. 被观察者调用 notifyObservers()
4. 所有观察者收到通知，执行 update()
5. 观察者根据需要从被观察者拉取数据或接收推送数据

三、Java 自带的观察者实现（早期 API）

Java 在早期提供了现成的类：

• java.util.Observable（被观察者，已过时）
• java.util.Observer（观察者接口）

示例：

import java.util.Observable;
import java.util.Observer;

class NewsPublisher extends Observable {
    public void publish(String news) {
        setChanged();      // 标记状态已改变
        notifyObservers(news);
    }
}

class Reader implements Observer {
    private String name;

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

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(name + " 收到新闻: " + arg);
    }
}

public class Test {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher();
        Reader r1 = new Reader("小明");
        Reader r2 = new Reader("小红");

        publisher.addObserver(r1);
        publisher.addObserver(r2);

        publisher.publish("Java 21 发布了！");
    }
}

⚠️ 注意：
Observable 和 Observer 在 Java 9 中已被标记为 废弃，不推荐新项目使用。

四、推荐写法：自己实现观察者模式

1. 定义观察者接口

interface Observer {
    void update(String message);
}

2. 定义被观察者

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

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

    public void attach(Observer o) {
        observers.add(o);
    }

    public void detach(Observer o) {
        observers.remove(o);
    }

    public void notifyObservers(String msg) {
        for (Observer o : observers) {
            o.update(msg);
        }
    }
}

3. 具体观察者

class User implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " 收到消息: " + message);
    }
}

4. 使用

public class Demo {
    public static void main(String[] args) {
        Subject subject = new Subject();

        User u1 = new User("Alice");
        User u2 = new User("Bob");

        subject.attach(u1);
        subject.attach(u2);

        subject.notifyObservers("系统维护通知");
    }
}

五、现代 Java 中的替代方案

在实际开发中，更常用的是：

• Spring 事件机制
  • ApplicationEvent
  • @EventListener
• 消息队列
  • Kafka / RabbitMQ
• 响应式编程
  • RxJava / Project Reactor

六、一句话总结

Java 观察者模式通过“注册—通知—更新”的机制，实现对象之间的解耦，让一个对象的变化自动传播给多个依赖对象。

如果你愿意，我也可以帮你画一张 观察者模式流程图，或者结合 Spring 事件 给你对比讲解。