第五部分 Spring IOC源码深度剖析

 
1. 好处:提⾼培养代码架构思维、深⼊理解框架
2. 原则
  • 定焦原则:抓主线
  • 宏观原则:站在上帝视⻆,关注源码结构和业务流程(淡化具体某⾏代码的编写细节)
3. 读源码的⽅法和技巧
  • 断点(观察调⽤栈)
  • 反调(Find Usages
  • 经验(spring框架中doXXX,做具体处理的地⽅)
4. Spring 源码构建
  • 下载源码(github
  • 安装gradle 5.6.3(类似于maven Idea 2019.1 Jdk 11.0.5
  • 导⼊(耗费⼀定时间)
  • 编译⼯程(顺序:core-oxm-context-beans-aspects-aop)⼯程—>tasks—>compileTestJava

第1节 Spring IoC容器初始化主体流程

1.1 Spring IoC的容器体系

IoC 容器是 Spring 的核⼼模块,是抽象了对象管理、依赖关系管理的框架解决⽅案。 Spring 提供了很多的容器,其中 BeanFactory 是顶层容器(根容器),不能被实例化,它定义了所有 IoC 容器 必须遵从 的⼀套原则,具体的容器实现可以增加额外的功能,⽐如我们常⽤到的ApplicationContext ,其下更具 体的实现如 ClassPathXmlApplicationContext 包含了解析 xml 等⼀系列的内容,AnnotationConfifigApplicationContext 则是包含了注解解析等⼀系列的内容。 Spring IoC 容器继承体系⾮常聪明,需要使⽤哪个层次⽤哪个层次即可,不必使⽤功能⼤⽽全的。
 
BeanFactory 顶级接⼝⽅法栈如下
 
 
BeanFactory 容器继承体系
 
 
通过其接⼝设计,我们可以看到我们⼀贯使⽤的 ApplicationContext 除了继承 BeanFactory 的⼦接⼝, 还继承了ResourceLoader MessageSource 等接⼝,因此其提供的功能也就更丰富了。下⾯我们以 ClasspathXmlApplicationContext 为例,深⼊源码说明 IoC 容器的初始化流程。

 

 

1.2 Bean⽣命周期关键时机点

思路: 创建⼀个类 LagouBean ,让其实现⼏个特殊的接⼝,并分别在接⼝实现的构造器、接⼝⽅法中断点,观察线程调⽤栈,分析出 Bean 对象创建和管理关键点的触发时机
 
LagouBean
 
package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import
org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
/**
* @Author 应癫
* @create 2019/12/3 11:46
*/
public class LagouBean implements InitializingBean{
 /**
 * 构造函数
 */
 public LagouBean(){
 System.out.println("LagouBean 构造器...");
 }
 /**
 * InitializingBean 接⼝实现
 */
 public void afterPropertiesSet() throws Exception {
 System.out.println("LagouBean afterPropertiesSet...");
 } }
BeanPostProcessor 接⼝实现类
 
 
package com.lagou;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
/**
* @Author 应癫
* @create 2019/12/3 16:59
*/
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;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import
org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
/**
* @Author 应癫
* @create 2019/12/3 16:56
*/
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
 public MyBeanFactoryPostProcessor() {
 System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
 }
 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory
beanFactory) throws BeansException {
 System.out.println("BeanFactoryPostProcessor的实现⽅法调⽤中......");
 } }
IoC 容器源码分析⽤例
/**
* Ioc 容器源码分析基础案例
*/
@Test
public void testIoC() {
 ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("classpath:applicationContext.xml");
 LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
 System.out.println(lagouBean);
}
1 )分析 Bean 的创建是在容器初始化时还是在 getBean

 

根据断点调试,我们发现,在未设置延迟加载的前提下, Bean 的创建是在容器初始化过程中完成的。
 
2 )分析构造函数调⽤情况

通过如上观察,我们发现构造函数的调⽤时机在 AbstractApplicationContext refresh ⽅法的fifinishBeanFactoryInitialization(beanFactory)处 ;
3 )分析 InitializingBean afterPropertiesSet 初始化⽅法调⽤情况

观察调⽤栈

