-
原则
- 定焦原则：抓主线
- 宏观原则：站在上帝视角，关注源码结构和业务流程，对于代码如何编写不要关注
-
读源码方法和技巧
- 断点（观察调用栈）
- 反调（Find Usages）
- 经验（Spring框架中doXXX，是做具体处理的地方）
1 Spring IoC的容器体系
1.1 Spring IoC的容器体系
- ApplicationContext是容器的高级接口，BeanFactory（定级容器/根容器，规范/定义了容器的基本行为。），Spring应用上下文，官方称之为IOC容器，（错误的认识：容器就是map而已，准确来说，map是IOC容器的一个成员，叫做单例池，容器是一组组件和过程的集合，包括BeanFactory、单例池、BeanPostProcessor等以及之间的协作）
1.2 Bean生命周期关键时机点
1.3 Spring IoC容器初始化主流程
容器启动后也可以在刷新容器，调用refresh方法
2 BeanFactory创建流程
2.1 获取BeanFactory子流程
AbstractApplicationContext.java
/**
* Tell the subclass to refresh the internal bean factory.
* @return the fresh BeanFactory instance
* @see #refreshBeanFactory()
* @see #getBeanFactory()
* 一共做了两件事：
* 1 获取BeanFactory，默认实现DefaultListableBeanFactory
* 2 解析xml中bean加载为BeanDefinition对象，并注册到BeanDefinitionRegistry（map，key为id或name，value为BeanDefinition对象）
*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
/**
* 判断是否有了bean Factory
* 如果有，就销毁beans，关闭bean factory
* 如果没有实例化 DefaultListableBeanFactory、设置序列化id、自定义bean工厂的一些属性（是否覆盖、是否允许循环依赖）、加载应用中的beanDefinitions
*/
refreshBeanFactory();
return getBeanFactory();
}
AbstractRefreshableApplicationContext.java
protected final void refreshBeanFactory() throws BeansException {
//判断是否有了bean Factory
if (hasBeanFactory()) {
//销毁beans
destroyBeans();
//关闭bean factory
closeBeanFactory();
}
try {
//实例化 DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
//设置序列化id
beanFactory.setSerializationId(getId());
//自定义bean工厂的一些属性（是否覆盖、是否允许循环依赖）
customizeBeanFactory(beanFactory);
//加载应用中的beanDefinitions
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
2.2 BeanDefinition加载解析及注册子流程
- 该子流程涉及到如下几个关键步骤 org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory) org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader) org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String...) org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.Resource) org.springframework.beans.factory.xml.XmlBeanDefinitionReader#doLoadBeanDefinitions 读取xml为Document对象完成
org.springframework.beans.factory.xml.XmlBeanDefinitionReader#registerBeanDefinitions （注册开始） org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#registerBeanDefinitions org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition
-
过程分析
-
时序图
3 Bean创建流程
org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
- 通过最开始的关键时机点分析，我们知道Bean创建子流程入口在 AbstractApplicationContext#refresh()方法的finishBeanFactoryInitialization(beanFactory) 处
/**
* Instantiate all remaining (non-lazy-init) singletons.
*
* 初始化所有剩下的非懒加载的单例Bean
* 初始化创建非懒加载方式的单例Bean实例（未设置属性）
* 填充属性
* 初始化方法调用（比如调用afterPropertiesSet方法，init-method方法）
* 调用BeanPostProcessor（后置处理器），对实例Bean进行后置处理
*
*/
finishBeanFactoryInitialization(beanFactory);
- 进入finishBeanFactoryInitialization
/**
* Finish the initialization of this context's bean factory,
* initializing all remaining singleton beans.
* 结束bean factory的初始化工作
* 实例化所有单例bean
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
//是否包含转换服务的bean（用于类型转换的）
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
//实例化所有立即加载的bean
beanFactory.preInstantiateSingletons();
}
- 继续进入DefaultListableBeanFactory类的preInstantiateSingletons方法，我们找到下面部分的 代码，看到工厂Bean或者普通Bean，最终都是通过getBean的方法获取实例
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 如果是FactoryBean 则加&
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 实例化当前bean
getBean(beanName);
}
}
- 继续跟踪下去，我们进入到了AbstractBeanFactory类的doGetBean方法，这个方法中的代码很 多，我们直接找到核心部分 org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
// 创建单例bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
- 接着进入到AbstractAutowireCapableBeanFactory类的方法，找到以下代码部分 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
try {
// 进入，真真正正创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
- 进入doCreateBean方法看看，该方法我们关注两块重点区域 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
if (instanceWrapper == null) {
// 创建bean实例，仅仅调用构造方法，但是尚未设置属性
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
给Bean填充属性，调用初始化方法，应用BeanPostProcessor后置处理器
try {
// bean属性填充
populateBean(beanName, mbd, instanceWrapper);
// 调用初始化方法，应用BeanPostProcessor后置处理器
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
4 lazy-init 延迟加载机制原理
普通 Bean 的初始化是在容器启动初始化阶段执行的，而被lazy-init=true修饰的 bean 则是在从容器里 第一次进行context.getBean() 时进行触发。Spring 启动的时候会把所有bean信息(包括XML和注解)解 析转化成Spring能够识别的BeanDefinition并存到Hashmap里供下面的初始化时用，然后对每个 BeanDefinition 进行处理，如果是懒加载的则在容器初始化阶段不处理，其他的则在容器初始化阶段进 行初始化并依赖注入。
org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
// 所有beanDefinition集合
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 触发所有非延迟加载单例bean的初始化，主要步骤为getBean
for (String beanName : beanNames) {
// 合并BeanDefinition对象
// map.get(beanName)
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 判断是否是懒加载单例bean，如果是单例的并且不是懒加载的则在容器创建时初始化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断是否是 FactoryBean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 如果是FactoryBean 则加&
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 实例化当前bean
/*
如果是普通bean则进行初始化并依赖注入，此 getBean(beanName)接下来触发的逻辑
懒加载时 context.getBean("beanName") 所触发的逻辑是一样的
*/
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
- 总结
- 对于被修饰为lazy-init的bean Spring 容器初始化阶段不会进行 init 并且依赖注入，当第一次 进行getBean时候才进行初始化并依赖注入
- 对于非懒加载的bean，getBean的时候会从缓存里头获取，因为容器初始化阶段 Bean 已经 初始化完成并缓存了起来
5 Spring IoC循环依赖问题
Spring 容器初始化阶段不会进行 init 并且依赖注入，当第一次 进行getBean时候才进行初始化并依赖注入
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容器中
-
lassB调用setClassA方法，Spring从容器中获取ClassA ，因为第一步中已经提前暴露了 ClassA，因此可以获取到ClassA实例 ClassA通过spring容器获取到ClassB，完成了对象初始化操作
-
这样ClassA和ClassB都完成了对象初始化操作，解决了循环依赖问题。
