Spring Boot 中的各种原理解析说一说
Spring Boot 启动原理
入口点：SpringApplication.run()
1
2
3
4
5
6
| @SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
|
@SpringBootApplication 是一个复合注解：
1
2
3
4
5
6
7
8
9
| @SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
}
)
public @interface SpringBootApplication {}
|
SpringApplication 启动流程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| SpringApplication.run()
↓
new SpringApplication(primarySources).run(args)
↓
[构造阶段] deduceWebApplicationType()
↓
[构造阶段] setInitializers()
↓
[构造阶段] setListeners()
↓
[运行阶段] 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
|
Bean 加载原理
刷新上下文的核心流程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
prepareRefresh();
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
prepareBeanFactory(beanFactory);
try {
postProcessBeanFactory(beanFactory);
invokeBeanFactoryPostProcessors(beanFactory);
registerBeanPostProcessors(beanFactory);
initMessageSource();
initApplicationEventMulticaster();
onRefresh();
registerListeners();
finishBeanFactoryInitialization(beanFactory);
finishRefresh();
}
}
}
|
配置类解析与 Bean 定义注册
invokeBeanFactoryPostProcessors() 是理解 Bean 加载的关键：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| invokeBeanFactoryPostProcessors()
↓
ConfigurationClassPostProcessor.processConfigBeanDefinitions()
↓
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
|
Bean 定义注册源码分析
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata())) {
return;
}
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());
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
processImports(configClass, sourceClass, getImports(sourceClass), true);
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
}
|
Bean 加载中的类继承关系
核心类继承图谱
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| 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 定义
|
BeanFactory 继承体系详解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
public interface BeanFactory {
Object getBean(String name);
<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);
}
public interface HierarchicalBeanFactory extends BeanFactory {
BeanFactory getParentBeanFactory();
}
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);
Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck);
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName);
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName);
}
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();
}
|
Bean 生命周期中的继承协作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| 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 执行 │
└─────────────────────────────────────────────────────────────┘
|
后置处理器继承体系
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
public interface BeanPostProcessor {
default Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
default Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
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;
}
}
public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
default void resetBeanDefinition(String beanName) {}
}
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 事务代理 |
AbstractAutoProxyCreator | AOP 代理创建基类 |
自动配置原理
@EnableAutoConfiguration 工作机制
1
2
3
| @AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| 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
|
条件注解实现
1
2
3
4
5
6
7
| @ConditionalOnClass(DataSource.class)
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(prefix = "spring.datasource", name = "url")
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class HibernateJpaAutoConfiguration {
}
|
条件注解实现原理：SpringBootCondition.matches()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| 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);
}
|
总结
核心流程图
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| ┌─────────────────────────────────────────────────────────────┐
│ 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代理在此) │
└─────────────────────────────────────────────────────────────┘
|
关键设计思想
- 模板方法模式：
AbstractApplicationContext 定义骨架，onRefresh() 等由子类实现 - 策略模式：
BeanPostProcessor 允许自定义 Bean 处理逻辑 - 观察者模式：事件机制 (
ApplicationListener, ApplicationEventMulticaster) - 工厂模式：
BeanFactory 负责 Bean 的创建和管理 - 委托模式：
ApplicationContext 委托给 BeanFactory 处理 Bean
调试技巧
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
java -jar app.jar --debug
@Autowired
private ApplicationContext ctx;
public void printBeans() {
String[] names = ctx.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name + " = " + ctx.getBean(name).getClass());
}
}
@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，而不是停留在 “开箱即用” 的表面。
