BeanFactory 实现

手动模拟 Spring 容器启动流程：深度解析 BeanFactory 核心机制

Spring容器就像一个"超级工厂"，负责Bean的创建、依赖注入、生命周期管理等核心操作。本文将通过手动模拟Spring容器启动的完整流程，深度解析其底层核心机制，包括BeanDefinition注册、BeanFactoryPostProcessor、BeanPostProcessor、依赖注入实现等关键技术点。

---

一、容器初始化：创建核心工厂实例

1.1 核心容器：DefaultListableBeanFactory

Spring容器的核心是DefaultListableBeanFactory，它继承自DefaultSingletonBeanRegistry（管理单例Bean缓存）并实现了ConfigurableListableBeanFactory接口（提供完整的Bean生命周期管理能力）。

其核心能力包括：

• Bean定义注册表 （beanDefinitionMap）：存储所有Bean的元数据描述（BeanDefinition），记录类的完整信息、作用域、构造参数等。
• 单例Bean缓存 （singletonObjects）：存储已初始化的单例Bean实例，避免重复创建。
• 后处理器管理 （beanFactoryPostProcessors、beanPostProcessors）：存储BeanFactory后处理器和Bean后处理器，用于扩展容器功能。
• 生命周期回调 ：支持InitializingBean、DisposableBean等接口，以及@PostConstruct、@PreDestroy注解。

1.2 代码实战：初始化容器

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
log.info("1. 创建核心容器实例，内存地址：" + System.identityHashCode(beanFactory));

通过new DefaultListableBeanFactory()创建容器实例，这是Spring容器启动的第一步。后续所有操作（如注册Bean定义、添加后处理器）都基于此实例。

---

二、注册Bean定义：告诉容器"如何创建Bean"

2.1 BeanDefinition：Bean的"元数据蓝图"

在Spring中，​Bean的定义（BeanDefinition）​ ​ 是容器的"蓝图"，它不直接创建Bean实例，而是记录如何创建实例的指令。BeanDefinition包含以下关键信息：

• beanClass：Bean的类对象（如ServiceA.class）。
• scope：作用域（默认SCOPE_SINGLETON，可选SCOPE_PROTOTYPE等）。
• constructorArguments：构造函数参数。
• propertyValues：属性值（如serviceB依赖的注入值）。
• initMethodName/destroyMethodName：初始化/销毁方法名。

2.2 代码实战：注册基础Bean定义

通过BeanDefinitionBuilder创建BeanDefinition并注册到容器：

// 注册AppConfig配置类（本质是一个普通Bean，但其@Bean方法会被特殊处理）
AbstractBeanDefinition appConfigDef = BeanDefinitionBuilder.genericBeanDefinition(AppConfig.class)
        .setScope(ConfigurableBeanFactory.SCOPE_SINGLETON)
        .getBeanDefinition();
beanFactory.registerBeanDefinition("appConfig", appConfigDef);

// 批量注册业务Bean（ServiceA、ServiceB等）
String[] beanNames = {"serviceA", "serviceB", "serviceC", "serviceD", "userService", "orderService", "serviceTest"};
for (String beanName : beanNames) {
    Class<?> beanClass = ClassUtils.resolveClassName(/* 根据beanName解析具体类 */);
    AbstractBeanDefinition def = BeanDefinitionBuilder.genericBeanDefinition(beanClass).getBeanDefinition();
    beanFactory.registerBeanDefinition(beanName, def);
}

• 配置类（AppConfig）​ ：虽然本质是普通Bean，但Spring会通过ConfigurationClassPostProcessor将其增强为ConfigurationClassBeanDefinition，用于解析@Bean方法。
• 业务Bean ：通过BeanDefinitionBuilder创建通用Bean定义，设置类信息后注册到容器。此时容器仅记录"如何创建Bean"，尚未实例化。

---

三、注册注解处理器：解析注解元数据

3.1 为什么需要注解处理器？

Spring的注解驱动（如@Autowired、@Component）需要通过注解处理器 解析元数据。其中最核心的是AnnotationConfigUtils，它会向容器注册5个关键的BeanFactoryPostProcessor，负责解析注解并完善BeanDefinition。

3.2 代码实战：注册注解处理器

AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

AnnotationConfigUtils.registerAnnotationConfigProcessors方法会注册以下5个核心处理器（按优先级排序）：

处理器类名	作用
ConfigurationClassPostProcessor	解析@Configuration、@Bean、@ComponentScan等注解，生成增强型BeanDefinition。
AutowiredAnnotationBeanPostProcessor	处理@Autowired、@Value注解，负责依赖注入（属于BeanPostProcessor）。
CommonAnnotationBeanPostProcessor	处理@Resource、@PostConstruct、@PreDestroy注解（属于BeanPostProcessor）。
EventListenerMethodProcessor	处理@EventListener注解，支持事件监听（属于BeanPostProcessor）。
DefaultEventListenerFactory	事件监听器工厂，辅助EventListenerMethodProcessor工作。