通过如上观察,我们发现 InitializingBean afterPropertiesSet ⽅法的调⽤时机也是在 AbstractApplicationContext类 refresh ⽅法的 fifinishBeanFactoryInitialization(beanFactory);
4 )分析 BeanFactoryPostProcessor 初始化和调⽤情况
分别在构造函数、 postProcessBeanFactory ⽅法处打断点,观察调⽤栈,发现 BeanFactoryPostProcessor 初始化 AbstractApplicationContext refresh ⽅法的invokeBeanFactoryPostProcessors(beanFactory);
postProcessBeanFactory 调⽤ AbstractApplicationContext refresh ⽅法的
invokeBeanFactoryPostProcessors(beanFactory);
5 )分析 BeanPostProcessor 初始化和调⽤情况
分别在构造函数、 postProcessBeanFactory ⽅法处打断点,观察调⽤栈,发现 BeanPostProcessor 初始化 AbstractApplicationContext refresh ⽅法的 registerBeanPostProcessors(beanFactory);
postProcessBeforeInitialization 调⽤ AbstractApplicationContext refresh ⽅法的 fifinishBeanFactoryInitialization(beanFactory);
postProcessAfterInitialization 调⽤ AbstractApplicationContext refresh ⽅法的
fifinishBeanFactoryInitialization(beanFactory);
6 )总结
根据上⾯的调试分析,我们发现 Bean 对象创建的⼏个关键时机点代码层级的调⽤都在
AbstractApplicationContext 类 的 refresh ⽅法中,可⻅这个⽅法对于 Spring IoC 容器初始化来说相当
关键,汇总如下:

1.3 Spring IoC 容器初始化主流程
由上分析可知, Spring IoC 容器初始化的关键环节就在 AbstractApplicationContext#refresh() ⽅法中 ,我们查看 refresh ⽅法来俯瞰容器创建的主体流程,主体流程下的具体⼦流程我们后⾯再来讨论。
@Override
public void refresh() throws BeansException, IllegalStateException {
 synchronized (this.startupShutdownMonitor) {
 // 第⼀步:刷新前的预处理
 prepareRefresh();
 /*
 第⼆步:
 获取BeanFactory;默认实现是DefaultListableBeanFactory
 加载BeanDefition 并注册到 BeanDefitionRegistry
 */
 ConfigurableListableBeanFactory beanFactory =
obtainFreshBeanFactory();
 // 第三步:BeanFactory的预准备⼯作(BeanFactory进⾏⼀些设置,⽐如context的类加
载器等)
 prepareBeanFactory(beanFactory);
 try {
 // 第四步:BeanFactory准备⼯作完成后进⾏的后置处理⼯作
 postProcessBeanFactory(beanFactory);
 // 第五步:实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
 invokeBeanFactoryPostProcessors(beanFactory);
 // 第六步:注册BeanPostProcessor(Bean的后置处理器),在创建bean的前后等执
⾏
 registerBeanPostProcessors(beanFactory);
 // 第七步:初始化MessageSource组件(做国际化功能;消息绑定,消息解析);
 initMessageSource();
 // 第⼋步:初始化事件派发器
 initApplicationEventMulticaster();
 // 第九步:⼦类重写这个⽅法,在容器刷新的时候可以⾃定义逻辑
 onRefresh();
 // 第⼗步:注册应⽤的***。就是注册实现了ApplicationListener接⼝的***
bean
 registerListeners();
 /*
 第⼗⼀步:
 初始化所有剩下的⾮懒加载的单例bean
 初始化创建⾮懒加载⽅式的单例Bean实例(未设置属性)
 填充属性
 初始化⽅法调⽤(⽐如调⽤afterPropertiesSet⽅法、init-method⽅法)
 调⽤BeanPostProcessor(后置处理器)对实例bean进⾏后置处
 */
 finishBeanFactoryInitialization(beanFactory);
 /*
 第⼗⼆步:
 完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法,并且发布事
件 (ContextRefreshedEvent)
 */
 finishRefresh();
 }
第2节 BeanFactory创建流程
2.1 获取BeanFactory⼦流程
时序图如下
2.2 BeanDefinition加载解析及注册⼦流程
(1)该⼦流程涉及到如下⼏个关键步骤
Resource定位:指对BeanDefinition的资源定位过程。通俗讲就是找到定义Javabean信息的XML⽂
件,并将其封装成Resource对象。
BeanDefinition载⼊ :把⽤户定义好的Javabean表示为IoC容器内部的数据结构,这个容器内部的数
据结构就是BeanDefinition。
注册BeanDefinition到 IoC 容器
(2)过程分析
 ......
 }
}

第2节 BeanFactory创建流程

2.1 获取BeanFactory⼦流程

时序图如下

2.2 BeanDefifinition加载解析及注册⼦流程

1 )该⼦流程涉及到如下⼏个关键步骤
Resource 定位: 指对 BeanDefifinition 的资源定位过程。通俗讲就是找到定义 Javabean 信息的 XML ⽂件,并将其封装成Resource 对象。
BeanDefifinition 载⼊ :把⽤户定义好的 Javabean 表示为 IoC 容器内部的数据结构,这个容器内部的数据结构就是BeanDefifinition
注册 BeanDefifinition IoC 容器
2 )过程分析
Step 1 ⼦流程⼊⼝在 AbstractRefreshableApplicationContext#refreshBeanFactory ⽅法中

