Spring 个原型 bean 需要手动销毁吗？

Question

我注意到我的原型范围 Spring bean 的 @PreDestroy 钩子没有被执行。

我后来读到 here 这实际上是设计使然。 Spring 容器将销毁单例 bean 但不会销毁原型 bean。我不清楚为什么。如果 Spring 容器将创建我的原型 bean 并执行它的 @PostConstruct 钩子，为什么它不会在容器关闭时也销毁我的 bean？一旦我的 Spring 容器关闭，继续使用它的任何 bean 是否有意义？我看不到在使用完 bean 之前要关闭容器的场景。是否有可能在其容器关闭后继续使用原型 Spring bean？

以上描述了我的主要问题令人费解的背景，即：如果 Spring 容器没有破坏原型 bean，是否意味着可能会发生内存泄漏？或者原型 bean 会在某个时候被垃圾回收吗？

Spring 文档指出：

The client code must clean up prototype-scoped objects and release expensive resources that the prototype bean(s) are holding. To get the Spring container to release resources held by prototype-scoped beans, try using a custom bean post-processor, which holds a reference to beans that need to be cleaned up.

这是什么意思？文本向我暗示，作为程序员，我有责任显式（手动）销毁我的原型 bean。这个对吗？如果是这样，我该怎么做？

Answer 1

为了其他人的利益，我将在下面展示我从调查中收集到的内容：

只要原型 bean 本身不持有对其他资源（如数据库连接或会话对象）的引用，一旦对对象的所有引用都被删除或对象消失，它就会被垃圾回收超出范围。因此通常没有必要显式销毁原型 bean。

但是，在如上所述可能发生内存泄漏的情况下，可以通过创建单例 bean post-处理器来销毁原型 bean，其销毁方法显式调用原型 bean 的销毁挂钩。因为 post-processor 本身是单例范围的，所以它的销毁钩子将被 Spring:

调用

创建一个 bean post 处理器来处理所有原型 bean 的销毁。这是必要的，因为 Spring 不会破坏原型 bean，因此容器永远不会调用代码中的任何 @PreDestroy 挂钩。
实现以下接口：

1.BeanFactoryAware
该接口提供了一个接收 Beanfactory 对象的回调方法。此 BeanFactory 对象用于 post-处理器 class 以通过其 BeanFactory.isPrototype(String beanName) 方法识别所有原型 bean。

2。 DisposableBean
该接口提供了一个由 Spring 容器调用的 Destroy() 回调方法。我们将从该方法中调用所有原型 bean 的 Destroy() 方法。

3。 BeanPostProcessor
实现此接口提供了对 post-process 回调的访问，我们从中准备了由 Spring 容器实例化的所有原型对象的内部 List<>。我们稍后将循环遍历此 List<> 以销毁我们的每个原型 bean。

3. 最后在您的每个原型 bean 中实现 DisposableBean 接口，提供此契约所需的 Destroy() 方法。

为了说明这个逻辑，我在下面提供了一些取自 article 的代码：

/**
* Bean PostProcessor that handles destruction of prototype beans
*/
@Component
public class DestroyPrototypeBeansPostProcessor implements BeanPostProcessor, BeanFactoryAware, DisposableBean {

    private BeanFactory beanFactory;

    private final List<Object> prototypeBeans = new LinkedList<>();

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanFactory.isPrototype(beanName)) {
            synchronized (prototypeBeans) {
                prototypeBeans.add(bean);
            }
        }
        return bean;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    @Override
    public void destroy() throws Exception {
        synchronized (prototypeBeans) {
            for (Object bean : prototypeBeans) {
                if (bean instanceof DisposableBean) {
                    DisposableBean disposable = (DisposableBean)bean;
                    try {
                        disposable.destroy();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
            prototypeBeans.clear();
        }
    }
}

Answer 2

你的回答很好。我还想分享一些关于替代解决方案的注释，该解决方案允许原型成员通过使用内部 bean 由 Spring IoC 容器生命周期本地管理。

我最近写了一篇 answer 来回答关于内部 beans 的一个单独问题。内部 bean 是通过将 bean 属性值分配为 BeanDefinition 对象来创建的。 Bean 定义属性值自动解析为它们定义的 bean 的 (inner) 个实例（作为托管单例 bean）。

以下 XML 上下文配置元素可用于为每个将被管理的引用创建不同的可自动装配 ForkJoinPool beans（@PreDestroy 将在上下文关闭时调用）：

<!-- Prototype-scoped bean for creating distinct FJPs within the application -->
<bean id="forkJoinPool" class="org.springframework.beans.factory.support.GenericBeanDefinition" scope="prototype">
    <property name="beanClass" value="org.springframework.scheduling.concurrent.ForkJoinPoolFactoryBean" />
</bean>

不过，此行为取决于将引用分配为 bean 定义的 属性值。这意味着默认情况下 @Autowired- 和构造函数注入不适用于此，因为这些自动装配方法会立即解析值，而不是使用 AbstractAutowireCapableBeanFactory#applyPropertyValues 中的属性值解析。按类型自动装配也不起作用，因为类型解析不会通过 BeanDefinition 的 bean 传播以查找生成的类型。

此方法只有在以下两个条件之一为真时才有效：

依赖bean 也在XML

中定义

或如果自动装配模式设置为AutowireCapableBeanFactory#AUTOWIRE_BY_NAME

<!-- Setting bean references through XML -->
<beans ...>
    <bean id="myOtherBean" class="com.example.demo.ForkJoinPoolContainer">
        <property name="forkJoinPool" ref="forkJoinPool" />
    </bean>
</beans>

<!-- Or setting the default autowire mode -->
<beans default-autowire="byName" ...>
    ...
</beans>

可能会进行两项额外更改以启用构造函数注入和 @Autowired 注入。

构造函数注入：

bean 工厂为构造函数注入分配 AutowireCandidateResolver。默认值 (ContextAnnotationAutowireCandidateResolver) 可以被覆盖 (DefaultListableBeanFactory#setAutowireCandidateResolver) 以应用候选解析器，该解析器寻找符合条件的 BeanDefinition 类型 bean 进行注入。
@Autowired-注入：

AutowiredAnnotationBeanPostProcessor bean post 处理器直接设置 bean 值而不解析 BeanDefinition 内部 bean。这个 post 处理器可以被覆盖，或者可以创建一个单独的 bean post 处理器来处理托管原型 bean 的自定义注释（例如，@AutowiredManagedPrototype）。

Spring 个原型 bean 需要手动销毁吗？

Do Spring prototype beans need to be destroyed manually?

java

spring

garbage-collection

spring-bean

predestroy