3.3 关键细节：处理器注册时机

这些处理器本身会被注册为Bean，但它们的执行时机在所有BeanDefinition加载完成后 ​（即BeanFactoryPostProcessor阶段）。Spring通过BeanDefinitionRegistry将处理器注册到容器中，确保后续流程能找到它们。

---

四、执行BeanFactoryPostProcessor：完善Bean定义

4.1 BeanFactoryPostProcessor的核心作用

BeanFactoryPostProcessor是Spring容器启动的"关键扩展点"，其核心职责是修改BeanDefinition的元数据 ​（而非创建实例）。执行时机在所有BeanDefinition加载完成后、Bean实例化之前。

4.2 代码实战：执行处理器

beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach(processor -> {
    log.info("执行BeanFactoryPostProcessor: " + processor.getClass().getName());
    processor.postProcessBeanFactory(beanFactory);
});

以ConfigurationClassPostProcessor为例，其核心逻辑如下：

1. 扫描配置类 ：查找所有标注@Configuration的类（如AppConfig）。
2. 增强配置类 ：将原配置类替换为EnhancedConfiguration（通过CGLIB增强，确保@Bean方法单例）。
3. 解析@Bean方法 ：扫描配置类的@Bean方法，生成对应的BeanDefinition并注册到容器。
4. 处理其他注解 ：解析@Import（导入其他配置类）、@ComponentScan（扫描组件）等注解，扩展BeanDefinition集合。

4.3 关键影响：Bean定义的最终形态

经过BeanFactoryPostProcessor处理后，BeanDefinition的元数据被最终确定。例如：

• @Configuration类被增强，@Bean方法被解析为具体的BeanDefinition。
• 依赖的Bean名称（如@Bean(destroyMethod="close")）被记录到BeanDefinition中。

---

五、注册BeanPostProcessor：干预Bean生命周期

5.1 BeanPostProcessor：扩展Bean的"生命周期钩子"

BeanPostProcessor是Spring的"扩展引擎"，用于干预Bean的实例化、属性注入、初始化 等生命周期阶段。与BeanFactoryPostProcessor不同，它的操作对象是Bean实例 ​（而非BeanDefinition）。

5.2 代码实战：注册并排序处理器

// 获取所有BeanPostProcessor实例（已通过@Bean或@Autowired注册到容器中的）
Map<String, BeanPostProcessor> processors = beanFactory.getBeansOfType(BeanPostProcessor.class);

// 按AnnotationAwareOrderComparator排序（支持@Order/@Ordered）
List<BeanPostProcessor> sortedProcessors = new ArrayList<>(processors.values());
sortedProcessors.sort(AnnotationAwareOrderComparator.INSTANCE);

// 按顺序添加到容器的BeanPostProcessors列表
sortedProcessors.forEach(beanFactory::addBeanPostProcessor);

5.3 排序规则：决定执行顺序

Spring通过AnnotationAwareOrderComparator对BeanPostProcessor排序，规则如下：

1. 实现Ordered接口的处理器，按getOrder()值升序排列（值越小优先级越高）。
2. 标注@Order注解的处理器，按注解的value值排序。
3. 未显式指定顺序的处理器，默认顺序为Ordered.LOWEST_PRECEDENCE（最低优先级）。

5.4 关键处理器：AutowiredAnnotationBeanPostProcessor

AutowiredAnnotationBeanPostProcessor是最常用的BeanPostProcessor之一，负责处理@Autowired注解的依赖注入。其核心逻辑在postProcessProperties方法中：

1. 扫描Bean的字段、方法、参数，查找@Autowired标注的元素。
2. 解析依赖类型（考虑泛型），调用beanFactory.getBean(dependencyType)获取匹配的Bean实例。
3. 通过反射将实例注入到目标字段/方法中。

---

六、预实例化单例Bean：触发完整的生命周期

6.1 preInstantiateSingletons：启动生命周期引擎

preInstantiateSingletons是Spring触发单例Bean完整生命周期的核心方法。其执行流程如下：

1. 遍历单例Bean定义 ：获取所有scope=singleton的BeanDefinition。
2. 触发getBean()​ ：对每个Bean定义调用getBean(beanName)，触发实例化、注入、初始化流程。
3. 缓存单例实例 ：将创建的Bean实例存入singletonObjects缓存（避免重复创建）。

6.2 生命周期全流程：从实例化到初始化

getBean()方法的底层调用链如下（简化版）：

getBean(beanName) → doGetBean(beanName) → createBean(beanName, beanDefinition, args) → 
instantiateBean(beanName, beanDefinition) → populateBean(beanName, beanDefinition, beanInstance) → 
initializeBean(beanName, beanInstance, beanDefinition)

