看源码
- 好处:提高培养代码架构思维、深入理解框架
- 原则
- 定焦原则:抓主线,比如BeanFactory的创建流程、Bean对象创建流程、lazy-int延迟加载流程、SpringIoc循环依赖原理,其他的不关心
- 宏观原则:站在上帝视角,关注源码结构和业务流程(淡化具体某行代码的编写细节),不需要扣太细,不然读不下去
- 读源码的方法和技巧
- 断点(观察调用栈)
- 反调(Find Usages),不知道改方法在哪个地方被调用了,右键find Usages
- 经验(spring框架中doXXX,做具体处理的地方)
- Spring源码构建
- 下载源码(github)
- 安装gradle 5.6.3(类似于maven) Idea 2019.1 Jdk 11.0.5
- 导入(耗费一定时间)
- 编译工程(顺序:core-oxm-context-beans-aspects-aop)工程—>tasks—>compileTestJava
一、Spring IoC容器初始化主体流程
1.1、Spring IoC的容器体系
IoC容器是Spring的核心模块,是抽象了对象管理、依赖关系管理的框架解决方案。Spring 提供了很多的容器,其中 BeanFactory 是顶层容器(根容器),不能被实例化,它定义了所有 IoC 容器必须遵从的一套原则,具体的容器实现可以增加额外的功能,比如我们常用到的ApplicationContext,其下更具体的实现如 ClassPathXmlApplicationContext 包含了解析 xml 等一系列的内容,AnnotationConfigApplicationContext 则是包含了注解解析等一系列的内容。Spring IoC 容器继承体系非常聪明,需要使用哪个层次用哪个层次即可,不必使用功能大而全的。
ApplicationContext是容器的高级接口,BeanFacotry(顶级容器/根容器,规范了/定义了容器的基础行为) Spring应用上下文,官方称之为 IoC容器(错误的认识:容器就是map而已;准确来说,map是ioc容器的一个成员, 叫做单例池,singletonObjects。容器是一组组件和过程的集合,包括BeanFactory、单例池、BeanPostProcessor等以及之间的协作流程)
BeanFactory
顶级接口方法栈如下:
BeanFactory 容器继承体系:
![](https://img-blog.csdnimg.cn/20200305194627504.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
通过其接口设计,我们可以看到我们一贯使用的
ApplicationContext
除了继承
BeanFactory
的子接口,还继承了ResourceLoader
、
MessageSource
等接口,因此其提供的功能也就更丰富了。下面我们以 ClasspathXmlApplicationContext
为例,深入源码说明
IoC
容器的初始化流程。
1.2、Bean生命周期关键时机点
思路:
创建一个类
LagouBean
,让其实现几个特殊的接口,并分别在接口实现的构造器、接口方法中断点,观察线程调用栈(调用了哪个类的哪个方法,分析出Bean
对象创建和管理关键点的触发时机。
LagouBean
package com.lagou.edu;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class LagouBean implements InitializingBean, ApplicationContextAware {
/*private ItBean itBean;
public void setItBean(ItBean itBean) {
this.itBean = itBean;
}*/
private int num;
public void setNum(int num) {
this.num = num;
}
/**
* 构造函数
*/
public LagouBean(){
System.out.println("LagouBean 构造器...");
}
/**
* InitializingBean 接口实现
*/
public void afterPropertiesSet() throws Exception {
System.out.println("LagouBean InitializingBean#afterPropertiesSet...");
}
public void print() {
System.out.println("print方法业务逻辑执行");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("setApplicationContext....");
}
/**
* BeanFactoryPostProcessor的实现类构造函数...
* BeanFactoryPostProcessor的实现方法调用中......
* BeanPostProcessor 实现类构造函数...
* LagouBean 构造器...
* setApplicationContext....
* BeanPostProcessor 实现类 postProcessBeforeInitialization 方法被调用中......
* LagouBean afterPropertiesSet...
* BeanPostProcessor 实现类 postProcessAfterInitialization 方法被调用中......
* com.lagou.edu.LagouBean@6ad3381f
*/
}
BeanPostProcessor 接口实现类
package com.lagou.edu;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor() {
System.out.println("BeanPostProcessor 实现类构造函数...");
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if("lagouBean".equals(beanName)) {
System.out.println("BeanPostProcessor 实现类 postProcessBeforeInitialization 方法被调用中......");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if("lagouBean".equals(beanName)) {
System.out.println("BeanPostProcessor 实现类 postProcessAfterInitialization 方法被调用中......");
}
return bean;
}
}
BeanFactoryPostProcessor接口实现类
package com.lagou.edu;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor() {
System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("BeanFactoryPostProcessor的实现方法调用中......");
}
}
测试:
import com.lagou.edu.LagouBean;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocTest {
/**
* Ioc 容器源码分析基础案例
*/
@Test
public void testIoC() {
// ApplicationContext是容器的高级接口,BeanFacotry(顶级容器/根容器,规范了/定义了容器的基础行为)
// Spring应用上下文,官方称之为 IoC容器(错误的认识:容器就是map而已;准确来说,map是ioc容器的一个成员,
// 叫做单例池, singletonObjects,容器是一组组件和过程的集合,包括BeanFactory、单例池、BeanPostProcessor等以及之间的协作流程)
/**
* Ioc容器创建管理Bean对象的,Spring Bean是有生命周期的,在特殊方法打断点可知
* bean构造函数执行、初始化方法执行 、Bean后置处理器的before/after方法:AbstractApplicationContext#refresh()#finishBeanFactoryInitialization()
*
* Bean工厂后置处理器构造函数执行、Bean工厂后置处理器方法执行:AbstractApplicationContext#refresh()#invokeBeanFactoryPostProcessors()
*
* Bean后置处理器构造函数执行:AbstractApplicationContext#refresh()#registerBeanPostProcessors()
*/
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
System.out.println(lagouBean);
}
}
1.3、Spring IoC容器初始化主流程
由上分析可知,
Spring IoC
容器初始化的关键环节就在
AbstractApplicationContext#refresh() 方
法中,我们查看 refresh 方
法来俯瞰容器创建的主体流程,主体流程下的具体子流程我们后面再一一来讨论。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
/**
* 第⼀步:刷新前的预处理
* 表示在真正刷新之前需要准备做的事情:
* 设置sping容器的启动时间
* 开启活跃状态,撤销关闭状态
* 验证环境信息里一些必要的属性
*/
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
/**
* 第⼆步:获取BeanFactory,有了bean工厂才能创建bean,默认实现是DefaultListableBeanFactory
* 读取配置文件信息,将<bean></bean>中的信息封装成BeanDefition 并注册到 BeanDefitionRegistry(是一个map)
*/
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 第三步:BeanFactory的预准备⼯作(BeanFactory进⾏⼀些设置,⽐如context的类加载器等
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 第四步:BeanFactory准备⼯作完成后进⾏的后置处理⼯作
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 第五步: 实例化并调用实现了BeanFactoryPostProcessor接口的Bean
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 第六步:注册BeanPostProcessors(Bean的后置处理器)
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 第七步:初始化MessageSource组件(做国际化功能;消息绑定,消息解析);
initMessageSource();
// Initialize event multicaster for this context.
// 第八步:初始化事件分发器
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 第九步:⼦类重写这个⽅法,在容器刷新的时候可以⾃定义逻辑
onRefresh();
// Check for listener beans and register them.
// 第⼗步:注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
/**
* 第十一步:
* 初始化所有剩下的非懒加载的单例bean
* 初始化创建非懒加载方式的单例bean实例(未设置属性)
* 填充属性
* 初始化方法调用,(比如调用afterPropertiesSet方法、init-method方法)
* 调用BeanPostProcessor(bean后置处理器)对实例bean进行后处置
*/
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 第⼗⼆步:完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法,并且发布事 (ContextRefreshedEvent)
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
二、BeanFactory创建流程
2.1 获取beanFactory子流程
![](https://img-blog.csdnimg.cn/20200306082121946.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
2.2、BeanDefinition加载解析及注册子流程
(1)该子流程涉及到如下几个关键步骤
Resource定位:
指对
BeanDefi
nition
的资源定位过程。通俗讲就是找到定义
Javabean
信息的
XML文件,并将其封装成Resource
对象。
BeanDefinition载入
:把用户定义好的
Javabean
表示为
IoC
容器内部的数据结构,这个容器内部的数据结构就是BeanDefi
nition
。
注册BeanDefinition到 IoC 容器
(2)过程分析
1 子流程入口在AbstractRefreshableApplicationContext#refreshBeanFactory方法中
![](https://img-blog.csdnimg.cn/20200306122902977.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
2 、依次调用多个类的
loadBeanDefi
nitions 方
法
—> AbstractXmlApplicationContext —>AbstractBeanDefinitionReader —> XmlBeanDefi
nitionReader一
直执行到XmlBeanDefinitionReader
的
doLoadBeanDefi
nitions 方
法
从xml中加载到beanDefinition
![](https://img-blog.csdnimg.cn/20200306130106895.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
![](https://img-blog.csdnimg.cn/20200306142357388.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
3、我们重点观察
XmlBeanDefi
nitionReader
类的
registerBeanDefi
nitions 方
法
![](https://img-blog.csdnimg.cn/20200306143134529.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
4、此处我们关注两个地方:一个
createRederContext方
法,一个是DefaultBeanDefinitionDocumentReader
类的
registerBeanDefi
nitions方
法,先进入createRederContext 方法看看
![](https://img-blog.csdnimg.cn/20200306143952185.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
5、我们可以看到,此处
Spring 首
先完成了
NamespaceHandlerResolver
的初始化。
6、
我们再进入
registerBeanDefi
nitions 方
法中追踪,调用了
DefaultBeanDefi
nitionDocumentReader#registerBeanDefi
nitions 方
法
![](https://img-blog.csdnimg.cn/20200306144651925.png)
7、进入
doRegisterBeanDefinitions方法
![](https://img-blog.csdnimg.cn/20200306144856413.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
8、进入
parseBeanDefinitions方法
![](https://img-blog.csdnimg.cn/20200306145025251.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
9、进入
parseDefaultElement方法
![](https://img-blog.csdnimg.cn/20200306145329940.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
10、进入
processBeanDefinition方法
![](https://img-blog.csdnimg.cn/2020030615035845.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
11、我们 可以在看看是怎么注册的,进入
registerBeanDefinition方法
![](https://img-blog.csdnimg.cn/20200306150727451.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
12、进入
registerBeanDefinition方法,最后将BeanDefinition存入map集合中
![](https://img-blog.csdnimg.cn/20200306151410386.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
三、Bean创建流程
1、通过最开始的关键时机点分析,我们知道
Bean
创建子流程入口在AbstractApplicationContext#refresh()方法的fi
nishBeanFactoryInitialization(beanFactory)
处
![](https://img-blog.csdnimg.cn/20200306152608685.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
2、进入
finishBeanFactoryInitialization
![](https://img-blog.csdnimg.cn/20200306153039124.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
3、进入
preInstantiateSingletons方
法,我们找到下面部分的
代码,看到工厂
Bean
或者普通
Bean
,最终都是通过
getBean
的方法获取实例
![](https://img-blog.csdnimg.cn/20200306154103238.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
4、进入getBean()
![](https://img-blog.csdnimg.cn/20200306154145118.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
5、进入doGetBean()方法,do开头的是真正干活的,
我们直接找到核心部分
![](https://img-blog.csdnimg.cn/20200306161329679.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
6、进入
createBean
![](https://img-blog.csdnimg.cn/20200306161726106.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)
7、doCreateBean
![](https://img-blog.csdnimg.cn/20200306162944822.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xXWVlZWVlZ,size_16,color_FFFFFF,t_70)