Spring Bean生成过程全新认识（自学笔记版）

具体流程图：

创建 Bean 的关键方法流程图：

refresh() ->
    obtainFreshBeanFactory() ->
    finishBeanFactoryInitialization() ->
        doGetBean(beanName) ->
            createBean(beanName) ->
                doCreateBean(beanName) ->
                    createBeanInstance() ->
                        populateBean() ->
                            initializeBean() ->
                                postProcessBeforeInitialization() ->
                                init-method/@PostConstruct/afterPropertiesSet ->
                                postProcessAfterInitialization() ->
                    addSingleton(beanName)

Spring Bean

1. Bean对象是Spring最核心的功能模块，最初最大的用途就是帮助用户通过反射的技术快速创建对象，而不用让用户通过每次new（）对象来进行实现
2. Bean对象既然是依托于Spring容器（即ApplicationContext）进行管理，我们需要得知Bean的创建流程以及其工作流程

Spring对象的工作流程

1. 初始化/创建BeanFactory，读取用户/系统自定义BeanDefinition

• 这一步实现的底层代码在AbstractApplicationContext#refresh()方法中，这一个方法的主要方法有（1）准备容器，（2）初始化BeanFactory并读取BeanDefinition （3）执行后续Spring扩展功能 + 创建Bean对象

public void refresh() throws BeansException, IllegalStateException {
    // 初始化容器
    prepareRefresh();
    // 创建 BeanFactory 并加载 Bean 定义
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    // 执行后续处理，包括 Bean 创建
    finishBeanFactoryInitialization(beanFactory);
}

• BeanDefinition：就是Spring通过（1）Bean的xml配置文件（2）注解（@Component，@Bean）（3）Java配置类（@Configuration）解析以后另外一种统一形式的存在，Spring就是通过将这些BeanDefinition注册到容器之后，实现对象的自动创建（详见BeanDefinition理解）

2. Bean的创建流程

• 当一个Bean被请求的时候（或被初始化时，即单例Bean在容器启动时被创建）

  2.1 检查缓存和实例（DefaultSingletonBeanRegistry#getSingleton(String beanName)）

    检查该 Bean 是否已经存在于单例缓存池中。如果存在，直接返回；否则继续创建。

  2.2 创建 Bean 抽象（AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, Object[] args)）

    根据 Bean 名称，找到对应的 BeanDefinition。调用 createBean() 方法创建 Bean 实例。
    流程：
        1. 核心方法，负责创建完整的 Bean。
        2. 流程包括（1）实例化（2）属性填充（3）初始化
  

3. Bean的实例化

• 具体的工作流程

  AbstractAutowireCapableBeanFactory#doCreateBean() ->
    createBeanInstance()

• createBeanInstance()
  （1）根据 Bean 定义的信息，选择合适的实例化策略（如无参构造、工厂方法等）
  （2）调用 InstantiationStrategy 来实例化

    默认实现：SimpleInstantiationStrategy。
    方法：instantiate()。
  

4. 实例化后处理

• 具体工作流程

InstantiationAwareBeanPostProcessor ->
    postProcessBeforeInstantiation()：实例化前处理。
    postProcessAfterInstantiation()：实例化后处理。

5. Bean属性填充（对象的赋值）

• 具体工作流程

AbstractAutowireCapableBeanFactory ->
    populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw)：实现赋值填充

• 属性值的解析方式
  （1）依赖注入（@Autowired）。

  @Autowired
  public MyBean myBean

  （2）占位符解析（${}）。

  @Value("#{xxx:yyy}")
  public String aaa;

  （3）方法调用 applyPropertyValues()。

• 后处理

  InstantiationAwareBeanPostProcessor#postProcessProperties()：动态属性处理。

6. Bean初始化
7. 具体工作流程

AbstractAutowireCapableBeanFactory ->
    initializeBean(String beanName, Object bean, RootBeanDefinition mbd)：实现Bean初始化