（1）实例化（Instantiation）

通过构造函数（无参/有参）或工厂方法创建Bean实例。Spring支持：

• 无参构造函数（最常用）。
• 有参构造函数（通过BeanDefinition的constructorArguments指定参数）。
• 工厂方法（通过factoryBeanName和factoryMethodName指定）。

（2）属性填充（Population）

调用populateBean方法，完成依赖注入：

• 处理@Autowired、@Resource注解的字段/方法。
• 处理@Value注解的属性值（支持SpEL表达式）。

（3）初始化（Initialization）

调用初始化方法：

• @PostConstruct注解的方法（JSR-250规范）。
• InitializingBean接口的afterPropertiesSet()方法。
• 自定义init-method（在BeanDefinition中指定）。

6.3 代码实战：观察生命周期日志

通过观察ServiceA、ServiceB的构造日志，可以清晰看到生命周期的执行顺序：

【构造】ServiceB实例化（内存地址：123456）
【构造】ServiceA实例化（内存地址：789012）

ServiceA依赖ServiceB，因此ServiceB会先被实例化，再注入到ServiceA中。

---

七、验证依赖注入：@Autowired的工作流程

7.1 依赖注入的本质

依赖注入（DI）的核心是将Bean的依赖关系从代码中解耦 ，由Spring容器自动完成。@Autowired是Spring最常用的注入方式，其本质是通过AutowiredAnnotationBeanPostProcessor实现的。

7.2 代码实战：验证注入结果

ServiceA serviceA = beanFactory.getBean(ServiceA.class);
log.info("ServiceA获取成功，其ServiceB实例：" + serviceA.getServiceB());

输出结果应显示ServiceA的serviceB字段已被成功注入ServiceB实例。这验证了@Autowired的注入逻辑：AutowiredAnnotationBeanPostProcessor扫描到@Autowired注解后，从容器中获取ServiceB实例并注入到ServiceA中。

---

八、混合注解场景：@Autowired + @Resource

8.1 注解的优先级与冲突

当Bean的字段同时标注@Autowired和@Resource时，Spring如何处理？
@Resource由CommonAnnotationBeanPostProcessor处理，其逻辑优先于@Autowired：

1. 优先使用@Resource的name属性查找Bean（若存在）。
2. 若name未指定，则使用字段名查找Bean。
3. 若仍未找到，则按类型查找（与@Autowired类似）。

8.2 代码实战：测试混合注入

ServiceTest serviceTest = beanFactory.getBean(ServiceTest.class);
Service injectedService = serviceTest.getService();
log.info("注入的Service类型：" + injectedService.getClass().getSimpleName());

ServiceTest的userService字段标注了@Autowired和@Resource(name="orderService")，因此Spring会优先查找name="orderService"的Bean（即OrderService实例），最终注入OrderService。

---

总结

通过手动模拟Spring容器启动流程，我们深度解析了以下核心机制：

1. BeanDefinition：Spring管理Bean的"元数据蓝图"，记录类的完整信息和创建指令。
2. BeanFactoryPostProcessor ：解析注解元数据，完善BeanDefinition（如ConfigurationClassPostProcessor处理@Configuration类）。
3. BeanPostProcessor ：扩展Bean的生命周期，干预实例化、注入、初始化（如AutowiredAnnotationBeanPostProcessor处理@Autowired）。
4. 依赖注入 ：通过BeanPostProcessor实现，@Autowired按类型匹配，@Resource按名称匹配（优先）。
5. 生命周期管理 ：从实例化到初始化的完整流程，支持@PostConstruct、InitializingBean等扩展点。

Spring容器的强大之处在于其可扩展的架构设计 ​：通过BeanFactoryPostProcessor和BeanPostProcessor，开发者可以轻松定制Bean的创建、注入和初始化逻辑，满足各种复杂场景的需求。

理解这些底层机制后，我们在实际开发中可以更高效地使用Spring（如自定义注解、扩展后处理器），并避免常见的"坑"（如依赖注入顺序问题、循环依赖）。

完整代码

package com.dwl.bean_factory_case;

import com.dwl.event.Env;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.DefaultSingletonBeanRegistry;
import org.springframework.context.annotation.AnnotationConfigUtils;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.util.ClassUtils;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * @ClassName BeanFactoryCase
 * @Description 手动模拟Spring容器启动全流程，深度解析BeanFactory核心机制
 * 底层原理覆盖：Bean生命周期、后处理器机制、注解解析、依赖注入实现
 * @Version 1.0.0
 * @Date 2025
 * @Author By Dwl
 */
@Slf4j
@SuppressWarnings({"unchecked"})
public class BeanFactoryCase {

