Spring之IOC源码分析-5

5. Spring IOC源码深度剖析

• 好处：提高培养代码架构思维、深入理解框架

• 原则

  • 定焦原则：抓主线

  • 宏观原则：站在上帝视⻆，关注源码结构和业务流程(淡化具体某行代码的编写细节)

• 读源码的方法和技巧

  • 断点 (观察调用栈)

  • 反调 (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

5.1 Spring IoC容器初始化主体流程

1. Spring IoC的容器体系

IoC容器是Spring的核心模块，是抽象了对象管理、依赖关系管理的框架解决方案。

Spring 提供了很多 的容器，其中 BeanFactory 是顶层容器(根容器)，不能被实例化，它定义了所有 IoC 容器 必须遵从的一套原则，具体的容器实现可以增加额外的功能，比如我们常用到的ApplicationContext，其下更具体的实现如 ClassPathXmlApplicationContext 包含了解析 xml 等一系列的内容， AnnotationConfigApplicationContext 则是包含了注解解析等一系列的内容。Spring IoC 容器继承体系非常聪明，需要使用哪个层次用哪个层次即可，不必使用功能大而全的。

BeanFactory 顶级接口方法栈如下

容器体系

通过其接口设计，我们可以看到我们一贯使用的 ApplicationContext 除了继承BeanFactory的子接口， 还继承了ResourceLoader、MessageSource等接口，因此其提供的功能也就更丰富了。

下面我们以 ClasspathXmlApplicationContext 为例，深入源码说明 IoC 容器的初始化流程。

2. Bean生命周期关键时机点

思路：创建一个类 LagouBean ，让其实现几个特殊的接口，并分别在接口实现的构造器、接口方法中 断点，观察线程调用栈，分析出 Bean 对象创建和管理关键点的触发时机。

LagouBean类

public class LagouBean implements InitializingBean, ApplicationContextAware {

	private ItBean itBean;

	public void setItBean(ItBean itBean) {
		this.itBean = itBean;
	}

	/**
	 * 构造函数
	 */
	public LagouBean(){
		System.out.println("LagouBean 构造器...");
	}


	/**
	 * InitializingBean 接口实现
	 */
	public void afterPropertiesSet() throws Exception {
		System.out.println("LagouBean afterPropertiesSet...");
	}

	public void print() {
		System.out.println("print方法业务逻辑执行");
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		System.out.println("setApplicationContext....");
	}
}

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

	public MyBeanFactoryPostProcessor() {
		System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("BeanFactoryPostProcessor的实现方法调用中......");
	}
}

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;
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
">
<bean id="lagouBean" class="com.lagou.LagouBean"/> <bean id="myBeanFactoryPostProcessor"
class="com.lagou.MyBeanFactoryPostProcessor"/>
<bean id="myBeanPostProcessor" class="com.lagou.MyBeanPostProcessor"/>
</beans>

public class IocTest {

	/**
	 *  Ioc 容器源码分析基础案例
	 */
	@Test
	public void testIoC() {
		// ApplicationContext是容器的高级接口，BeanFacotry（顶级容器/根容器，规范了/定义了容器的基础行为）
		// Spring应用上下文，官方称之为 IoC容器（错误的认识：容器就是map而已；准确来说，map是ioc容器的一个成员，
		// 叫做单例池, singletonObjects,容器是一组组件和过程的集合，包括BeanFactory、单例池、BeanPostProcessor等以及之间的协作流程）

		/**
		 * Ioc容器创建管理Bean对象的，Spring Bean是有生命周期的
		 * 构造器执行、初始化方法执行、Bean后置处理器的before/after方法、：AbstractApplicationContext#refresh#finishBeanFactoryInitialization
		 * 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. 分析 Bean 的创建是在容器初始化时还是在 getBean 时
   在未设置延迟加载的前提下，Bean 的创建是在容器初始化过程中完成的。

2. 分析构造函数调用情况
   发现Bean的构造函数的调用时机在AbstractApplicationContext类refresh方法的 finishBeanFactoryInitialization(beanFactory)处。

3. 分析 InitializingBean 之 afterPropertiesSet 初始化方法调用情况
   发现 InitializingBean中afterPropertiesSet 方法的调用时机也是在 AbstractApplicationContext类refresh方法的finishBeanFactoryInitialization(beanFactory);

4. 分析BeanFactoryPostProcessor 初始化和调用情况
   分别在构造函数、postProcessBeanFactory 方法处打断点，观察调用栈，发现 BeanFactoryPostProcessor 初始化和调用都发生在AbstractApplicationContext类refresh方法的invokeBeanFactoryPostProcessors(beanFactory);

5. 分析 BeanPostProcessor 初始化和调用情况
   分别在构造函数、postProcessBeanFactory 方法处打断点，观察调用栈，发现BeanPostProcessor 初始化在AbstractApplicationContext类refresh方法的 registerBeanPostProcessors(beanFactory);
   postProcessBeforeInitialization 调用在AbstractApplicationContext类refresh方法的 finishBeanFactoryInitialization(beanFactory);
   postProcessAfterInitialization 调用在AbstractApplicationContext类refresh方法的 finishBeanFactoryInitialization(beanFactory);

6. 总结
   根据上面的调试分析，我们发现 Bean对象创建的几个关键时机点代码层级的调用都在 AbstractApplicationContext 类的 refresh 方法中，可⻅这个方法对于Spring IoC 容器初始化来说相当关键，汇总如下:

3. BeanFactory初始化主流程分析

由以上分析可知，Spring IOC容器初始化的关键环节在AbstractApplicationContext#refresh()方法中，我们查看refresh方法来俯瞰IOC创建的主题流程：

@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接口的监听器
            registerListeners();
            /**
             *第十一步:
			 *初始化所有剩下的非懒加载的单例bean 
			 *初始化创建非懒加载方式的单例Bean实例(未设置属性)bean
			 *填充属性 
			 *初始化方法调用(比如调用afterPropertiesSet方法、init-method方法) 
			 *调用BeanPostProcessor(后置处理器)对实例bean进行后置处理
			 *(ContextRefreshedEvent) 
			 */
            finishBeanFactoryInitialization(beanFactory);
            /**
			 *第十二步: 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，
             *并且发布事件(ContextRefreshedEvent)
			 */
            finishRefresh();
        }
        //...... 
    }
}

