Spring Boot 启动

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MySpringBootApp {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApp.class, args);
    }
}

ConfigurationClassPostProcessor
  → postProcessBeanDefinitionRegistry()
    → processConfigBeanDefinitions()
      → doProcessConfigurationClass()
        → 扫描 @ComponentScan
        → 解析 @Import/@Bean
        → 注册成 BeanDefinition 到 BeanFactory

public class MyBean implements ServletContextAware {
    public void setServletContext(ServletContext servletContext) {
        // 注入的 servletContext 可用
    }
}

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory,
        List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // 用于记录已执行过的 Bean 名称，防止重复执行
    Set<String> processedBeans = new HashSet<>();

    // 判断是否支持注册 BeanDefinition 的能力（支持动态注册），如常见的 DefaultListableBeanFactory
    if (beanFactory instanceof BeanDefinitionRegistry registry) {

        // regular：普通 BeanFactoryPostProcessor（不负责注册 BeanDefinition）
        // registry：BeanDefinitionRegistryPostProcessor（负责注册/修改 BeanDefinition）
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        // 先处理开发者手动添加的 BeanFactoryPostProcessor
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) {
                // 立即执行注册方法（扫描/注册新的BeanDefinition）
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            } else {
                regularPostProcessors.add(postProcessor);
            }
        }

        // 当前批次处理器
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // 第一批：容器中实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(
                        beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }

        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();

        // 第二批：实现了 Ordered（但不是 PriorityOrdered）的处理器
        postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName)
                    && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(
                        beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }

        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        currentRegistryProcessors.clear();

        // 第三批：普通无序的 BeanDefinitionRegistryPostProcessor
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(
                            beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }

            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
        }

        // 执行所有 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

        // 执行手动添加的 BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

    } else {
        // 对于不是 BeanDefinitionRegistry 的容器，直接执行传入的 BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // 处理所有容器中还未执行的 BeanFactoryPostProcessor（不是 Registry 的）
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();

    // 分类 PriorityOrdered、Ordered、无序 三批
    for (String ppName : postProcessorNames) {
        if (!processedBeans.contains(ppName)) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(
                        beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            } else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }
    }

    // 执行 PriorityOrdered 的
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 执行 Ordered 的
    List<BeanFactoryPostProcessor> orderedPostProcessors =
            new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(
                beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 执行无序的
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors =
            new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(
                beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // 最后：清除合并的 BeanDefinition 缓存，避免后续创建 Bean 时用到旧数据
    beanFactory.clearMetadataCache();
}

├── 1. 分出手动注册的 PostProcessor 中的 Registry 和 普通类
│     ├── 立即执行手动的 RegistryProcessor
│     └── 留下 regularPostProcessor 暂时不动
│
├── 2. 查找容器中定义的所有 RegistryPostProcessor
│     ├── PriorityOrdered
│     ├── Ordered
│     └── 普通无序
│     ↪ 每一批都执行：registryProcessor.postProcessBeanDefinitionRegistry()
│
├── 3. 执行 registryProcessors 的 postProcessBeanFactory()
├── 4. 执行 regularPostProcessors 的 postProcessBeanFactory()
│
├── 5. 查找所有 BeanFactoryPostProcessor（但不是 Registry 的）
│     ├── PriorityOrdered
│     ├── Ordered
│     └── 无序
│     ↪ 分批执行 postProcessBeanFactory()
│
└── 6. 清理 BeanFactory 的缓存（因 BD 被动态注册/修改）

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    // 1️获取容器中所有 BeanPostProcessor 的名称（此时还没实例化）
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // 计算目标总数 = 当前已注册 + 预计将要注册 + 1（BeanPostProcessorChecker）
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;

    // 注册一个特殊的校验处理器：用于记录哪些 Bean 在所有处理器未注册完就被创建（可能未被增强）
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, postProcessorNames, beanProcessorTargetCount));

    // 初始化分类容器
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();

    // 遍历所有名称，根据是否实现 PriorityOrdered / Ordered 分类
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // 注册 PriorityOrdered 组
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // 注册 Ordered 组
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // 注册无序组
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // 注册 internal 类型（MergedBeanDefinitionPostProcessor，最后执行）
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // 注册 ApplicationListenerDetector，自动识别实现 ApplicationListener 的 bean
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

