Spring Boot 中的各种原理解析说一说

1. Spring Boot 启动原理

1.1 入口点：SpringApplication.run()

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@SpringBootApplication 是一个复合注解：

@SpringBootConfiguration  // 继承 @Configuration
@EnableAutoConfiguration  // 开启自动配置
@ComponentScan(
    excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
    }
)
public @interface SpringBootApplication {}

1.2 SpringApplication 启动流程

SpringApplication.run()
    ↓
new SpringApplication(primarySources).run(args)
    ↓
[构造阶段] deduceWebApplicationType()   // 推断应用类型 (Servlet/Reactive/None)
    ↓
[构造阶段] setInitializers()            // 加载 ApplicationContextInitializer
    ↓
[构造阶段] setListeners()               // 加载 ApplicationListener
    ↓
[运行阶段] run()
    ├─ 1. 启动计时器 (StartupInfoLogger)
    ├─ 2. 获取 SpringApplicationRunListeners
    ├─ 3. 发布 ApplicationStartingEvent
    ├─ 4. 准备环境 (prepareEnvironment)
    │      ├─ 加载配置文件 (application.properties/yml)
    │      ├─ 加载系统环境变量
    │      └─ 发布 ApplicationEnvironmentPreparedEvent
    ├─ 5. 打印 Banner
    ├─ 6. 创建 ApplicationContext
    │      ├─ Servlet: AnnotationConfigServletWebServerApplicationContext
    │      └─ Reactive: AnnotationConfigReactiveWebServerApplicationContext
    ├─ 7. 准备 Context (prepareContext)
    │      ├─ 执行 Initializers
    │      ├─ 加载主类作为 Configuration
    │      └─ 发布 ApplicationPreparedEvent
    ├─ 8. 刷新 Context (refreshContext) ← **核心：Bean 加载在此完成**
    ├─ 9. 启动 WebServer (如果是 Web 应用)
    ├─ 10. 发布 ApplicationStartedEvent
    ├─ 11. 执行 CommandLineRunner / ApplicationRunner
    └─ 12. 发布 ApplicationReadyEvent

2. Bean 加载原理

2.1 刷新上下文的核心流程

// AbstractApplicationContext.refresh()
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1. 准备刷新
        prepareRefresh();
        
        // 2. 获取/刷新 BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        
        // 3. 准备 BeanFactory
        prepareBeanFactory(beanFactory);
        
        try {
            // 4. 子类扩展点 (空实现，供子类重写)
            postProcessBeanFactory(beanFactory);
            
            // 5. 执行 BeanFactoryPostProcessor
            invokeBeanFactoryPostProcessors(beanFactory);
            
            // 6. 注册 BeanPostProcessor
            registerBeanPostProcessors(beanFactory);
            
            // 7. 初始化 MessageSource
            initMessageSource();
            
            // 8. 初始化 ApplicationEventMulticaster
            initApplicationEventMulticaster();
            
            // 9. 子类扩展：初始化 WebServer (ServletWebServerApplicationContext)
            onRefresh();
            
            // 10. 注册事件监听器
            registerListeners();
            
            // 11. 实例化所有非懒加载的单例 Bean
            finishBeanFactoryInitialization(beanFactory);
            
            // 12. 完成刷新，发布 ContextRefreshedEvent
            finishRefresh();
        }
        // ... catch 和 finally
    }
}

2.2 配置类解析与 Bean 定义注册

invokeBeanFactoryPostProcessors() 是理解 Bean 加载的关键：

invokeBeanFactoryPostProcessors()
    ↓
ConfigurationClassPostProcessor.processConfigBeanDefinitions()
    ↓
// 解析所有 @Configuration 类
ConfigurationClassParser.parse()
    ├─ 1. 处理 @ComponentScan
    │      ↓
    │      ComponentScanAnnotationParser.parse()
    │      ↓
    │      ClassPathBeanDefinitionScanner.doScan()
    │      ↓
    │      扫描 classpath，将 @Component 类注册为 BeanDefinition
    │
    ├─ 2. 处理 @Import
    │      ↓
    │      递归处理 ImportSelector / ImportBeanDefinitionRegistrar
    │      @EnableAutoConfiguration 就是在这里加载的
    │      ↓
    │      AutoConfigurationImportSelector.selectImports()
    │      读取 META-INF/spring.factories 中的自动配置类
    │
    ├─ 3. 处理 @ImportResource (XML 配置)
    │
    └─ 4. 处理 @Bean 方法
           ↓
           ConfigurationClassBeanDefinitionReader.loadBeanDefinitions()
           ↓
           将 @Bean 方法解析为 BeanDefinition

