注意，看完这篇文章需要很长很长很长时间。。。
准备工作
本文会基于注解的方向分析SpringIOC模块的整体流程，在阅读本篇文章之前建议您先阅读基于XML分析的两篇文章: SpringIOC源码解析(上)，SpringIOC源码解析(下)
Demo工程
本次源码分析的demo工程我已经准备好了，大家可自行前往以下地址下载
- 1
| - https://github.com/shiyujun/spring-framework
|
本次工程复用了之前工程的包cn.shiyujun.service中的接口和实现类，同时新增了一个基于注解的配置类，此类在cn.shiyujun.config包下
- 1
2
3
4
5
6
7
| - @Configuration
public class AnnotationConfig {
@Bean
public IOCService iocService(){
return new IOCServiceImpl();
}
}
|
然后就是启动类了，启动类在cn.shiyujun.demo包下
- 1
2
3
4
5
6
7
| - public class AnnotationIOCDemo {
public static void main (String args[]){
ApplicationContext context = new AnnotationConfigApplicationContext(“cn.shiyujun.config”);
IOCService iocService=context.getBean(IOCService.class);
System.out.println(iocService.hollo());
}
}
|
AnnotationConfigApplicationContext继承关系
再次拿出之前的一张图片，可以看到相较于ClassPathXmlApplicationContext和FileSystemXmlApplicationContext来说AnnotationConfigApplicationContext这个类的辈分好像更高一些
接着我们看一下它的方法
我们会发现除了register注册bean的方法以外，有一个scan方法，有没有感觉很熟悉。@CompantScan用过没，他们之间什么关系，在启动类中new AnnotationConfigApplicationContext的时候传的一个包名是不是跟这个有关系？带着疑问往下看吧
源码分析
构造方法
源码分析第一站就是进入如下构造方法
- 1
2
3
4
5
| - public AnnotationConfigApplicationContext(String… basePackages) {
this();
scan(basePackages);
refresh();
}
|
千万不要小瞧上方简简单单的三行代码，我们整篇文章都会基于这三行代码来展开
首先看this
- 1
2
3
4
5
6
| - public AnnotationConfigApplicationContext() {
//注解bean读取器
this.reader = new AnnotatedBeanDefinitionReader(this);
//注解bean扫描器
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
|
同时子类的构造方法执行之前肯定会先执行父类的构造方法，所以还有父类
GenericApplicationContext的构造方法
- 1
2
3
4
| - public GenericApplicationContext() {
//这个bean的相关知识请参考之前的文章
this.beanFactory = new DefaultListableBeanFactory();
}
|
注册bean
接着看scan方法
- 1
2
3
4
| - public void scan(String… basePackages) {
Assert.notEmpty(basePackages, “At least one base package must be specified”);
this.scanner.scan(basePackages);
}
|
可以看到这里调用的是bean扫描器ClassPathBeanDefinitionScanner的scan方法
- 1
2
3
4
5
6
7
8
9
10
11
12
13
| - public int scan(String… basePackages) {
//获取当前注册bean的数量
int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
//往下看
doScan(basePackages);
if (this.includeAnnotationConfig) {
//注册配置处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
//返回此次注册的数量
return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}
|
接着往下看doScan方法
- 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
| - protected Set<BeanDefinitionHolder> doScan(String… basePackages) {
Assert.notEmpty(basePackages, “At least one base package must be specified”);
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
//遍历需要扫描的包路径
for (String basePackage : basePackages) {
//先跟进去看，下面的方法先忽略
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
|
扫描包
- 1
2
3
4
5
6
7
8
9
10
|
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
//判断是否使用Filter指定忽略包不扫描
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
//扫描包
return scanCandidateComponents(basePackage);
}
|
在接着往下看之前，我们有必要先认识一个东东，MetadataReader。这个接口有三个方法
- 1
2
3
4
5
6
7
8
9
| - public interface MetadataReader {
Resource getResource();
ClassMetadata getClassMetadata();
AnnotationMetadata getAnnotationMetadata();
}
|
第一个返回Resource就不必多说了，就是配置类的资源对象。第二个第三个根据名字我们可以猜到是类的元数据和注解的元数据
可以看一下它们两个的方法
接着往下看
- 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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| - private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
//组装扫描路径（组装完成后是这种格式：classpath:cn/shiyujun/config/**/.class）
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + ‘/‘ + this.resourcePattern;
//根据路径获取资源对象
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace(“Scanning “ + resource);
}
if (resource.isReadable()) {
try {
//根据资源对象通过反射获取资源对象的MetadataReader，具体就不展开说了
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//查看配置类是否有@Conditional一系列的注解，然后是否满足注册Bean的条件，关于这个知识点可以参考我之前的文章：https://mp.weixin.qq.com/s/RXYIh_g5iU1e3liK-8n5zA
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug(“Identified candidate component class: “ + resource);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug(“Ignored because not a concrete top-level class: “ + resource);
}
}
}
else {
if (traceEnabled) {
logger.trace(“Ignored because not matching any filter: “ + resource);
}
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
“Failed to read candidate component class: “ + resource, ex);
}
}
else {
if (traceEnabled) {
logger.trace(“Ignored because not readable: “ + resource);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(“I/O failure during classpath scanning”, ex);
}
return candidates;
}
|
创建BeanDefinition
现在回到开始的doScan方法
- 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
| - protected Set<BeanDefinitionHolder> doScan(String… basePackages) {
Assert.notEmpty(basePackages, “At least one base package must be specified”);
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
//遍历需要扫描的包路径
for (String basePackage : basePackages) {
//获取所有符合条件的BeanDefinition
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
//绑定BeanDefinition与Scope
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
//查看是否配置类是否指定bean的名称，如没指定则使用类名首字母小写
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
//下面两个if是处理lazy、Autowire、DependencyOn、initMethod、enforceInitMethod、destroyMethod、enforceDestroyMethod、Primary、Role、Description这些逻辑的
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//检查bean是否存在
if (checkCandidate(beanName, candidate)) {
//又包装了一层
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
//检查scope是否创建，如未创建则进行创建
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//重点来了，往下看
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
|
注册bean
到了一个比较重要的节点了，跟着上文的registerBeanDefinition方法走
- 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| - protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
String beanName = definitionHolder.getBeanName();
// 注册bean，往下看
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//如果存在别名则循环注册别名，逻辑跟上方差不多，就不展开了
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias: aliases) {
registry.registerAlias(beanName, alias);
}
}
}
|
其实这个注册bean的方法是DefaultListableBeanFactory的方法，之前的文章已经解析过了，大体就是下面这么个流程
- 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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
| - @Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, “Bean name must not be empty”);
Assert.notNull(beanDefinition, “BeanDefinition must not be null”);
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(…);
}
}
BeanDefinition oldBeanDefinition;
// 所有的 Bean 注册后都会被放入到这个beanDefinitionMap 中，查看是否已存在这个bean
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
// 处理重复名称的 Bean 定义的情况
if (oldBeanDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
// 如果不允许覆盖的话，抛异常
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
“Cannot register bean definition [“ + beanDefinition + “] for bean ‘“ + beanName +
“‘: There is already [“ + oldBeanDefinition + “] bound.”);
}
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// 用框架定义的 Bean 覆盖用户自定义的 Bean
if (this.logger.isWarnEnabled()) {
this.logger.warn(“Overriding user-defined bean definition for bean ‘“ + beanName +
“‘ with a framework-generated bean definition: replacing [“ +
oldBeanDefinition + “] with [“ + beanDefinition + “]”);
}
}
else if (!beanDefinition.equals(oldBeanDefinition)) {
// 用新的 Bean 覆盖旧的 Bean
if (this.logger.isWarnEnabled()) {
this.logger.warn(“Overriding user-defined bean definition for bean ‘“ + beanName +
“‘ with a framework-generated bean definition: replacing [“ +
oldBeanDefinition + “] with [“ + beanDefinition + “]”);
}
}
else {
// log…用同等的 Bean 覆盖旧的 Bean
if (this.logger.isInfoEnabled()) {
this.logger.info(“Overriding bean definition for bean ‘“ + beanName +
“‘ with a different definition: replacing [“ + oldBeanDefinition +
“] with [“ + beanDefinition + “]”);
}
}
// 覆盖
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
// 判断是否已经有其他的 Bean 开始初始化了.注意，“注册Bean” 这个动作结束，Bean 依然还没有初始化 在 Spring 容器启动的最后，会 预初始化 所有的 singleton beans
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// 将 BeanDefinition 放到这个 map 中，这个 map 保存了所有的 BeanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
// 这是个 ArrayList，所以会按照 bean 配置的顺序保存每一个注册的 Bean 的名字
this.beanDefinitionNames.add(beanName);
// 这是个 LinkedHashSet，代表的是手动注册的 singleton bean，
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
|
现在回到文章开始的三句代码
- 1
2
3
4
5
| - public AnnotationConfigApplicationContext(String… basePackages) {
this();
scan(basePackages);
refresh();
}
|
可以看到，只剩最后一个refresh()方法了，如果看过之前文章的同学可能都已经知道这里面是什么东西了
refresh()
首先整个方法进来以后跟使用XML的时候是一样的
- 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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| - public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 记录容器的启动时间、标记“已启动”状态、检查环境变量
prepareRefresh();
// 初始化BeanFactory容器、注册BeanDefinition
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
prepareBeanFactory(beanFactory);
try {
// 扩展点
postProcessBeanFactory(beanFactory);
// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
invokeBeanFactoryPostProcessors(beanFactory);
// 注册 BeanPostProcessor 的实现类
registerBeanPostProcessors(beanFactory);
// 初始化MessageSource
initMessageSource();
// 初始化事件广播器
initApplicationEventMulticaster();
// 扩展点
onRefresh();
// 注册事件监听器
registerListeners();
// 初始化所有的 singleton beans
finishBeanFactoryInitialization(beanFactory);
// 广播事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn(“Exception encountered during context initialization - “ +
“cancelling refresh attempt: “ + ex);
}
// 销毁已经初始化的的Bean
destroyBeans();
// 设置 ‘active’ 状态
cancelRefresh(ex);
throw ex;
}
finally {
// 清除缓存
resetCommonCaches();
}
}
}
|
与XML的不同点
obtainFreshBeanFactory()方法
还记得在之前的文章中列出了好几万行代码来解析这个方法，但是回忆一个这个方法是干啥的来着，创建bean容器，但是呢，bean容器在scan方法里就已经创建好了，所以这里就没必要再进行额外的逻辑了，你看现在它的代码现在多简单
- 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| - protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug(“Bean factory for “ + getDisplayName() + “: “ + beanFactory);
}
return beanFactory;
}
protected final void refreshBeanFactory() throws IllegalStateException {
if (!this.refreshed.compareAndSet(false, true)) {
throw new IllegalStateException(
“GenericApplicationContext does not support multiple refresh attempts: just call ‘refresh’ once”);
}
this.beanFactory.setSerializationId(getId());
}
|
再接下来，其实就没了，有一个重点就是初始化，但是初始化逻辑是放在这个Spring家族的超级富二代DefaultListableBeanFactory身上的。
心得体会
源码阅读入门很难，面对几十兆几百兆的代码不是一时半会就能看明白的，也不是一遍两遍debug就能搞懂的。阅读源码，一定要静下心来花上几个小时甚至几天的时间来钻研。
一通百通，当你研究明白一部分以后，再去看另外的部分，就好像有人推着你走一样，无比的顺利
不得不看
1.SpringCloud系列博客汇总
2.为啥一线大厂面试必问Redis，有啥好问的？
3.Java多线程面试必备基础知识汇总
4.Java集合源码分析汇总
5.Linux常用命令汇总
6.JVM系列文章汇总
7.MySQL系列文章汇总
8.RabbitMQ系列文章汇总
雨点打透心脏的1/2处
小鱼儿
还没有评论，来说两句吧...