• 初始化流程

  1. 调用 BeanPostProcessor#postProcessBeforeInitialization()。

  2. 调用 Bean 的初始化方法：

     • 实现了 InitializingBean 接口时，调用 afterPropertiesSet()。
     • 配置了 init-method 时，调用指定方法。
     • 使用 @PostConstruct 标注的方法。
  3. 调用 BeanPostProcessor#postProcessAfterInitialization()。

7. 放入单例池

• 具体工作流程

DefaultSingletonBeanRegistry ->
    addSingleton(String beanName, Object singletonObject): 将完成初始化的 Bean 放入单例池中，供后续直接使用。

8. 销毁Bean

当容器关闭时（调用 AbstractApplicationContext#close()）：

• 销毁方法

  • 如果实现了 DisposableBean 接口，调用其 destroy() 方法。
  • 如果配置了 destroy-method，调用指定方法。
  • 如果使用了 @PreDestroy，调用该标注的方法。

• 调用后处理：

  • DestructionAwareBeanPostProcessor#postProcessBeforeDestruction()。

Spring容器的扩展功能-后处理（PostProcessor）

后处理器允许开发者在 Spring 的各个阶段定制 Bean 的行为。具体来说：

1. 容器的初始化 -> BeanFactoryPostProcessor

   • 在容器初始化时，修改 BeanDefinition，如动态注册 Bean、修改 Scope
   • 示例：PropertyPlaceholderConfigurer 实现配置文件解析。

2. Bean初始化 -> InstantationAwareBeanPostProcessor

   • 控制实例化过程，比如生成代理对象、动态替换原始对象。
   • 示例：@Transactional 的代理生成。

3. Bean实例化 -> BeanPostProcessor

   • 在 Bean 初始化前后进行增强。

     • Bean 初始化前 -> postProcessBeforeInitialization：AOP 动态代理、日志增强等。
     • Bean 初始化后 -> postProcessAfterInitialization：安全校验等

4. Bean销毁 -> DestructionAwareBeanPostProcessor

   • 在 Bean 销毁时执行额外操作。
   • 示例：关闭数据库连接、释放线程池。

Spring容器的扩展功能-Aware接口（Aware Interface）

Aware 接口是一种资源注入机制，允许 Bean 获取容器中的特定资源或上下文信息，扩展 Spring 的功能

接口	功能
ApplicationContextAware	获取 ApplicationContext，操作上下文资源。
BeanFactoryAware	获取 BeanFactory，控制 Bean 的创建逻辑。
EmbeddedValueResolverAware	支持解析占位符（如 ${}）和 SpEL 表达式。
ResourceLoaderAware	提供访问文件、URL、Classpath 等资源的能力。
EnvironmentAware	获取运行环境（Environment），如配置属性、Profile 信息等。

Spring特性整合

1. 依赖注入（DI）

   • 通过 BeanPostProcessor 和 InstantiationAwareBeanPostProcessor 完成自动注入
   • 示例：@Autowired、@Value

2. AOP 动态代理

   • 通过 BeanPostProcessor 在 postProcessAfterInitialization 中创建代理对象。

3. 事务管理（@Transactional）

   • 使用 InstantiationAwareBeanPostProcessor 和 AOP 实现事务拦截器

4. 事件驱动（ApplicationListener 和 ApplicationEvent）

   • 通过 ApplicationContextAware 注册监听器。

一句话说明SpringBean

Spring Bean 的创建过程可以总结为：从 AbstractApplicationContext#refresh() 方法开始，通过加载用户定义的 BeanDefinition，交给 BeanFactory 处理，完成实例化、属性填充、初始化，并最终放入缓存中。如果是单例 Bean，则加入缓存以供全局使用；如果是多例 Bean，每次请求时都单独创建。为了增强灵活性和扩展性，Spring 提供了各种后处理器（PostProcessor）和 Aware 接口，允许开发者在 Bean 的不同阶段（定义、实例化、初始化、销毁）中扩展行为，同时也支持对资源和上下文的动态管理。