5.2 BeanFactory创建流程

1. 获取BeanFactory子流程

时序图：

2. BeanDefinition加载解析及注册子流程

关键步骤

该子流程涉及到如下几个关键步骤：

1. Resource定位：指对BeanDefinition的资源定位过程。通俗讲就是找到定义Javabean信息的XML文 件，并将其封装成Resource对象。

2. BeanDefinition载入 ：把用户定义好的Javabean表示为IoC容器内部的数据结构，这个容器内部的数 据结构就是BeanDefinition。

3. 注册BeanDefinition到 IoC 容器

过程分析

1. 子流程入口在 AbstractRefreshableApplicationContext#refreshBeanFactory

2. 依次调用多个类的 loadBeanDefinitions 方法 —> AbstractXmlApplicationContext —> AbstractBeanDefinitionReader —> XmlBeanDefinitionReader 一直执行到 XmlBeanDefinitionReader 的 doLoadBeanDefinitions 方法

我们重点观察XmlBeanDefinitionReader 类的 registerBeanDefinitions 方法，期间产生了多 次重载调用，我们定位到最后一个

此处我们关注两个地方：一个createRederContext方法，一个是 DefaultBeanDefinitionDocumentReader类的registerBeanDefinitions方法，先进入 createRederContext 方法看看

public XmlReaderContext createReaderContext(Resource resource) {
    return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
                                this.sourceExtractor, this, getNamespaceHandlerResolver());
}

public NamespaceHandlerResolver getNamespaceHandlerResolver() {
    if (this.namespaceHandlerResolver == null) {
        this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
    }
    return this.namespaceHandlerResolver;
}

protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
    ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
    return new DefaultNamespaceHandlerResolver(cl);
}

我们可以看到，此处 Spring 首先完成了 NamespaceHandlerResolver 的初始化。 我们再进入 registerBeanDefinitions 方法中追踪，调用了 DefaultBeanDefinitionDocumentReader#registerBeanDefinitions 方法

进入 doRegisterBeanDefinitions 方法

进入 parseBeanDefinitions 方法

进入 processBeanDefinition 方法

至此，注册流程结束，我们发现，所谓的注册就是把封装的 XML 中定义的 Bean信息封装为 BeanDefinition 对象之后放入一个Map中，BeanFactory 是以 Map 的结构组织这些 BeanDefinition 的。

可以在DefaultListableBeanFactory中看到此Map的定义

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

时序图

5.3 Bean创建流程

通过最开始的关键时机点分析，我们知道Bean创建子流程入口在 AbstractApplicationContext#refresh()方法的finishBeanFactoryInitialization(beanFactory)处进入finishBeanFactoryInitialization

继续进入DefaultListableBeanFactory类的preInstantiateSingletons方法,我们找到下面部分的代码,看到工厂Bean或者普通豆,最终都是通过getBean的方法获取实例