    public static void main(String[] args) {
        log.info("===== 开始初始化Spring容器（核心：DefaultListableBeanFactory） =====");
        /*
         * 底层原理：DefaultListableBeanFactory是Spring容器的核心实现类，继承自DefaultSingletonBeanRegistry
         *          并实现了ConfigurableListableBeanFactory接口，提供完整的Bean生命周期管理能力：
         *          - Bean定义注册（BeanDefinitionRegistry）
         *          - 单例Bean缓存（singletonObjects）
         *          - 后处理器管理（beanFactoryPostProcessors、beanPostProcessors）
         *          - 生命周期回调（postProcessBeforeInitialization/postProcessAfterInitialization）
         */
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        log.info("1. 创建核心容器实例，内存地址：" + System.identityHashCode(beanFactory));
        log.info("   容器关键能力：单例缓存（singletonObjects）、Bean定义注册表（beanDefinitionMap）、后处理器列表（beanPostProcessors）");


        /*
         * 底层原理：BeanDefinition是Spring对Bean的"元数据描述"，存储类的完整信息（Class对象）、作用域（SCOPE_SINGLETON）、
         *          构造参数（ConstructorArgumentValues）、属性值（MutablePropertyValues）、初始化方法（initMethodName）等。
         *          注册BeanDefinition是将"类的描述"告知容器，此时尚未创建实例，仅记录如何创建Bean的指令。
         */
        registerBeanDefinitions(beanFactory);
        log.info("2. 完成基础Bean定义注册，当前BeanDefinition数量：" + beanFactory.getBeanDefinitionCount());
        log.info("   示例BeanDefinition（ServiceA）结构：");
        log.info("      beanClass: " + ServiceA.class.getName());
        log.info("      scope: singleton");
        log.info("      constructorArguments: []");
        log.info("      propertyValues: {serviceB=null（未解析）}");


        /*
         * 底层原理：AnnotationConfigUtils是Spring注解驱动的核心工具类，通过registerAnnotationConfigProcessors方法
         *          向容器注册5个关键BeanFactoryPostProcessor，这些处理器负责解析注解元数据：
         *          1. ConfigurationClassPostProcessor（优先级最高）：处理@Configuration、@Bean、@ComponentScan等注解
         *             - 解析@Configuration类，生成增强后的BeanDefinition（ConfigurationClassBeanDefinition）
         *             - 扫描@Bean方法，将其转换为BeanDefinition
         *          2. AutowiredAnnotationBeanPostProcessor：处理@Autowired、@Value注解（属于BeanPostProcessor）
         *          3. CommonAnnotationBeanPostProcessor：处理@Resource、@PostConstruct、@PreDestroy（属于BeanPostProcessor）
         *          4. EventListenerMethodProcessor：处理@EventListener注解（属于BeanPostProcessor）
         *          5. DefaultEventListenerFactory：事件监听器工厂（辅助类）
         *          注意：这些处理器本身会被注册为Bean，但它们的执行时机在Bean定义加载完成后。
         */
        registerAnnotationProcessors(beanFactory);

        /*
         * 底层原理：BeanFactoryPostProcessor的执行是Spring容器启动的关键阶段，发生在所有BeanDefinition加载完成后，
         *          Bean实例化之前。其核心职责是"修改BeanDefinition的元数据"（而非创建实例）。
         *          执行顺序：按BeanFactory中BeanFactoryPostProcessor的注册顺序执行（可通过@Order调整）。
         *          关键操作示例（以ConfigurationClassPostProcessor为例）：
         *          1. 扫描容器中所有@Configuration类（通过beanFactory.getBeanNamesForAnnotation(Configuration.class)）
         *          2. 解析@Configuration类的@Bean方法，生成对应的BeanDefinition（标记为"已解析"，避免重复解析）
         *          3. 处理@Import、@ComponentScan等其他注解，扩展BeanDefinition集合。
         */
        processBeanFactoryPostProcessors(beanFactory);
        log.info("4. 完成BeanFactoryPostProcessor执行，核心操作已完成BeanDefinition的最终解析");

        /*
         * 底层原理：BeanPostProcessor是Spring扩展机制的核心，用于干预Bean的实例化、属性注入、初始化等生命周期阶段。
         *          与BeanFactoryPostProcessor不同，BeanPostProcessor的操作对象是Bean实例（而非BeanDefinition）。
         *          执行顺序：通过AnnotationAwareOrderComparator排序（支持@Order/@Ordered），确保AOP等扩展按正确顺序执行。
         *          关键处理器说明：
         *          - AutowiredAnnotationBeanPostProcessor：在postProcessProperties阶段注入@Autowired依赖
         *            - 原理：通过反射扫描Bean的字段/方法，查找@Autowired标注的依赖，从容器中获取匹配的Bean并注入
         *          - CommonAnnotationBeanPostProcessor：在postProcessBeforeInitialization阶段处理@Resource注入
         *            - 原理：优先按name属性查找Bean（若未指定则按字段名），再按类型匹配
         *          注意：BeanPostProcessor的执行时机在Bean实例化之后（构造函数调用完成），因此可以访问Bean实例。
         */
        registerBeanPostProcessors(beanFactory);
        log.info("5. 完成BeanPostProcessor注册，当前数量：" + beanFactory.getBeanPostProcessors().size());
        log.info("   排序后的BeanPostProcessor（前3个）：");
        for (int i = 0; i < Math.min(3, beanFactory.getBeanPostProcessors().size()); i++) {
            log.info("      " + i + ". " + beanFactory.getBeanPostProcessors().get(i).getClass().getName());
        }

        /*
         * 底层原理：preInstantiateSingletons是触发单例Bean完整生命周期的关键方法，其执行流程如下：
         *          1. 遍历所有单例BeanDefinition（beanDefinitionMap中scope=singleton的Bean）
         *          2. 对每个BeanDefinition调用getBean(beanName)，触发实例化流程：
         *             a. 实例化：通过构造函数（无参/有参）或工厂方法创建Bean实例（反射调用）
         *             b. 属性填充：调用BeanPostProcessor的postProcessProperties方法，注入依赖（@Autowired/@Resource）
         *             c. 初始化：依次调用@PostConstruct注解方法、InitializingBean#afterPropertiesSet()、自定义init-method
         *          3. 将创建的Bean实例存入singletonObjects缓存（避免重复创建）
         *          注意：非单例Bean（如prototype）不会在此处实例化，仅在首次调用getBean()时创建。
         */
        preInstantiateSingletons(beanFactory);
        log.info("6. 完成单例Bean预实例化，已初始化Bean数量：" + countInitializedBeans(beanFactory));

        /*
         * 底层原理：依赖注入的完整流程由BeanPostProcessor驱动，以@Autowired为例：
         *          1. AutowiredAnnotationBeanPostProcessor在postProcessProperties阶段被调用
         *          2. 通过ReflectionUtils.findField获取所有@Autowired标注的字段
         *          3. 对每个字段，使用TypeConverter将字段类型转换为需要的依赖类型
         *          4. 调用beanFactory.getBean(dependencyType)获取匹配的Bean实例（考虑@Primary、@Qualifier）
         *          5. 通过Field.set()方法将Bean实例注入到目标字段中
         *          关键细节：若注入失败（如找不到Bean），默认会抛出NoSuchBeanDefinitionException（可通过required=false忽略）
         */
        verifyDependencyInjection(beanFactory);


        /*
         * 底层原理：混合使用@Autowired（类型匹配）和@Resource（名称匹配）时，Spring的处理顺序由注解的加载顺序决定：
         *          1. @Resource由CommonAnnotationBeanPostProcessor处理（属于BeanPostProcessor）
         *          2. @Autowired由AutowiredAnnotationBeanPostProcessor处理（同为BeanPostProcessor）
         *          3. 两者的执行顺序由AnnotationAwareOrderComparator决定，默认按注册顺序（此处两者均为0，按类名排序）
         *          4. 但@Resource的name属性具有"强匹配"特性，若显式指定name，会优先按名称查找Bean，覆盖类型匹配逻辑。
         *          示例中@ServiceTest的userService字段同时标注@Autowired和@Resource(name="orderService")，最终注入orderService。
         */
        testMixedAnnotationInjection(beanFactory);

        Env.sleep(2000);
        log.info("===== 容器运行结束 =====");
    }

