设计模式-观察者

定义

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

核心角色

1. Subject（主题/被观察者）
2. ConcreteSubject（具体主题/被观察者）
3. Observer（观察者）
4. ConcreteObserver（具体观察者）

使用场景

发布与订阅【原生】

发布者=被观察者

// 主题【被观察者】
public interface Subject {

    void registerObserver(Observer observer);

    void removeObserver(Observer observer);

    // 通知观察者，message是内容
    void notifyObservers(String message);
}

// 具体主题实现【被观察者】
class NewsPublisher implements Subject {

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

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

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

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }

    // 业务方法
    public void publishNews(String news) {
        notifyObservers(news);
    }
}

订阅者=观察者

// 观察者接口
public interface Observer {

    void update(String message);
}

// 邮件订阅者【观察者】
class EmailSubscriber implements Observer {

    private final String name;

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

    @Override
    public void update(String message) {
        System.out.println("[" + name + "] 收到邮件通知: " + message);
    }
}


// 电话订阅者【观察者】
class MobileSubscriber implements Observer {

    private final String phone;

    public MobileSubscriber(String phone) {
        this.phone = phone;
    }

    @Override
    public void update(String message) {
        System.out.println("[" + phone + "] 收到短信通知: " + message);
    }
}

测试结果

public class PubSub {

    public static void main(String[] args) {
        // 创建新闻发布者
        NewsPublisher publisher = new NewsPublisher();

        // 创建订阅者
        Observer emailUser = new EmailSubscriber("张三");
        Observer mobileUser = new MobileSubscriber("13800138000");

        // 注册订阅者
        publisher.registerObserver(emailUser);
        publisher.registerObserver(mobileUser);

        // 发布新闻
        publisher.publishNews("Java 21 正式发布！");
    }

}

Spring事件驱动【广泛使用】

定义事件

定义UserEvent类，它继承ApplicationEvent，它有属性User user(事件的内容)。

public class UserEvent extends ApplicationEvent {

    private final User user;

    public UserEvent(Object source, User user) {
        super(source);
        this.user = user;
    }

    public User getUser() {
        return user;
    }
}

发布事件

@Service
@RequiredArgsConstructor
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    private final ApplicationEventPublisher applicationEventPublisher;

    @Override
//    @DataSource
    @Transactional(rollbackFor = Exception.class)
    public void add(UserDTO userDTO) {
        User user = BeanUtil.copyProperties(userDTO, User.class);
        save(user);
        // 发布事件
        applicationEventPublisher.publishEvent(new UserEvent(this, user));
    }
}

监听事件

定义UserEventListener类，它实现ApplicationListener。

@Component
@RequiredArgsConstructor
public class UserEventListener implements ApplicationListener<UserEvent> {

    private final IUserLogService userLogService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onApplicationEvent(UserEvent event) {
        // 监听到事件，则新增一条用户操作log【新增】
        User user = event.getUser();
        UserLog userLog = new UserLog();
        userLog.setOpType("add");
        userLog.setUserId(user.getUserId());
        userLog.setUserName(user.getUserName());
        userLogService.save(userLog);
    }

}