spring中java观察者模式怎么写

在 Spring 中，实现“观察者模式”通常有 两种主流方式：

1. 基于 Spring 事件机制（推荐，最常用）
2. 自己手写观察者模式（不依赖 Spring 事件）

下面分别说明，并给可运行示例。

一、Spring 原生事件机制（最推荐）

Spring 自带 ApplicationEvent + ApplicationListener，本质就是观察者模式。

1️⃣ 定义事件（Event）

import org.springframework.context.ApplicationEvent;

public class UserRegisterEvent extends ApplicationEvent {
    private String username;

    public UserRegisterEvent(Object source, String username) {
        super(source);
        this.username = username;
    }

    public String getUsername() {
        return username;
    }
}

2️⃣ 发布事件（被观察者）

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final ApplicationEventPublisher publisher;

    public UserService(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void register(String username) {
        System.out.println("注册用户：" + username);
        publisher.publishEvent(new UserRegisterEvent(this, username));
    }
}

3️⃣ 监听事件（观察者）

方式一：注解方式（推荐）

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class EmailListener {

    @EventListener
    public void sendEmail(UserRegisterEvent event) {
        System.out.println("发送邮件给：" + event.getUsername());
    }
}

方式二：实现接口方式

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class LogListener implements ApplicationListener<UserRegisterEvent> {

    @Override
    public void onApplicationEvent(UserRegisterEvent event) {
        System.out.println("记录日志：" + event.getUsername());
    }
}

4️⃣ 测试

context.getBean(UserService.class).register("tom");

输出：

注册用户：tom
发送邮件给：tom
记录日志：tom

✅ Spring 会自动管理观察者（Listener）

二、异步观察者（常用）

只需加 @Async

@EventListener
@Async
public void sendEmail(UserRegisterEvent event) {
    // 异步执行
}

⚠️ 需要开启异步：

@EnableAsync
@SpringBootApplication
public class App {}

三、手写观察者模式（不推荐但了解）

interface Observer {
    void update(String msg);
}

class ConcreteObserver implements Observer {
    public void update(String msg) {
        System.out.println("收到：" + msg);
    }
}

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

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

    public void notify(String msg) {
        observers.forEach(o -> o.update(msg));
    }
}

❌ 缺点：

• 要自己管理生命周期
• 没有 Spring 的依赖注入

四、总结

如果你愿意，我可以：

• 给你 Spring Boot 完整 Demo
• 讲 观察者 vs 发布订阅
• 讲 事务事件 @TransactionalEventListener

你想看哪一个？