Spring Bean 的创建流程_spring bean的创建过程-CSDN博客

finishBeanFactoryInitialization() 是 Spring 容器启动过程中 完成 BeanFactory 初始化 的核心方法，它负责 实例化所有非懒加载的单例 Bean，并完成其依赖注入、初始化等生命周期阶段。这个过程涉及多个核心组件的协作，是 Spring IOC 容器中 Bean 创建流程 的核心阶段。

🧠 一、`finishBeanFactoryInitialization()` 的作用

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 初始化 ConversionService（用于类型转换）
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
        beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // 注册临时的嵌入值解析器（用于解析注解中的占位符）
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // 提前初始化 LoadTimeWeaverAware 类型的 Bean（用于类加载期织入）
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // 停止使用临时的 ClassLoader（用于 AOP 等）
    beanFactory.setTempClassLoader(null);

    // 冻结所有 BeanDefinition，防止后续修改
    beanFactory.freezeConfiguration();

    // 实例化所有非懒加载的单例 Bean
    beanFactory.preInstantiateSingletons();
}

✅ 核心功能：

设置类型转换器（ConversionService）
注册嵌入值解析器（用于解析 ${} 占位符）
初始化 LoadTimeWeaverAware 类型的 Bean
冻结 BeanDefinition，防止后续修改
实例化所有非懒加载的单例 Bean（preInstantiateSingletons()）

🔄 二、`preInstantiateSingletons()` 方法详解

这是 finishBeanFactoryInitialization() 中最核心的一步，负责 遍历所有非懒加载的单例 BeanDefinition，并调用 getBean() 方法进行实例化。

public void preInstantiateSingletons() throws BeansException {
    List<String> beanNames = new ArrayList<>(this.getBeanDefinitionNames());

    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            } else {
                getBean(beanName); // 触发 Bean 实例化
            }
        }
    }

    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            ((SmartInitializingSingleton) singletonInstance).afterSingletonsInstantiated();
        }
    }
}

📦 三、Bean 创建流程详解（`getBean()` 到 `initializeBean()`）

🧱 1. `getBean()`：触发 Bean 实例化

public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

doGetBean() 是核心实现方法，负责：
- 从缓存中获取 Bean（支持单例）
- 如果不存在，则创建 Bean 实例

🧱 2. `createBean()`：创建 Bean 实例

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    try {
        Object beanInstance = doCreateBean(beanName, mbd, args);
        return beanInstance;
    } catch (Exception ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Creation of bean failed", ex);
    }
}

🧱 3. `doCreateBean()`：Bean 创建主流程

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;

    // 1. 实例化 Bean（调用构造函数）
    instanceWrapper = createBeanInstance(beanName, mbd, args);

    Object bean = instanceWrapper.getWrappedInstance();

    // 2. 解析并缓存 Bean 的类型
    Class<?> beanType = instanceWrapper.getWrappedClass();

    // 3. 填充属性（依赖注入）
    populateBean(beanName, mbd, instanceWrapper);

    // 4. 初始化 Bean（调用 Aware 接口、BeanPostProcessor、初始化方法）
    Object exposedObject = initializeBean(beanName, bean, mbd);

    // 5. 注册销毁方法（用于单例 Bean 的销毁）
    registerDisposableBeanIfNecessary(beanName, bean, mbd);

    return exposedObject;
}

🧩 四、Bean 创建流程图（简化版）

preInstantiateSingletons()
 └── getBean(beanName)
      └── doGetBean()
           └── getSingleton() // 从缓存获取
                └── createBean()
                     └── doCreateBean()
                          ├── createBeanInstance() // 实例化（构造函数）
                          ├── populateBean()       // 属性注入（依赖注入）
                          ├── initializeBean()     // 初始化（Aware、BeanPostProcessor、init-method）
                          └── registerDisposableBeanIfNecessary() // 注册销毁方法

🧱 五、Bean 创建流程详解（核心阶段）

✅ 1. 实例化阶段（`createBeanInstance()`）

调用构造函数创建 Bean 实例
支持以下方式：
- 使用默认构造函数
- 使用有参构造函数（通过 @Autowired 或 XML 配置）
- 使用工厂方法（factory-method）

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    return instantiateBean(beanName, mbd);
}

✅ 2. 属性注入阶段（`populateBean()`）

使用反射为 Bean 的字段赋值（@Autowired、@Resource 等）
支持字段注入、Setter 注入、构造器注入

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            PropertyValues pvsToUse = ((InstantiationAwareBeanPostProcessor) bp)
                .postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
            if (pvsToUse != null) {
                applyPropertyValues(beanName, mbd, bw, pvsToUse);
            }
        }
    }
}

✅ 3. 初始化阶段（`initializeBean()`）

阶段 1：调用 Aware 接口

invokeAwareMethods(beanName, wrappedBean); // 包括 BeanNameAware、BeanFactoryAware 等

阶段 2：调用 `BeanPostProcessor.postProcessBeforeInitialization()`

wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

阶段 3：调用初始化方法

@PostConstruct
InitializingBean.afterPropertiesSet()
自定义 init-method

invokeInitMethods(beanName, wrappedBean, mbd);

阶段 4：调用 `BeanPostProcessor.postProcessAfterInitialization()`

wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

✅ 4. 注册销毁方法（`registerDisposableBeanIfNecessary()`）

为单例 Bean 注册销毁方法（如 @PreDestroy、DisposableBean.destroy()、destroy-method）

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    if (mbd.isSingleton()) {
        registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors()));
    }
}

🔁 六、Bean 的生命周期总结

阶段	方法	说明
实例化	构造函数、工厂方法	创建 Bean 实例
属性注入	`@Autowired`、`@Resource`、`@Value`	注入依赖对象
初始化前	`BeanPostProcessor.postProcessBeforeInitialization()`	可修改 Bean 实例
初始化	`@PostConstruct`, `InitializingBean`, `init-method`	初始化逻辑
初始化后	`BeanPostProcessor.postProcessAfterInitialization()`	可生成代理对象（如 AOP）
销毁	`@PreDestroy`, `DisposableBean`, `destroy-method`	容器关闭时执行

❗ 七、常见问题与解决方案

问题	原因	解决方案
Bean 创建失败	构造函数参数不匹配、依赖注入失败	检查依赖是否正确配置
循环依赖问题	构造函数注入导致无法解决	使用 Setter 注入或 `@Lazy` 延迟注入
AOP 代理未生效	`@Aspect` 未被识别或未启用 AOP	检查是否引入 `aspectjweaver` 依赖
初始化方法未执行	未标注 `@PostConstruct` 或未配置 `init-method`	确保初始化方法正确配置
销毁方法未执行	容器未正常关闭	使用 `context.close()` 关闭容器

✅ 八、总结

特性	说明
Bean 创建入口	`finishBeanFactoryInitialization()` → `preInstantiateSingletons()`
实例化阶段	调用构造函数或工厂方法
属性注入阶段	依赖注入（`@Autowired`, `@Resource`）
初始化阶段	`@PostConstruct`, `InitializingBean`, `init-method`
代理生成	`BeanPostProcessor` 实现（如 AOP）
销毁阶段	单例 Bean 的销毁方法（`@PreDestroy`, `DisposableBean`）
异常处理	容器捕获异常并抛出 `BeanCreationException`