通用事件监听器的设计与实现：基于观察者模式的解耦方案

本文介绍如何在不修改现有 aevent 和 bevent 类的前提下，通过观察者模式统一处理不同事件的创建逻辑，实现类型无关的事件响应机制。

在实际开发中，我们常遇到需要对多种相似但类型不同的事件（如 AEvent、BEvent）执行统一后续操作的场景。然而，受限于已有代码约束——不能修改 AEvent 和 BEvent 的原始定义——直接抽象共用接口或泛型基类不可行。此时，观察者模式（Observer Pattern）提供了一种优雅的解耦方案：它允许我们将“事件发生”与“响应行为”分离，并通过中间协调者（即观察者）聚合异构事件的状态与行为。

✅ 核心思路：引入中介观察者

我们不改变 AEvent 和 BEvent 的类结构，而是为它们添加轻量级扩展能力——即支持注册外部观察者，并在关键方法（如 onAEventCreate / onBEventCreate）中主动通知观察者。这符合开闭原则（对扩展开放，对修改关闭）。

1. 定义通用观察者协调器

class EventObserver {
    private final AEvent aEvent;
    private final BEvent bEvent;
    private boolean aCreated = false;
    private boolean bCreated = false;

    public EventObserver(AEvent aEvent, BEvent bEvent) {
        this.aEvent = aEvent;
        this.bEvent = bEvent;
        // 注册自身为两者的观察者（需 AEvent/BEvent 提供 setObserver 方法）
        aEvent.setObserver(this);
        bEvent.setObserver(this);
    }

    // 被 AEvent 调用
    public void onAEventCreated() {
        this.aCreated = true;
        checkAndTrigger();
 
   }

    // 被 BEvent 调用
    public void onBEventCreated() {
        this.bCreated = true;
        checkAndTrigger();
    }

    private void checkAndTrigger() {
        if (aCreated && bCreated) {
            onBothEventsCreated();
        }
    }

    // 统一业务入口：所有共性逻辑放在这里
    protected void onBothEventsCreated() {
        System.out.println("✅ Both AEvent and BEvent have been created.");
        // 此处可执行日志、通知、状态更新等通用操作
    }
}

2. 对现有类做最小侵入式增强（仅需添加 observer 支持）

⚠️ 注意：此步骤是必要适配，但不改变原有方法签名与核心逻辑，仅增加观察者回调能力。

class AEvent {
    private EventObserver observer;

    public void setObserver(EventObserver observer) {
        this.observer = observer;
    }

    public void onAEventCreate(A event) {
        // 原有业务逻辑保持不变
        System.out.println("Handling A event: " + event);

        // 新增：通知观察者
        if (observer != null) {
            observer.onAEventCreated();
        }
    }
}

class BEvent {
    private EventObserver observer;

    public void setObserver(EventObserver observer) {
        this.observer = observer;
    }

    public void onBEventCreate(B event) {
        // 原有业务逻辑保持不变
        System.out.println("Handling B event: " + event);

        // 新增：通知观察者
        if (observer != null) {
            observer.onBEventCreated();
        }
    }
}

3. 使用示例

public class Main {
    public static void main(String[] args) {
        AEvent aEvent = new AEvent();
        BEvent bEvent = new BEvent();

        // 构建观察者并绑定
        EventObserver observer = new EventObserver(aEvent, bEvent);

        // 触发事件
        aEvent.onAEventCreate(new A()); // → 触发 observer.onAEventCreated()
        bEvent.onBEventCreate(new B()); // → 触发 observer.onBEventCreated()
        // 当二者均触发后，自动执行 onBothEventsCreated()
    }
}

? 关键优势与注意事项

• ✅ 零侵入原有逻辑：onAEventCreate() 和 onBEventCreate() 内部实现完全保留，仅追加一行通知调用；
• ✅ 松耦合 & 可扩展：未来新增 CEvent，只需为其添加 setObserver() 和通知逻辑，再扩展 EventObserver 即可；
• ⚠️ 线程安全提示：若事件可能并发触发，aCreated/bCreated 标志位应使用 AtomicBoolean 或加锁保护；
• ⚠️ 生命周期管理：建议在 EventObserver 中提供 detach() 方法，避免内存泄漏（尤其在长生命周期对象中持有短生命周期事件引用时）；
• ? 进阶方向：可结合 Java 的 java.util.Observer（已过时）或现代替代方案如 PropertyChangeListener、Reactive Streams（如 Project Reactor），或使用 Spring Event 机制实现更强大的事件总线能力。

通过上述设计，你无需泛型、反射或动态代理，即可用清晰、可控、符合设计原则的方式，将异构事件纳入统一响应管道——这正是观察者模式在真实工程中的典型价值体现。