2.3 Bean 定义注册源码分析

// ConfigurationClassParser.java
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    // 1. 条件注解判断 (@Conditional)
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata())) {
        return;
    }
    
    // 2. 处理 @ComponentScan
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils
        .attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class);
    if (!componentScans.isEmpty()) {
        for (AnnotationAttributes componentScan : componentScans) {
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                this.componentScanParser.parse(componentScan, sourceClass.getMetadata());
            // 递归检查扫描到的类是否也是 @Configuration
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                parse(bdCand.getBeanClassName(), holder.getBeanName());
            }
        }
    }
    
    // 3. 处理 @Import
    processImports(configClass, sourceClass, getImports(sourceClass), true);
    
    // 4. 处理 @Bean 方法
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }
}

3. Bean 加载中的类继承关系

3.1 核心类继承图谱

Object
  └── BeanFactory (接口)                    ← 最顶层，定义获取 Bean 的基本方法
       └── HierarchicalBeanFactory (接口)   ← 支持层级结构
            └── AutowireCapableBeanFactory (接口)  ← 支持自动装配
                 └── ConfigurableListableBeanFactory (接口) ← 可配置、可列表
                      └── DefaultListableBeanFactory         ← 标准实现

Object
  └── ApplicationContext (接口)             ← 应用上下文接口
       └── ConfigurableApplicationContext (接口) ← 可配置
            └── AbstractApplicationContext    ← 骨架实现
                 └── GenericApplicationContext
                      └── AnnotationConfigApplicationContext
                      └── ServletWebServerApplicationContext
                           └── AnnotationConfigServletWebServerApplicationContext

Object
  └── BeanDefinition                         ← Bean 定义抽象
       ├── AnnotatedBeanDefinition           ← 注解方式
       │    └── ScannedGenericBeanDefinition ← @Component 扫描
       │    └── ConfigurationClassBeanDefinition ← @Configuration 类
       └── AbstractBeanDefinition
            └── RootBeanDefinition           ← 最终的 Bean 定义
            └── GenericBeanDefinition        ← 通用的 Bean 定义

3.2 BeanFactory 继承体系详解

// ========== 1. BeanFactory - 根接口 ==========
public interface BeanFactory {
    Object getBean(String name);                          // 核心：按名称获取 Bean
    <T> T getBean(String name, Class<T> requiredType);    // 按名称和类型获取
    <T> T getBean(Class<T> requiredType);                 // 按类型获取
    boolean containsBean(String name);                    // 是否包含
    boolean isSingleton(String name);                     // 是否单例
    boolean isPrototype(String name);                     // 是否原型
}

// ========== 2. HierarchicalBeanFactory - 层级支持 ==========
public interface HierarchicalBeanFactory extends BeanFactory {
    BeanFactory getParentBeanFactory();  // 父容器，用于分层架构
}

// ========== 3. AutowireCapableBeanFactory - 自动装配能力 ==========
public interface AutowireCapableBeanFactory extends BeanFactory {
    int AUTOWIRE_NO = 0;          // 不自动装配
    int AUTOWIRE_BY_NAME = 1;     // 按名称装配
    int AUTOWIRE_BY_TYPE = 2;     // 按类型装配
    int AUTOWIRE_CONSTRUCTOR = 3; // 按构造器装配
    
    <T> T createBean(Class<T> beanClass);                    // 创建 Bean
    Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck);
    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName);
    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName);
}

// ========== 4. ConfigurableListableBeanFactory - 完整能力 ==========
public interface ConfigurableListableBeanFactory 
    extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
    
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
    void registerSingleton(String beanName, Object singletonObject);
    void registerResolvableDependency(Class<?> dependencyType, Object autowiredValue);
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    Iterator<String> getBeanNamesIterator();
    void freezeConfiguration();
    boolean isConfigurationFrozen();
}

