如何通过 BeanManager 创建和销毁 CDI (Weld) 托管 Bean？

Question

我正在尝试使用 BeanManager 而不是 Instance .select().get() 创建 CDI 托管 bean 的实例。

建议将此作为解决我在使用 ApplicationScoped beans 及其依赖项的垃圾收集时遇到的问题的解决方法 - 请参阅 CDI 应用程序和依赖范围可以共同影响垃圾收集？ 了解背景信息和建议的解决方法。

如果您对 ApplicationScoped bean 使用 Instance 编程查找方法，则 Instance 对象以及从中获取的任何 bean 最终都依赖于 ApplicationScoped bean，因此共享它的生命周期。但是，如果您使用 BeanManager 创建 Bean，您就拥有 Bean 实例本身的句柄，并且显然可以显式销毁它，我理解这意味着它将被 GC 处理。

我当前的方法是在 BeanManagerUtil 类中创建 bean，并返回 Bean、实例和 CreationalContext 的复合对象：

public class BeanManagerUtil {

    @Inject private BeanManager beanManager;

    @SuppressWarnings("unchecked")
    public <T> DestructibleBeanInstance<T> getDestructibleBeanInstance(final Class<T> type,
            final Annotation... qualifiers) {

        DestructibleBeanInstance<T> result = null;
        Bean<T> bean = (Bean<T>) beanManager.resolve(beanManager.getBeans(type, qualifiers));
        if (bean != null) {
            CreationalContext<T> creationalContext = beanManager.createCreationalContext(bean);
            if (creationalContext != null) {
                T instance = bean.create(creationalContext);
                result = new DestructibleBeanInstance<T>(instance, bean, creationalContext);
            }
        }
        return result;
    }
}

public class DestructibleBeanInstance<T> {

    private T instance;
    private Bean<T> bean;
    private CreationalContext<T> context;

    public DestructibleBeanInstance(T instance, Bean<T> bean, CreationalContext<T> context) {
        this.instance = instance;
        this.bean = bean;
        this.context = context;
    }

    public T getInstance() {
        return instance;
    }    

    public void destroy() {
        bean.destroy(instance, context);
    }
}

由此，在调用代码中，我可以获取实际实例，将其放入映射中以供以后检索，并正常使用：

private Map<Worker, DestructibleBeanInstance<Worker>> beansByTheirWorkers =
    new HashMap<Worker, DestructibleBeanInstance<Worker>>();
...
DestructibleBeanInstance<Worker> destructible =
        beanUtils.getDestructibleBeanInstance(Worker.class, workerBindingQualifier);
Worker worker = destructible.getInstance();
...

当我完成它时，我可以查找可破坏的包装器并在其上调用 destroy() ，并且应该清理 bean 及其依赖项：

DestructibleBeanInstance<JamWorker> workerBean =
        beansByTheirWorkers.remove(worker);
workerBean.destroy();
worker = null;

但是，在运行几个工作程序并离开我的 JBoss 之后（7.1.0.Alpha1-SNAPSHOT）大约 20 分钟，我可以看到 GC 发生，

2011.002: [GC
Desired survivor size 15794176 bytes, new threshold 1 (max 15)
1884205K->1568621K(3128704K), 0.0091281 secs]

但 JMAP 直方图仍然显示旧工作线程及其依赖实例挂在周围，未GCed。我缺少什么？

通过调试，我可以看到创建的bean的上下文字段具有正确的Worker类型的上下文，没有incompleteInstances和parentDependentInstances。它有许多 dependentInstances，这些实例与工作人员字段中的预期相同。

Worker 上的这些字段之一实际上是一个实例，当我将此字段与通过编程实例查找检索到的 Worker 的字段进行比较时，它们的 CreationalContext 构成略有不同。通过 Instance 查找的 Worker 上的 Instance 字段将 Worker 本身放在 incompleteInstances 下，而从 BeanManager 检索的 Worker 上的 Instance 字段则没有。它们都有相同的parentDependentInstances 和 dependentInstances。

这表明我没有正确镜像实例的检索。这是否会导致没有破坏？

最后，在调试时，我可以看到在 DestructibleBeanInstance.destroy() 中调用 bean.destroy()，这会传递到 ManagedBean.destroy，并且我可以看到依赖对象作为 .release() 的一部分被销毁。然而他们仍然没有被垃圾收集！

任何对此的帮助将非常感激！谢谢。

Answer 1

我会更改您粘贴的代码中的一些内容。

1. 使该类成为常规 java 类，无需注入并传入 BeanManager。那样的话可能会出现一些混乱。这不太可能，但有可能。
2. 使用 BeanManager.createCreationContext(null) 创建一个新的 CreationalContext，这本质上将为您提供一个依赖范围，您可以在完成后通过调用 CreationalContext.release() 来释放它。

您可以通过调用 DestructibleBeanInstance 中已有的 CreationalContext 上的 release 方法，让一切按照您想要的方式正常工作，假设其中没有其他 Bean CreationalContext 会弄乱您的应用程序。首先尝试一下，看看它是否会把事情搞砸。

Answer 2

仅当注入 bean 以外的类时才应传入 null。在你的例子中，你正在注入一个豆子。不过，我仍然希望 GC 在这种情况下能够工作，所以您能否在 Weld 问题跟踪器中提交 JIRA，其中包含测试用例和重现步骤？

Answer 3

解决问题的更好方法可能是使用动态代理来处理 bean 销毁。以编程方式获取 bean 类实例的代码如下：

public static <B> B getBeanClassInstance(BeanManager beanManager, Class<B> beanType, Annotation... qualifiers) {
    final B result;
    Set<Bean<?>> beans = beanManager.getBeans(beanType, qualifiers);
    if (beans.isEmpty())
        result = null;
    else {
        final Bean<B> bean = (Bean<B>) beanManager.resolve(beans);
        if (bean == null)
            result = null;
        else {
            final CreationalContext<B> cc = beanManager.createCreationalContext(bean);
            final B reference = (B) beanManager.getReference(bean, beanType, cc);
            Class<? extends Annotation> scope = bean.getScope();
            if (scope.equals(Dependent.class)) {
                if (beanType.isInterface()) {
                    result = (B) Proxy.newProxyInstance(bean.getBeanClass().getClassLoader(), new Class<?>[] { beanType,
                            Finalizable.class }, new InvocationHandler() {
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            if (method.getName().equals("finalize")) {
                                bean.destroy(reference, cc);
                            }
                            try {
                                return method.invoke(reference, args);
                            } catch (InvocationTargetException e) {
                                throw e.getCause();
                            }
                        }
                    });
                } else
                    throw new IllegalArgumentException("If the resolved bean is dependent scoped then the received beanType should be an interface in order to manage the destruction of the created dependent bean class instance.");
            } else
                result = reference;
        }
    }
    return result;
}

interface Finalizable {
    void finalize() throws Throwable;
}

这样用户代码就更简单了。它不必负责破坏。
此方法的局限性在于，不支持接收到的 beanType 不是接口且解析的 bean 类为 @Dependent 的情况。但很容易工作。只需使用一个接口即可。
我测试了这段代码（使用 JBoss 7.1.1），它也适用于依赖的有状态会话 bean。