    /**
     * 步骤2：注册基础Bean定义（BeanDefinition的创建与注册）
     * 底层原理：BeanDefinitionBuilder通过genericBeanDefinition()创建通用BeanDefinition，设置类信息后，
     * 调用registerBeanDefinition()将BeanDefinition存入beanFactory.beanDefinitionMap（ConcurrentHashMap）。
     * 关键属性说明：
     * - scope：默认SCOPE_SINGLETON（单例），其他可选值：SCOPE_PROTOTYPE（原型）、SCOPE_REQUEST（请求）等
     * - lazyInit：默认false（立即初始化），设置为true时延迟到getBean()时初始化
     * - dependsOn：指定依赖的Bean名称（需先初始化这些Bean）
     */
    private static void registerBeanDefinitions(DefaultListableBeanFactory beanFactory) {
        // 注册AppConfig配置类（本质是一个普通的Bean，但其@Bean方法会被ConfigurationClassPostProcessor解析）
        AbstractBeanDefinition appConfigDef = BeanDefinitionBuilder.genericBeanDefinition(AppConfig.class)
                .setScope(ConfigurableBeanFactory.SCOPE_SINGLETON)
                .getBeanDefinition();

        beanFactory.registerBeanDefinition("appConfig", appConfigDef);
        log.info("注册Bean定义 - beanName: appConfig, 类型: " + AppConfig.class.getName());

        // 批量注册业务Bean（简化代码，实际可通过循环或配置类管理）
        String[] beanNames = {"serviceA", "serviceB", "serviceC", "serviceD", "userService", "orderService", "serviceTest"};
        for (String beanName : beanNames) {
            Class<?> beanClass = ClassUtils.resolveClassName(
                    switch (beanName) {
                        case "serviceA" -> "com.dwl.bean_factory_case.BeanFactoryCase$ServiceA";
                        case "serviceB" -> "com.dwl.bean_factory_case.BeanFactoryCase$ServiceB";
                        case "serviceC" -> "com.dwl.bean_factory_case.BeanFactoryCase$ServiceC";
                        case "serviceD" -> "com.dwl.bean_factory_case.BeanFactoryCase$ServiceD";
                        case "userService" -> "com.dwl.bean_factory_case.BeanFactoryCase$UserService";
                        case "orderService" -> "com.dwl.bean_factory_case.BeanFactoryCase$OrderService";
                        case "serviceTest" -> "com.dwl.bean_factory_case.BeanFactoryCase$ServiceTest";
                        default -> throw new IllegalArgumentException("未知Bean类型: " + beanName);
                    },
                    Thread.currentThread().getContextClassLoader()
            );
            AbstractBeanDefinition def = BeanDefinitionBuilder.genericBeanDefinition(beanClass)
                    .getBeanDefinition(); // 默认单例（SCOPE_SINGLETON）
            beanFactory.registerBeanDefinition(beanName, def);
            log.info("注册Bean定义 - beanName: {}, 类型: {}", beanName, beanClass.getName());
        }
    }

