Spring Bean 生命周期的执行流程
1. Bean 定义阶段
- 解析配置元数据：Spring 容器会读取配置信息，这些配置信息可以是 XML 文件、Java 注解或者 Java 配置类。容器根据这些配置信息解析出 Bean 的定义，包括 Bean 的类名、作用域、依赖关系等。
- 注册 Bean 定义：解析完成后，Spring 会将 Bean 定义信息注册到
BeanDefinitionRegistry中，BeanDefinitionRegistry是一个存储 Bean 定义的注册表，它为后续的 Bean 创建提供了基础信息。
2. Bean 实例化阶段
- 创建 Bean 实例：当需要使用某个 Bean 时，Spring 容器会根据 Bean 定义信息创建 Bean 的实例。创建实例的方式有多种，常见的是使用构造函数创建，也可以通过工厂方法创建。
- 构造函数创建：Spring 会调用 Bean 类的无参构造函数或者有参构造函数来创建实例。
- 工厂方法创建：可以使用静态工厂方法或者实例工厂方法来创建 Bean 实例。
3. 属性注入阶段
- 注入依赖：在 Bean 实例创建完成后，Spring 会根据 Bean 定义中的依赖关系，将其他 Bean 或者配置值注入到当前 Bean 的属性中。注入方式主要有两种：
- Setter 方法注入：通过调用 Bean 类的 Setter 方法将依赖注入到 Bean 中。
- 构造函数注入：在创建 Bean 实例时，通过构造函数将依赖传递给 Bean。
4. Bean 初始化阶段
- 实现
BeanNameAware接口：如果 Bean 实现了BeanNameAware接口，Spring 会调用其setBeanName方法，将该 Bean 在容器中的名称传递给它。
收起
java
import org.springframework.beans.factory.BeanNameAware;
public class MyBean implements BeanNameAware {
private String beanName;
@Override
public void setBeanName(String name) {
this.beanName = name;
System.out.println("BeanNameAware: Bean name is " + beanName);
}
}
- 实现
BeanFactoryAware接口：如果 Bean 实现了BeanFactoryAware接口，Spring 会调用其setBeanFactory方法，将当前的BeanFactory传递给它。
收起
java
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
public class MyBean implements BeanFactoryAware {
private BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory factory) {
this.beanFactory = factory;
System.out.println("BeanFactoryAware: BeanFactory is set");
}
}
- 实现
ApplicationContextAware接口：如果 Bean 实现了ApplicationContextAware接口，Spring 会调用其setApplicationContext方法，将当前的ApplicationContext传递给它。
收起
java
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class MyBean implements ApplicationContextAware {
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext context) {
this.applicationContext = context;
System.out.println("ApplicationContextAware: ApplicationContext is set");
}
}
- 执行
BeanPostProcessor的前置处理方法：Spring 会调用所有注册的BeanPostProcessor的postProcessBeforeInitialization方法，允许开发者在 Bean 初始化之前对其进行额外的处理。
收起
java
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("BeanPostProcessor: Before initialization of " + beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("BeanPostProcessor: After initialization of " + beanName);
return bean;
}
}
- 实现
InitializingBean接口：如果 Bean 实现了InitializingBean接口，Spring 会调用其afterPropertiesSet方法，用于在属性注入完成后进行一些初始化操作。
收起
java
import org.springframework.beans.factory.InitializingBean;
public class MyBean implements InitializingBean {
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("InitializingBean: Bean properties are set");
}
}
- 执行自定义的初始化方法：可以在 Bean 定义中指定一个初始化方法，Spring 会在上述步骤完成后调用该方法。
收起
java
public class MyBean {
public void init() {
System.out.println("Custom init method is called");
}
}
在 XML 配置中指定初始化方法：
收起
xml
<bean id="myBean" class="com.example.MyBean" init-method="init"/>
或者使用 Java 配置：
收起
java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean(initMethod = "init")
public MyBean myBean() {
return new MyBean();
}
}
- 执行
BeanPostProcessor的后置处理方法：Spring 会调用所有注册的BeanPostProcessor的postProcessAfterInitialization方法，允许开发者在 Bean 初始化之后对其进行额外的处理。
5. Bean 使用阶段
经过上述步骤，Bean 已经完成了初始化，可以被应用程序使用。在应用程序的运行过程中，可以通过 Spring 容器获取 Bean 实例，并调用其方法。
6. Bean 销毁阶段
- 实现
DisposableBean接口：如果 Bean 实现了DisposableBean接口，Spring 会在容器关闭时调用其destroy方法，用于进行一些资源释放操作。
收起
java
import org.springframework.beans.factory.DisposableBean;
public class MyBean implements DisposableBean {
@Override
public void destroy() throws Exception {
System.out.println("DisposableBean: Bean is being destroyed");
}
}
- 执行自定义的销毁方法：可以在 Bean 定义中指定一个销毁方法，Spring 会在容器关闭时调用该方法。
收起
java
public class MyBean {
public void cleanup() {
System.out.println("Custom destroy method is called");
}
}
在 XML 配置中指定销毁方法：
收起
xml
<bean id="myBean" class="com.example.MyBean" destroy-method="cleanup"/>
或者使用 Java 配置：
收起
java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean(destroyMethod = "cleanup")
public MyBean myBean() {
return new MyBean();
}
}
综上所述，Spring Bean 的生命周期包括定义、实例化、属性注入、初始化、使用和销毁等阶段，开发者可以通过实现特定的接口或指定自定义方法，在不同阶段对 Bean 进行定制化操作。