AbstractBeanFactory类的doGetBean方法，这个方法中的代码很多，我们直接找到核心部分

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
	                          @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		//转换beanName，这里传入进来的beanName可能是以&开头的，这里会截掉&
		final String beanName = transformedBeanName(name);
		Object bean;

		/*
		TODO 这里多级缓存用于解决循环依赖问题。
			注：循环依赖只能是属性间的依赖，不能是构造函数中参数的循环依赖。
		    从缓存（一级二级三级缓存依次获取，获取到就返回）中获取单例实例，如果获取到并且是无参构造函数，则将bean变量的值赋值。
		 */
		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isTraceEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				} else {
					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			// 如果bean不是FactoryBean类型或者beanName以&开头，则直接返回。
			// 否则将bean强转为FactoryBean类型，并调用getObject()方法返回。
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		} else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			// 多例不支持循环引用。多例时，如果返回指定的原型bean是否正在创建中，则抛出异常。
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			//如果父beanFactory不为空，并且当前beanFactory中不包含要获取的beanDefinition，则从父beanFactory中获取。
			// Check if bean definition exists in this factory.
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				} else if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				} else if (requiredType != null) {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				} else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}

			// 如果不是仅仅检查类型，则标记beanName对应的bean已经创建（将beanName添加到alreadyCreated中），
			// 并且清除MergeBeanDefinitionMap中beanName的值。
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						} catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				/*
				  TODO 重要程度 5
				    单例实例第一次创建bean入口，这里的getSingleton方法中，调用了参数中匿名对象的getObject()
				    在bean创建完成后，将bean放入到一级缓存，并从二三级缓存中移除:addSingleton(beanName, singletonObject);
				 */
				// Create bean instance.
				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;
						}
					});
					/*
					TODO 重要程度 5
						如果bean不是FactoryBean类型或者beanName以&开头，则直接返回。
						否则调用FactoryBean的getObject(),且将返回的bean替换为getObject()的返回值。
						FactoryBean接口很重要，具体应用场景见FactoryBean接口注释。
					 */
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				} else if (mbd.isPrototype()) {
					// 如果是多例，则创建bean实例。
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					} finally {
						afterPrototypeCreation(beanName);
					}
					/*
						如果bean不是FactoryBean类型或者beanName以&开头，则直接返回。
						否则将bean强转为FactoryBean类型，并调用getObject()方法返回。
					 */
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				} else {
					/*
						如果不是单例也不是多例，而是自定义的Scope，即@Scope注解的实例，从scopes中获取到指定名称的scope，
						并调用get方法获取对象。如request session等。
						如果需要自定义Scope，需要实现Scope接口，并注册到BeanFactory中，可以通过实现FactoryBeanPostProcessor接口来注册自定义Scope。
					 */
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						// 这里通过指定的scope获取bean的实例。
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							} finally {
								afterPrototypeCreation(beanName);
							}
						});
						/*
						如果bean不是FactoryBean类型或者beanName以&开头，则直接返回。
						否则将bean强转为FactoryBean类型，并调用getObject()方法返回。
					    */
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					} catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
										"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			} catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			} catch (TypeMismatchException ex) {
				if (logger.isTraceEnabled()) {
					logger.trace("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

接着进入到AbstractAutowireCapableBeanFactory类的方法，找到以下代码部分

进入doCreateBean方法看看，该方法我们关注两块重点区域

• 创建Bean实例，此时尚未设置属性

// 创建bean实例
if (instanceWrapper == null) {
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}

给Bean填充属性,调用初始化方法，应用BeanPostProcessor后置处理器

5.4 lazy-init 延迟加载机制原理

• lazy-init 延迟加载机制分析

普通 Bean 的初始化是在容器启动初始化阶段执行的，而被lazy-init=true修饰的 bean 则是在从容器里 第一次进行context.getBean() 时进行触发。Spring 启动的时候会把所有bean信息(包括XML和注解)解 析转化成Spring能够识别的BeanDefinition并存到Hashmap里供下面的初始化时用，然后对每个 BeanDefinition 进行处理，如果是懒加载的则在容器初始化阶段不处理，其他的则在容器初始化阶段进 行初始化并依赖注入。

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.
		// 所有bean的名字
		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);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					// 如果是FactoryBean则加&
					if (bean instanceof FactoryBean) {
						final 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);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final 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.5 Spring IoC循环依赖问题

1. 什么是循环依赖

循环依赖其实就是循环引用，也就是两个或者两个以上的 Bean 互相持有对方，最终形成闭环。比如A 依赖于B，B依赖于C，C又依赖于A。

注意，这里不是函数的循环调用，是对象的相互依赖关系。循环调用其实就是一个死循环，除非有终结条件。

Spring中循环依赖场景有:

• 构造器的循环依赖(构造器注入)
• Field 属性的循环依赖(set注入)

其中，构造器的循环依赖问题无法解决，只能拋出 BeanCurrentlyInCreationException 异常，在解决

属性循环依赖时，spring采用的是提前暴露对象的方法。

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实例化的对象通过singletonFactory提前暴露到Spring容器中。

1. Spring容器初始化ClassA通过构造器初始化对象后提前暴露到Spring容器
2. ClassA调用setClassB方法，Spring首先尝试从容器中获取ClassB，此时ClassB不存在Spring容器中
3. Spring容器初始化ClassB，同时也会将ClassB提前暴露到Spring容器中
4. ClassB调用setClassA方法，Spring从容器中获取ClassA ，因为第一步中已经提前暴露了ClassA，因此可以获取到ClassA实例
5. ClassA通过spring容器获取到ClassB，完成了对象初始化操作。

这样ClassA和ClassB都完成了对象初始化操作，解决了循环依赖问题。