    /**
     * 步骤3：注册注解处理后处理器（AnnotationConfigUtils核心逻辑）
     * 底层原理：AnnotationConfigUtils.registerAnnotationConfigProcessors()方法内部通过beanFactory.getBeanDefinitionRegistry()
     * 获取BeanDefinitionRegistry接口（DefaultListableBeanFactory实现了该接口），然后调用registerBeanDefinition()
     * 注册5个关键的BeanFactoryPostProcessor。这些处理器的Bean定义会被提前创建并注册，确保在后续流程中被执行。
     * 关键代码逻辑（源码简化）：
     * public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, Object source) {
     * if (!(registry instanceof DefaultListableBeanFactory)) return;
     * DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) registry;
     * // 注册ConfigurationClassPostProcessor（优先级最高）
     * BeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
     * beanFactory.registerBeanDefinition(ConfigurationClassPostProcessor.class.getName(), def);
     * // 注册AutowiredAnnotationBeanPostProcessor
     * def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
     * beanFactory.registerBeanDefinition(AutowiredAnnotationBeanPostProcessor.class.getName(), def);
     * // ...其他处理器注册逻辑
     * }
     */
    private static void registerAnnotationProcessors(DefaultListableBeanFactory beanFactory) {
        // 打印当前已有的BeanFactoryPostProcessor（初始状态：仅容器自身可能的内置处理器）
        log.info("3. 注册注解处理器前，已存在的BeanFactoryPostProcessor数量：" +
                beanFactory.getBeanDefinitionNames().length);

        String[] front = beanFactory.getBeanDefinitionNames();

        // 调用AnnotationConfigUtils注册内置处理器（关键步骤）
        AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

        // 打印注册后的BeanFactoryPostProcessor（新增5个核心处理器）
        log.info("注册注解处理器后，已存在的BeanFactoryPostProcessor数量：" +
                beanFactory.getBeanDefinitionNames().length);

        String[] after = beanFactory.getBeanDefinitionNames();

        log.info("   新增的核心处理器类名：");
        for (String name : Arrays.stream(after)
                .filter(element -> !Arrays.asList(front).contains(element))
                .toList()) {
            log.info("      " + name);
        }
    }

    /**
     * 步骤4：执行BeanFactoryPostProcessor（解析BeanDefinition的元数据）
     * 底层原理：BeanFactoryPostProcessor的postProcessBeanFactory()方法会被依次调用，核心操作是修改BeanDefinition的属性。
     * 以ConfigurationClassPostProcessor为例，其执行流程如下：
     * 1. 查找所有@Configuration类（通过beanFactory.getBeanNamesForAnnotation(Configuration.class)）
     * 2. 对每个@Configuration类，创建EnhancedConfiguration实例（CGLIB增强类，确保@Bean方法单例）
     * 3. 将原@Configuration类的BeanDefinition替换为EnhancedConfiguration的BeanDefinition（标记为"已解析"）
     * 4. 扫描@Configuration类的@Bean方法，生成对应的BeanDefinition并注册到容器中
     * 注意：此阶段不会创建Bean实例，仅修改BeanDefinition的元数据（如method、factoryBeanName等）。
     */
    private static void processBeanFactoryPostProcessors(DefaultListableBeanFactory beanFactory) {
        log.info("===== 开始执行BeanFactoryPostProcessor =====");
        // 获取所有BeanFactoryPostProcessor并按注册顺序执行（默认顺序）
        beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach(processor -> {
            log.info("执行BeanFactoryPostProcessor: " + processor.getClass().getName());
            try {
                // 调用处理器核心方法，修改BeanDefinition元数据
                processor.postProcessBeanFactory(beanFactory);
            } catch (BeansException e) {
                log.error("BeanFactoryPostProcessor执行失败：" + e.getMessage(), e);
                throw e;
            }
        });
        log.info("===== 完成BeanFactoryPostProcessor执行 =====");
    }