Step 2 依次调⽤多个类的 loadBeanDefifinitions ⽅法 —> AbstractXmlApplicationContext —> AbstractBeanDefifinitionReader —> XmlBeanDefifinitionReader ⼀直执⾏到XmlBeanDefifinitionReader 的 doLoadBeanDefifinitions ⽅法

Step 3 我们重点观察 XmlBeanDefifinitionReader 类的 registerBeanDefifinitions ⽅法,期间产⽣了多次重载调⽤,我们定位到最后⼀个

此处我们关注两个地⽅:⼀个 createRederContext ⽅法,⼀个是DefaultBeanDefifinitionDocumentReader类的 registerBeanDefifinitions ⽅法,先进⼊createRederContext ⽅法看看

我们可以看到,此处 Spring ⾸先完成了 NamespaceHandlerResolver 的初始化。
我们再进⼊ registerBeanDefifinitions ⽅法中追踪,调⽤了
DefaultBeanDefifinitionDocumentReader#registerBeanDefifinitions ⽅法

进⼊ parseBeanDefifinitions ⽅法

进⼊ parseDefaultElement ⽅法
 
进⼊ processBeanDefifinition ⽅法
 
 
 
⾄此,注册流程结束,我们发现,所谓的注册就是把封装的 XML 中定义的 Bean 信息封装为 BeanDefifinition 对象之后放⼊⼀个 Map 中, BeanFactory 是以 Map 的结构组织这些 BeanDefifinition 的。
 
 
可以在 DefaultListableBeanFactory 中看到此 Map 的定义
/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new
ConcurrentHashMap<>(256);
3 )时序图
 
 

第3节 Bean创建流程

  • 通过最开始的关键时机点分析,我们知道Bean创建⼦流程⼊⼝在AbstractApplicationContext#refresh()⽅法的fifinishBeanFactoryInitialization(beanFactory)
  • 进⼊fifinishBeanFactoryInitialization
 
 
继续进⼊ DefaultListableBeanFactory 类的 preInstantiateSingletons ⽅法,我们找到下⾯部分的代码,看到⼯⼚Bean 或者普通 Bean ,最终都是通过 getBean 的⽅法获取实例
 
 
 
  • 继续跟踪下去,我们进⼊到了AbstractBeanFactory类的doGetBean⽅法,这个⽅法中的代码很多,我们直接找到核⼼部分
 
 
  • 接着进⼊到AbstractAutowireCapableBeanFactory类的⽅法,找到以下代码部分
 
  • 进⼊doCreateBean⽅法看看,该⽅法我们关注两块重点区域
创建 Bean 实例,此时尚未设置属性
 
 
 
 
  • lazy-init 延迟加载机制分析
 
普通 Bean 的初始化是在容器启动初始化阶段执⾏的,⽽被 lazy-init=true 修饰的 bean 则是在从容器⾥第⼀次进⾏context.getBean() 时进⾏触发。 Spring 启动的时候会把所有 bean 信息 ( 包括 XML 和注解 ) 解 析转化成Spring 能够识别的 BeanDefifinition 并存到 Hashmap ⾥供下⾯的初始化时⽤,然后对每个 BeanDefifinition 进⾏处理,如果是懒加载的则在容器初始化阶段不处理,其他的则在容器初始化阶段进⾏初始化并依赖注⼊
public void preInstantiateSingletons() throws BeansException {
 // 所有beanDefinition集合
 List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
 // 触发所有⾮懒加载单例bean的初始化
 for (String beanName : beanNames) {
 // 获取bean 定义
 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
 // 判断是否是懒加载单例bean,如果是单例的并且不是懒加载的则在容器创建时初始化
 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
 // 判断是否是 FactoryBean
 if (isFactoryBean(beanName)) {
 final FactoryBean<?> factory = (FactoryBean<?>)
getBean(FACTORY_BEAN_PREFIX + beanName);
 boolean isEagerInit;
 if (System.getSecurityManager() != null && factory instanceof
SmartFactoryBean) {
 isEagerInit = AccessController.doPrivileged(new
PrivilegedAction<Boolean>() {
 @Override
 public Boolean run() {
 return ((SmartFactoryBean<?>) factory).isEagerInit();
 }
 }, getAccessControlContext());
 }
 }else {
 /*
 如果是普通bean则进⾏初始化并依赖注⼊,此 getBean(beanName)接下来触发的逻辑
和
 懒加载时 context.getBean("beanName") 所触发的逻辑是⼀样的
 */
 getBean(beanName);
 }
 }
 }
}
  • 总结
  • 对于被修饰为lazy-initbean Spring 容器初始化阶段不会进⾏ init 并且依赖注⼊,当第⼀次 进⾏getBean时候才进⾏初始化并依赖注⼊
  • 对于⾮懒加载的beangetBean的时候会从缓存⾥头获取,因为容器初始化阶段 Bean 已经 初始化完成并缓存了起来
 