3.3 Bean 生命周期中的继承协作

Bean 生命周期 (AbstractAutowireCapableBeanFactory.doCreateBean)

┌─────────────────────────────────────────────────────────────┐
│  阶段 1: 实例化 (Instantiation)                              │
│  ├─ createBeanInstance()                                    │
│  │   ├─ 推断构造器 (SmartInstantiationAwareBeanPostProcessor) │
│  │   └─ instantiateBean() 或 autowireConstructor()          │
│  └─ 此时：对象已创建，但未注入依赖                            │
├─────────────────────────────────────────────────────────────┤
│  阶段 2: 属性赋值 (Populate)                                  │
│  ├─ populateBean()                                          │
│  │   ├─ InstantiationAwareBeanPostProcessor.postProcessProperties() │
│  │   └─ applyPropertyValues()                               │
│  │       ├─ @Autowired 解析                                 │
│  │       ├─ @Value 解析                                     │
│  │       └─ @Resource 解析                                  │
│  └─ 此时：依赖已注入，但尚未初始化                           │
├─────────────────────────────────────────────────────────────┤
│  阶段 3: 初始化 (Initialization)                              │
│  ├─ initializeBean()                                        │
│  │   ├─ BeanPostProcessor.postProcessBeforeInitialization() │
│  │   │   └─ @PostConstruct 执行 (InitDestroyAnnotationBeanPostProcessor) │
│  │   ├─ InitializingBean.afterPropertiesSet()               │
│  │   ├─ init-method 执行                                    │
│  │   └─ BeanPostProcessor.postProcessAfterInitialization()  │
│  │       └─ AOP 代理在此创建                                 │
│  └─ 此时：Bean 完全就绪                                      │
├─────────────────────────────────────────────────────────────┤
│  阶段 4: 销毁 (Destruction)                                   │
│  └─ 容器关闭时                                               │
│      ├─ @PreDestroy 执行                                     │
│      ├─ DisposableBean.destroy()                             │
│      └─ destroy-method 执行                                  │
└─────────────────────────────────────────────────────────────┘

3.4 后置处理器继承体系

// BeanPostProcessor - Bean 后置处理器 (所有 Bean 都会经过)
public interface BeanPostProcessor {
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

// InstantiationAwareBeanPostProcessor - 扩展实例化阶段
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        return null;
    }
    default boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true;
    }
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        return null;
    }
}

// MergedBeanDefinitionPostProcessor - 合并 BeanDefinition 阶段
public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
    void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
    default void resetBeanDefinition(String beanName) {}
}

// SmartInstantiationAwareBeanPostProcessor - 智能实例化 (预测类型、确定构造器)
public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
    default Class<?> predictBeanType(Class<?> beanClass, String beanName) {
        return null;
    }
    default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) {
        return null;
    }
    default Object getEarlyBeanReference(Object bean, String beanName) {
        return bean;
    }
}

关键实现类：

后置处理器作用
AutowiredAnnotationBeanPostProcessor处理 @Autowired, @Value 注入
CommonAnnotationBeanPostProcessor处理 @Resource, @PostConstruct, @PreDestroy
AsyncAnnotationBeanPostProcessor处理 @Async 异步代理
TransactionalProxyFactoryBean处理 @Transactional 事务代理
AbstractAutoProxyCreatorAOP 代理创建基类

4. 自动配置原理

4.1 @EnableAutoConfiguration 工作机制

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}
AutoConfigurationImportSelector
    ↓
selectImports()
    ↓
getAutoConfigurationEntry()
    ├─ 1. 读取 META-INF/spring.factories
    │   键：org.springframework.boot.autoconfigure.EnableAutoConfiguration
    │   值：所有自动配置类全限定名列表
    │
    ├─ 2. 去重 (removeDuplicates)
    │
    ├─ 3. 排除 (getExclusions)
    │   ├─ @EnableAutoConfiguration(exclude = {...})
    │   └─ spring.autoconfigure.exclude
    │
    └─ 4. 过滤 (filter)
        ↓
        OnClassCondition.checkCandidates()
        ↓
        @ConditionalOnClass / @ConditionalOnMissingClass