    /**
     * 步骤5：注册并排序BeanPostProcessor（干预Bean生命周期的关键扩展点）
     * 底层原理：BeanPostProcessor的注册分为两步：
     * 1. 收集所有BeanPostProcessor（通过beanFactory.getBeansOfType(BeanPostProcessor.class)）
     * 2. 按AnnotationAwareOrderComparator排序（支持@Order/@Ordered接口）
     * 排序规则：
     * - 实现Ordered接口的处理器，按getOrder()值升序排列（值越小优先级越高）
     * - 标注@Order注解的处理器，按注解的value值排序
     * - 未显式指定顺序的处理器，默认顺序为Ordered.LOWEST_PRECEDENCE（最低优先级）
     * 关键影响：AOP的@Around切面处理器通常需要高优先级（值小），以确保在其他处理器前执行。
     */
    private static void registerBeanPostProcessors(DefaultListableBeanFactory beanFactory) {
        log.info("===== 开始注册BeanPostProcessor =====");

        // 获取所有BeanPostProcessor实例（已通过@Bean或@Autowired注册到容器中的）
        Map<String, BeanPostProcessor> processors = beanFactory.getBeansOfType(BeanPostProcessor.class);
        log.info("原始BeanPostProcessor数量：" + processors.size());

        // 按AnnotationAwareOrderComparator排序（Spring核心排序器）
        List<BeanPostProcessor> sortedProcessors = new ArrayList<>(processors.values());
        sortedProcessors.sort(AnnotationAwareOrderComparator.INSTANCE);

        // 按顺序添加到容器的BeanPostProcessors列表（影响实际执行顺序）
        sortedProcessors.forEach(processor -> {
            log.info("添加BeanPostProcessor: {}（顺序：{}）",
                    processor.getClass().getName(), getOrderValue(processor));
            beanFactory.addBeanPostProcessor(processor); // 直接操作容器的后处理器列表
        });

        log.info("===== 完成BeanPostProcessor注册，当前数量：{} =====", beanFactory.getBeanPostProcessors().size());
    }

    /**
     * 辅助方法：获取BeanPostProcessor的顺序值（兼容Ordered和@Order）
     */
    private static int getOrderValue(BeanPostProcessor processor) {
        if (processor instanceof Ordered) {
            return ((Ordered) processor).getOrder();
        }
        try {
            // 反射获取@Order注解的值（处理未实现Ordered接口但标注@Order的情况）
            Field orderField = processor.getClass().getDeclaredField("order");
            orderField.setAccessible(true);
            return (int) orderField.get(processor);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            return Ordered.LOWEST_PRECEDENCE; // 默认最低优先级
        }
    }

    /**
     * 步骤6：预实例化单例Bean（触发完整的Bean生命周期）
     * 底层原理：preInstantiateSingletons()方法的执行流程如下（源码简化）：
     * public void preInstantiateSingletons() throws BeansException {
     * List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
     * for (String beanName : beanNames) {
     * BeanDefinition bd = this.beanDefinitionMap.get(beanName);
     * if (bd.isSingleton()) {
     * getBean(beanName); // 触发Bean的实例化、注入、初始化
     * }
     * }
     * }
     * 关键调用链：getBean() → doGetBean() → createBean() → instantiateBean()（实例化）→ populateBean()（属性注入）→ initializeBean()（初始化）
     */
    private static void preInstantiateSingletons(DefaultListableBeanFactory beanFactory) {
        log.info("===== 开始预实例化单例Bean =====");
        long startTime = System.currentTimeMillis();
        beanFactory.preInstantiateSingletons(); // 触发所有单例Bean的完整生命周期
        long duration = System.currentTimeMillis() - startTime;
        log.info("===== 完成单例Bean预实例化（耗时：{}ms），已初始化Bean数量：{} =====",
                duration, countInitializedBeans(beanFactory));
    }

    /**
     * 辅助方法：统计已初始化的单例Bean数量（通过singletonObjects缓存判断）
     */
    private static int countInitializedBeans(DefaultListableBeanFactory beanFactory) {
        // 获取容器内部的单例缓存（ConcurrentHashMap<String, Object>）
        try {
            Field singletonObjectsField = DefaultSingletonBeanRegistry.class.getDeclaredField("singletonObjects");
            singletonObjectsField.setAccessible(true);
            Map<String, Object> singletonObjects = (Map<String, Object>) singletonObjectsField.get(beanFactory);
            return singletonObjects.size();
        } catch (NoSuchFieldException | IllegalAccessException e) {
            log.error("获取单例缓存失败：" + e.getMessage(), e);
            return 0;
        }
    }

