Spring – Bean 生命周期

原文： https://howtodoinjava.com/spring-core/spring-bean-life-cycle/

在本文中，了解SpringBean 生命周期。 我们将学习生命周期阶段，初始化和销毁回调方法。 我们将学习使用 XML 配置以及注解配置来控制 bean 生命周期事件。

1. Bean 的生命周期

当容器启动时 – 需要基于 Java 或 XML bean 定义实例化 Spring bean。 可能还需要执行一些初始化后的步骤，以使其进入可用状态。 相同的 bean 生命周期也适用于 SpringBoot 应用程序。

之后，当不再需要该 bean 时，它将被从 IoC 容器中删除。

Spring bean 工厂负责管理通过 spring 容器创建的 bean 的生命周期。

1.1. 生命周期回调

Spring bean 工厂控制 bean 的创建和销毁。 为了执行一些自定义代码，它提供了回调方法，这些方法可以大致分为两类：

• 初始化后回调方法
• 销毁回调方法

1.1. 生命周期图示

Spring Bean Life Cycle

2. 生命周期回调方法

Spring 框架提供了以下 4 种方式来控制 Bean 的生命周期事件：

1. InitializingBean和DisposableBean回调接口
2. *了解特定行为的界面
3. bean 配置文件中的自定义init()和destroy()方法
4. @PostConstruct和@PreDestroy注解

2.1. InitializingBean和DisposableBean

org.springframework.beans.factory.InitializingBean 接口允许 Bean 在容器上设置了所有必需的属性后执行初始化工作。

InitializingBean接口指定一种方法：

InitializingBean.java

void afterPropertiesSet() throws Exception;

这不是初始化 bean 的首选方法，因为它将 bean 类与 spring 容器紧密耦合。 更好的方法是在applicationContext.xml文件中的 bean 定义中使用“初始化方法”属性。

类似地，实现org.springframework.beans.factory.DisposableBean接口允许 Bean 在包含它的容器被销毁时获得回调。

DisposableBean接口指定一种方法：

DisposableBean.java

void destroy() throws Exception;
A sample bean implementing above interfaces would look like this:
package com.howtodoinjava.task;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
public class DemoBean implements InitializingBean, DisposableBean 
{
    //Other bean attributes and methods 
    @Override
    public void afterPropertiesSet() throws Exception
    {
        //Bean initialization code
    }
    @Override
    public void destroy() throws Exception 
    {
        //Bean destruction code
    }
}

2.2. 了解特定行为的接口

Spring 提供了一系列*Aware接口，这些接口允许 bean 向容器指示它们需要一定的基础结构依赖。 每个接口都将要求您实现一种将依赖项注入 bean 的方法。

这些接口可以概括为：

Java 程序展示了使用感知接口来控制字符串 bean 生命周期的用法。

DemoBean.java

package com.howtodoinjava.task;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.MessageSource;
import org.springframework.context.MessageSourceAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.weaving.LoadTimeWeaverAware;
import org.springframework.core.io.ResourceLoader;
import org.springframework.instrument.classloading.LoadTimeWeaver;
import org.springframework.jmx.export.notification.NotificationPublisher;
import org.springframework.jmx.export.notification.NotificationPublisherAware;
public class DemoBean implements ApplicationContextAware,
        ApplicationEventPublisherAware, BeanClassLoaderAware, BeanFactoryAware,
        BeanNameAware, LoadTimeWeaverAware, MessageSourceAware,
        NotificationPublisherAware, ResourceLoaderAware
{
    @Override
    public void setResourceLoader(ResourceLoader arg0) {
        // TODO Auto-generated method stub
    }
    @Override
    public void setNotificationPublisher(NotificationPublisher arg0) {
        // TODO Auto-generated method stub
    }
    @Override
    public void setMessageSource(MessageSource arg0) {
        // TODO Auto-generated method stub
    }
    @Override
    public void setLoadTimeWeaver(LoadTimeWeaver arg0) {
        // TODO Auto-generated method stub
    }
    @Override
    public void setBeanName(String arg0) {
        // TODO Auto-generated method stub
    }
    @Override
    public void setBeanFactory(BeanFactory arg0) throws BeansException {
        // TODO Auto-generated method stub
    }
    @Override
    public void setBeanClassLoader(ClassLoader arg0) {
        // TODO Auto-generated method stub
    }
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher arg0) {
        // TODO Auto-generated method stub
    }
    @Override
    public void setApplicationContext(ApplicationContext arg0)
            throws BeansException {
        // TODO Auto-generated method stub
    }
}

2.3. 自定义init()和destroy()方法

可以通过两种方式定义 bean 配置文件中的默认init和destroy方法：

• Bean 本地定义适用于单个 Bean
• 全局定义适用于 bean 上下文中定义的所有 bean

2.3.1. Bean 本地定义

本地定义如下。

beans.xml

<beans>
    <bean id="demoBean" class="com.howtodoinjava.task.DemoBean" 
                    init-method="customInit" 
                    destroy-method="customDestroy"></bean>
</beans>

2.3.2. 全局定义

全局定义如下。 这些方法将为<beans>标签下给出的所有 bean 定义调用。 当您具有为所有 bean 一致定义通用方法名称（例如init()和destroy()）的模式时，它们很有用。 此功能可帮助您不必为所有 bean 单独提及init和destroy方法名称。

<beans default-init-method="customInit" default-destroy-method="customDestroy">   
        <bean id="demoBean" class="com.howtodoinjava.task.DemoBean"></bean>
</beans>

显示在 bean XML 配置文件中配置的方法的 Java 程序。

DemoBean.java

package com.howtodoinjava.task;
public class DemoBean 
{
    public void customInit() 
    {
        System.out.println("Method customInit() invoked...");
    }
    public void customDestroy() 
    {
        System.out.println("Method customDestroy() invoked...");
    }
}

2.4. @PostConstruct和@PreDestroy

从 Spring 2.5 开始，您还可以使用注解来指定使用@PostConstruct和@PreDestroy注解的生命周期方法。

• @PostConstruct带注解的方法将在使用默认构造函数构造 Bean 之后，并且在实例返回给请求对象之前被调用。
• 在即将在 bean 容器内销毁 bean 之前，将调用@PreDestroy带注解的方法。

Java 程序，用于显示注解配置的使用以控制注解的使用。

package com.howtodoinjava.task;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class DemoBean 
{
    @PostConstruct
    public void customInit() 
    {
        System.out.println("Method customInit() invoked...");
    }
    @PreDestroy
    public void customDestroy() 
    {
        System.out.println("Method customDestroy() invoked...");
    }
}

因此，这一切都与 Spring 容器内的 spring bean 生命周期有关。 记住给定的生命周期事件类型，这是一个常见的问题Spring 面试问题。

学习愉快！