4.2 条件注解实现

@ConditionalOnClass(DataSource.class)  // 类路径有 DataSource 才生效
@ConditionalOnMissingBean(DataSource.class)  // 容器中没有 DataSource Bean 才生效
@ConditionalOnProperty(prefix = "spring.datasource", name = "url")  // 配置存在才生效
@AutoConfigureAfter(DataSourceAutoConfiguration.class)  // 在指定配置之后
public class HibernateJpaAutoConfiguration {
    // ...
}

条件注解实现原理：SpringBootCondition.matches()

public abstract class SpringBootCondition implements Condition {
    @Override
    public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String classOrMethodName = getClassOrMethodName(metadata);
        try {
            ConditionOutcome outcome = getMatchOutcome(context, metadata);
            logOutcome(classOrMethodName, outcome);
            recordEvaluation(context, classOrMethodName, outcome);
            return outcome.isMatch();
        }
        catch (NoClassDefFoundError ex) {
            throw new IllegalStateException("Could not evaluate condition...", ex);
        }
    }
    
    public abstract ConditionOutcome getMatchOutcome(ConditionContext context, 
                                                      AnnotatedTypeMetadata metadata);
}

5. 总结

5.1 核心流程图

┌─────────────────────────────────────────────────────────────┐
│                    Spring Boot 启动                          │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│  @SpringBootApplication                                      │
│  ├─ @SpringBootConfiguration  → @Configuration              │
│  ├─ @EnableAutoConfiguration  → 加载 META-INF/spring.factories │
│  └─ @ComponentScan            → 扫描当前包及子包              │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│              SpringApplication.run()                         │
│  ├─ 创建 SpringApplication (推断类型、加载初始化器)           │
│  └─ 运行 run() 方法                                          │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│              AbstractApplicationContext.refresh()            │
│  ├─ obtainFreshBeanFactory()  → 获取 BeanFactory             │
│  ├─ invokeBeanFactoryPostProcessors() → 解析配置类           │
│  │   └─ ConfigurationClassPostProcessor                     │
│  │       ├─ 处理 @ComponentScan                             │
│  │       ├─ 处理 @Import (包括自动配置)                      │
│  │       └─ 处理 @Bean 方法                                  │
│  ├─ registerBeanPostProcessors() → 注册后置处理器            │
│  ├─ onRefresh()               → 启动 WebServer               │
│  └─ finishBeanFactoryInitialization() → 实例化所有单例 Bean  │
│      └─ DefaultListableBeanFactory.preInstantiateSingletons()│
│          └─ AbstractAutowireCapableBeanFactory.doCreateBean()│
│              ├─ createBeanInstance()  → 实例化               │
│              ├─ populateBean()        → 属性赋值             │
│              └─ initializeBean()      → 初始化               │
│                  └─ BeanPostProcessor (AOP代理在此)          │
└─────────────────────────────────────────────────────────────┘

5.2 关键设计思想

  1. 模板方法模式：AbstractApplicationContext 定义骨架，onRefresh() 等由子类实现
  2. 策略模式：BeanPostProcessor 允许自定义 Bean 处理逻辑
  3. 观察者模式：事件机制 (ApplicationListener, ApplicationEventMulticaster)
  4. 工厂模式：BeanFactory 负责 Bean 的创建和管理
  5. 委托模式：ApplicationContext 委托给 BeanFactory 处理 Bean

5.3 调试技巧

# 1. 查看自动配置报告
java -jar app.jar --debug
# 或 application.properties: debug=true

# 2. 查看 Bean 定义
@Autowired
private ApplicationContext ctx;

public void printBeans() {
    String[] names = ctx.getBeanDefinitionNames();
    for (String name : names) {
        System.out.println(name + " = " + ctx.getBean(name).getClass());
    }
}

# 3. 查看 Bean 生命周期
@Component
public class BeanLifecycleLogger implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("Before init: " + beanName);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("After init: " + beanName);
        return bean;
    }
}

理解这些原理，才能真正掌握 Spring Boot，而不是停留在 “开箱即用” 的表面。