┌──────────────────────────────┐
│ registerBeanPostProcessors()│
└──────────────┬───────────────┘
               │
               ▼
  获取所有 BeanPostProcessor 名称
               │
               ▼
  添加 BeanPostProcessorChecker（记录日志）
               │
               ▼
   分类处理：
   ├─ PriorityOrdered ➤ 立即实例化 ➤ 排序 ➤ 注册
   ├─ Ordered         ➤ 延迟实例化 ➤ 排序 ➤ 注册
   ├─ 无序            ➤ 延迟实例化 ➤ 注册
   │
   └─ internal (MergedBeanDefinitionPostProcessor)
        ➤ 从上述中筛选出来 ➤ 最后统一排序注册
               │
               ▼
  注册 ApplicationListenerDetector（监听器探测）

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 如果容器中有名为 bootstrapExecutor 的 Executor 类型 Bean，则设置给 BeanFactory 用于启动相关异步任务
    if (beanFactory.containsBean("bootstrapExecutor") && beanFactory.isTypeMatch("bootstrapExecutor", Executor.class)) {
        beanFactory.setBootstrapExecutor((Executor)beanFactory.getBean("bootstrapExecutor", Executor.class));
    }

    // 如果容器中有名为 conversionService 的 ConversionService 类型 Bean，则设置给 BeanFactory 用于类型转换
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }

    // 如果 BeanFactory 没有配置字符串解析器（如占位符解析），则添加一个，支持环境变量和属性占位符替换
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> this.getEnvironment().resolvePlaceholders(strVal));
    }

    // 获取所有实现了 BeanFactoryInitializer 接口的 Bean 的名字，依次调用它们的 initialize 方法进行初始化
    String[] initializerNames = beanFactory.getBeanNamesForType(BeanFactoryInitializer.class, false, false);
    for(String initializerName : initializerNames) {
        ((BeanFactoryInitializer)beanFactory.getBean(initializerName, BeanFactoryInitializer.class)).initialize(beanFactory);
    }

    // 获取所有实现了 LoadTimeWeaverAware 接口的 Bean 的名字，尝试进行初始化（通常用于类加载时织入操作）
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for(String weaverAwareName : weaverAwareNames) {
        try {
            beanFactory.getBean(weaverAwareName, LoadTimeWeaverAware.class);
        } catch (BeanNotOfRequiredTypeException ex) {
            // 如果类型不匹配，输出调试日志
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Failed to initialize LoadTimeWeaverAware bean '" + weaverAwareName +
                    "' due to unexpected type mismatch: " + ex.getMessage());
            }
        }
    }

    // 取消临时类加载器（一般用于类型匹配等特定阶段）
    beanFactory.setTempClassLoader((ClassLoader)null);

    // 锁定配置，不允许再修改 Bean 定义，保证容器配置稳定
    beanFactory.freezeConfiguration();

    // 预实例化所有非延迟加载的单例 Bean，触发它们的构造和初始化流程
    beanFactory.preInstantiateSingletons();
}

@Component
class MyService {
    @Autowired
    private MyRepository repository;
    public void doSomething() {
        System.out.println("Use repository: " + repository);
    }
}

@Component
class MyRepository {
}

@Component
public class MyListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("容器刷新完毕，可启动业务逻辑！");
    }
}

@Component
public class BeanDefinitionRegistryLogger implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        System.out.println("---- 所有注册的 Bean 名称 ----");
        for (String name : registry.getBeanDefinitionNames()) {
            System.out.println(name);
        }
        System.out.println("-------------------------");
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 无操作
    }
}

@Component
public class AutowiredInjectionChecker implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Field[] fields = bean.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Autowired.class)) {
                field.setAccessible(true);
                try {
                    Object value = field.get(bean);
                    System.out.printf("Bean [%s], 字段 [%s] 注入值: %s%n", beanName, field.getName(), value);
                } catch (IllegalAccessException e) {
                    System.err.println("无法访问字段: " + field.getName());
                }
            }
        }
        return bean;
    }
}

@Component
public class BusinessBeanLifecycleLogger implements BeanPostProcessor {
    private static final Set<String> interestedBeans = Set.of("myService", "orderManager", "userRepository");

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (interestedBeans.contains(beanName)) {
            System.out.println("业务Bean初始化开始: " + beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (interestedBeans.contains(beanName)) {
            System.out.println("业务Bean初始化完成: " + beanName + ", 实例: " + bean);
        }
        return bean;
    }
}

Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
invokeInitMethods(beanName, wrappedBean, mbd);
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);