5.1 什么是循环依赖

循环依赖其实就是循环引⽤,也就是两个或者两个以上的 Bean 互相持有对⽅,最终形成闭环。⽐如 A 依赖于B B 依赖于 C C ⼜依赖于 A
 
 
 
注意,这⾥不是函数的循环调⽤,是对象的相互依赖关系。循环调⽤其实就是⼀个死循环,除⾮有终结条件。
Spring 中循环依赖场景有:
  • 构造器的循环依赖(构造器注⼊)
  • Field 属性的循环依赖(set注⼊)
其中,构造器的循环依赖问题⽆法解决,只能拋出 BeanCurrentlyInCreationException 异常,在解决属性循环依赖时,spring 采⽤的是提前暴露对象的⽅法。
 
 

5.2 循环依赖处理机制

  • 单例 bean 构造器参数循环依赖(⽆法解决)
  • prototype 原型 bean循环依赖(⽆法解决)
对于原型 bean 的初始化过程中不论是通过构造器参数循环依赖还是通过 setXxx ⽅法产⽣循环依赖,Spring 都 会直接报错处理。
 
AbstractBeanFactory.doGetBean() ⽅法:
 
if (isPrototypeCurrentlyInCreation(beanName)) {
 throw new BeanCurrentlyInCreationException(beanName);
}
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
 Object curVal = this.prototypesCurrentlyInCreation.get();
 return (curVal != null &&
 (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>)
curVal).contains(beanName))));
}
在获取 bean 之前如果这个原型 bean 正在被创建则直接抛出异常。原型 bean 在创建之前会进⾏标记这个beanName 正在被创建,等创建结束之后会删除标记
 
try {
 //创建原型bean之前添加标记
 beforePrototypeCreation(beanName);
 //创建原型bean
 prototypeInstance = createBean(beanName, mbd, args);
}
finally {
 //创建原型bean之后删除标记
 afterPrototypeCreation(beanName);
}
总结: Spring 不⽀持原型 bean 的循环依赖。
 
  • 单例bean通过setXxx或者@Autowired进⾏循环依赖
Spring 的循环依赖的理论依据基于 Java 的引⽤传递,当获得对象的引⽤时,对象的属性是可以延后设置的,但是构造器必须是在获取引⽤之前Spring通过 setXxx 或者 @Autowired ⽅法解决循环依赖其实是通过提前暴露⼀个 ObjectFactory 对象来完成的,简单来说ClassA 在调⽤构造器完成对象初始化之后,在调⽤ ClassA setClassB ⽅法之前就把ClassA 实例化的对象通过 ObjectFactory 提前暴露到 Spring 容器中。
 
Spring 容器初始化 ClassA 通过构造器初始化对象后提前暴露到 Spring 容器。
boolean earlySingletonExposure = (mbd.isSingleton() &&
this.allowCircularReferences &&
 isSingletonCurrentlyInCreation(beanName));
 if (earlySingletonExposure) {
 if (logger.isDebugEnabled()) {
 logger.debug("Eagerly caching bean '" + beanName +
 "' to allow for resolving potential circular references");
 }
 //将初始化后的对象提前已ObjectFactory对象注⼊到容器中
 addSingletonFactory(beanName, new ObjectFactory<Object>() {
 @Override
 public Object getObject() throws BeansException {
 return getEarlyBeanReference(beanName, mbd, bean);
 }
 });
 }
ClassA 调⽤ setClassB ⽅法, Spring ⾸先尝试从容器中获取 ClassB ,此时 ClassB 不存在 Spring 容器中。
Spring 容器初始化 ClassB ,同时也会将 ClassB 提前暴露到 Spring 容器中ClassB调⽤ setClassA ⽅法, Spring 从容器中获取 ClassA ,因为第⼀步中已经提前暴露了ClassA,因此可以获取到 ClassA 实例ClassA通过 spring 容器获取到 ClassB ,完成了对象初始化操作。
这样 ClassA ClassB 都完成了对象初始化操作,解决了循环依赖问题。
 
 

更多关于Java集合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构面试解析等等可以去这个Github链接地址:

https://github.com/ThinkingHan/Java-note 阅读,Star一下吧,感谢支持~