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 进行定制化操作。