Jakarta CDI（Quarkus）批量注册遗留事件监听器的方案咨询

我在开发一个基于Jakarta EE（Quarkus）的新应用，现有一套包含事件监听器注册逻辑的旧代码，已经为事件注册表实现了EventRegistry包装类，现在需要高效批量注册大量事件监听器。相关代码示例如下：

EventRegistry 代码 #

@ApplicationScoped
public class EventRegistry {
    private Set<Listener<?>> listeners = Collections.synchronizedSet(new HashSet<>());

    public void register(Listener l) {
    }
    public void unregister(Listener l) {
    }
}

监听器示例代码 #

@ApplicationScoped
public class Listener1 implements Listener<MyEvent> {
    @Override
    public void onEvent(MyEvent e) {
    }
}

我计划在EventRegistry的@PostConstruct方法中触发一个Jakarta EE事件，让每个监听器Bean监听该事件并自行调用EventRegistry.register()完成注册。想请教以下问题：

1. 这种注册方式是否安全？
2. 未通过@Inject被其他Bean引用的监听器Bean，会不会被容器销毁？
3. 针对同一包下的特定Bean执行注册操作，有没有更优的实现方案？

1. 事件触发式注册的安全性 #

这种方式是安全的，但需要注意几个关键细节：

• 事件同步性：默认Jakarta EE事件是异步触发的，若在EventRegistry的@PostConstruct阶段发布事件，可能存在部分监听器未完成初始化就错过事件的情况。建议使用同步事件观察（比如@Observes注解替代异步的@ObservesAsync），确保应用启动阶段所有监听器都能收到注册事件。
• 线程安全：你的listeners集合已通过Collections.synchronizedSet做线程安全包装，只要register方法内部逻辑仅做集合元素添加（比如listeners.add(l)），就不会有线程安全问题。
• 重复注册：由于@ApplicationScoped是单例Bean，每个监听器只会收到一次启动事件，但如果后续事件被重复发布，需依赖HashSet的去重特性（前提是Listener实现了正确的equals和hashCode），或在register方法中显式判断是否已存在该监听器。

2. 未被注入的监听器Bean的生命周期 #

在Quarkus/Jakarta EE中，@ApplicationScoped Bean的生命周期由容器管理：

• 只要Bean被类路径扫描发现（未被排除扫描），即使没有被其他Bean通过@Inject引用，默认不会被销毁。
• 除非你显式配置了懒加载（比如添加@Lazy注解），或开启了Quarkus的quarkus.arc.remove-unused-beans优化配置，否则容器会在应用启动时初始化这些Bean，并保持实例直到应用停止。因此不用担心未被注入的监听器被销毁，它们能正常监听启动事件并完成注册。

3. 同一包下特定Bean的批量注册更优方案 #

针对同一包下的监听器Bean，以下方案比事件触发更直接高效：

方案一：利用Quarkus Instance注入批量获取 #

通过Instance注入所有实现Listener接口的Bean，再过滤指定包名完成注册，代码简洁且符合Quarkus CDI规范：

@ApplicationScoped
public class EventRegistry {
    private Set<Listener<?>> listeners = Collections.synchronizedSet(new HashSet<>());

    @Inject
    Instance<Listener<?>> listenerInstances;

    @PostConstruct
    public void init() {
        String targetPackage = "com.yourpackage.listeners";
        for (Listener<?> listener : listenerInstances) {
            if (listener.getClass().getPackageName().equals(targetPackage)) {
                register(listener);
            }
        }
    }

    public void register(Listener l) {
        listeners.add(l);
    }

    public void unregister(Listener l) {
        listeners.remove(l);
    }
}

方案二：通过BeanManager扫描指定包Bean #

若需要更精细的控制，可使用Jakarta EE的BeanManager直接扫描指定包下的Listener实现类：

@ApplicationScoped
public class EventRegistry {
    private Set<Listener<?>> listeners = Collections.synchronizedSet(new HashSet<>());

    @Inject
    BeanManager beanManager;

    @PostConstruct
    public void init() {
        String targetPackage = "com.yourpackage.listeners";
        Set<Bean<?>> listenerBeans = beanManager.getBeans(Listener.class, Any.Literal.INSTANCE);
        for (Bean<?> bean : listenerBeans) {
            Class<?> beanClass = bean.getBeanClass();
            if (beanClass.getPackageName().equals(targetPackage)) {
                Listener<?> listener = (Listener<?>) beanManager.getReference(
                        bean, Listener.class, beanManager.createCreationalContext(bean)
                );
                register(listener);
            }
        }
    }

    // register/unregister方法同上
}

方案三：自定义注解标记监听器 #

如果不想依赖包结构，可自定义注解标记需要注册的监听器，再扫描带有该注解的Bean：

// 自定义注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventSubscriber {}

// 监听器添加注解
@ApplicationScoped
@EventSubscriber
public class Listener1 implements Listener<MyEvent> {
    // ...
}

// EventRegistry中扫描注册
@PostConstruct
public void init() {
    Set<Bean<?>> subscriberBeans = beanManager.getBeans(
            Any.Literal.INSTANCE, new AnnotationLiteral<EventSubscriber>() {}
    );
    for (Bean<?> bean : subscriberBeans) {
        if (Listener.class.isAssignableFrom(bean.getBeanClass())) {
            Listener<?> listener = (Listener<?>) beanManager.getReference(
                    bean, Listener.class, beanManager.createCreationalContext(bean)
            );
            register(listener);
        }
    }
}

内容的提问来源于stack exchange，提问作者Fexl