    /**
     * 步骤7：验证依赖注入效果（@Autowired的工作流程）
     * 底层原理：@Autowired的注入由AutowiredAnnotationBeanPostProcessor处理，其postProcessProperties()方法核心逻辑：
     * 1. 扫描目标Bean的所有字段、方法、参数，查找@Autowired标注的元素
     * 2. 对每个需要注入的元素，解析其依赖类型（考虑泛型）
     * 3. 调用beanFactory.resolveDependency()查找匹配的Bean实例
     * 4. 通过反射将Bean实例注入到目标元素中（Field.set()/Method.invoke()）
     * 关键细节：若依赖的Bean有多个实现（如多个Service实现同一个接口），且未指定@Qualifier，
     * Spring会抛出NoUniqueBeanDefinitionException；若未找到Bean则抛出NoSuchBeanDefinitionException。
     */
    private static void verifyDependencyInjection(DefaultListableBeanFactory beanFactory) {
        log.info("\n===== 验证依赖注入 =====");
        ServiceA serviceA = beanFactory.getBean(ServiceA.class);
        log.info("ServiceA获取成功，其ServiceB实例：" + serviceA.getServiceB());
        // 输出应显示ServiceB已被成功注入（构造日志中可见ServiceB先于ServiceA实例化）
    }

    /**
     * 步骤8：测试混合注解场景（@Autowired + @Resource）
     * 底层原理：@Resource的处理由CommonAnnotationBeanPostProcessor完成，其postProcessBeforeInitialization()方法核心逻辑：
     * 1. 扫描目标Bean的所有字段、方法，查找@Resource标注的元素
     * 2. 对每个@Resource元素，优先使用name属性指定的Bean名称查找（若存在）
     * 3. 若name未指定，则使用字段名或方法参数名作为Bean名称查找
     * 4. 若仍未找到，则按类型查找（与@Autowired类似）
     * 示例中@ServiceTest的userService字段标注了@Resource(name="orderService")，因此会优先查找name="orderService"的Bean，
     * 即使该Bean的类型是OrderService（实现了Service接口），最终注入的是OrderService实例。
     */
    private static void testMixedAnnotationInjection(DefaultListableBeanFactory beanFactory) {
        log.info("\n===== 测试混合注解注入 =====");
        ServiceTest serviceTest = beanFactory.getBean(ServiceTest.class);
        Service injectedService = serviceTest.getService();
        log.info("ServiceTest注入的Service类型：" + injectedService.getClass().getSimpleName() +
                "（预期：OrderService，因@Resource指定了name='orderService'）");
    }

    // ------------------------------ 配置类与Bean定义 ------------------------------
    @Configuration
    static class AppConfig {
        // 配置类本身会被注册为Bean（类型为AnnotationConfigApplicationContext$ConfigurationClassBeanDefinition）
        // @Configuration注解标记此类为配置类，其@Bean方法会被ConfigurationClassPostProcessor解析为BeanDefinition
    }

    static class ServiceA {
        @Autowired
        private ServiceB serviceB; // 依赖ServiceB

        public ServiceA() {
            log.info("【构造】ServiceA实例化（内存地址：" + System.identityHashCode(this) + "）");
        }

        public ServiceB getServiceB() {
            return serviceB;
        }
    }

    static class ServiceB {
        public ServiceB() {
            log.info("【构造】ServiceB实例化（内存地址：" + System.identityHashCode(this) + "）");
        }
    }

    static class ServiceC {
        @Autowired
        private ServiceD serviceD; // 依赖ServiceD

        public ServiceC() {
            log.info("【构造】ServiceC实例化（内存地址：" + System.identityHashCode(this) + "）");
        }

        public ServiceD getServiceD() {
            return serviceD;
        }
    }

    static class ServiceD {
        public ServiceD() {
            log.info("【构造】ServiceD实例化（内存地址：" + System.identityHashCode(this) + "）");
        }
    }

    static class ServiceTest {
        // 混合使用@Autowired（类型匹配）和@Resource(name="orderService")（名称匹配）
        @Autowired
        @Resource(name = "orderService")
        private Service userService;

        public Service getService() {
            return userService;
        }
    }

    interface Service {
    }

    static class UserService implements Service {
        public UserService() {
            log.info("【构造】UserService实例化（内存地址：" + System.identityHashCode(this) + "）");
        }
    }

    static class OrderService implements Service {
        public OrderService() {
            log.info("【构造】OrderService实例化（内存地址：" + System.identityHashCode(this) + "）");
        }
    }


}