循环依赖
类A和类B，A实例化的时候需要B的实例，B实例化的时候需要A的实例，这样就进入了死循环。
@Data @Component public class Org{ private final Role role; public Org(Role role){ this.role=role; } } @Data @Component public class Role{ private final Org org; public Role(Org org){ this.org=org; } }
这就是spring中典型额构造器注入方式。此时启动会出错。
而如果改一下代码，把构造器注入改为属性注入（@Autowired，@Resource），就不会报错，两个bean都实例化成功了。说明spring框架有解决循环依赖的过程。
三级缓存
spring创建bean的过程分为三步：
1.实例化，对应方法AbstractAutowireCapableBeanFactory中的createBeanInstance方法，简单理解就是new了一个对象。
2.属性注入，对应方法AbstractAutowireCapableBeanFactory中的populateBean方法，为实例化中new出来的对象填充属性和注入依赖。
3.初始化，对应方法AbstractAutowireCapableBeanFactory的initializeBean，执行aware接口中的方法，初始化方法，完成aop代理。
从单例Bean的初始化来看，主要可能发生循环依赖的环节就在第二部populate。值得注意的是，给予勾到方法注入的方式，其实是将第一步和第二部同时进行，因此马上就抛出错误。而spring通过属性注入的方法，是否有其他特殊处理呢，这时候就提到了三级缓存：
private final Map<String,Object> singletonObject = new ConcurrentHashMap<>(256); private final Map<String,Object> earlySingletonObjects = new ConcurrentHashMap<>(16); private final Map<String,ObjectFactory<?>> singletonFactories = new ConcurrentHashMap<>(16);
singletonObject:第一级缓存，存放可用的完全初始化，成品bean。
earlySingletonObjects：第二级缓存，存放半成品bean，指的是已创建对象，但是未注入属性和初始化，用以解决循环依赖。
singletonFactories：第三级缓存，存的事bean工厂对象，用来生成半成品的bean并放入到二级缓存中。用以解决循环依赖。如果bean存在AOP的话，返回的就是AOP的代理对象。
核心方法：getSingleton
我们在获取bean实例的时候，其实是先从三级缓存中获取：
protected Object getSingleton(String beanName, boolean allowEarlyReference) { //查询缓存中是否有创建好的单例 Object singletonObject = this.singletonObjects.get(beanName); //isSingletonCurrentlyInCreation 判断对应的单例对象是否在创建中 //如果不存在，判断是否正在创建中 //当单例对象没有被初始化完全(例如A定义的构造函数依赖了B对象，得先去创建B对象，或者在populatebean过程中依赖了B对象，得先去创建B对象，此时A处于创建中) if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { //从earlySingletonObjects冲查询是否有early缓存 singletonObject = this.earlySingletonObjects.get(beanName); //allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象 //early缓存也不存在，且允许early使用 if (singletonObject == null && allowEarlyReference) { //从单例工厂Map里查询beanName ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { //singletonFactory存在，则调用getObject方法拿到单例对象 singletonObject = singletonFactory.getObject(); //将单例对象添加到early缓存中 this.earlySingletonObjects.put(beanName, singletonObject); //移除单例工厂中对应的singletonFactory this.singletonFactories.remove(beanName); } } } } return (singletonObject != NULL_OBJECT ? singletonObject : null);}
三级缓存中一级一级的找匹配的bean，直到最后一级缓存，通过匹配beanName和ObjectFactory来获取Bean，namesingleFactories何时放入了可以通过getObject获得bean对象的ObjectFactory呢？
核心方法：doCreateBean
Bean的实例化，实际执行的源码是AbstractAutowireCapableBeanFactory类的doCreateBean方法；
方法中的BeanWrapper接口，他是bean的包裹类，即在内部中将会保存该bean的实例，提供其他一些扩展功能。同时，BeanWrapper接口还继承了PropertyAccessor,propertyEditorRegistry,TypeConverter,ConfigurationPropertyAccessor接口，所以他还提供了访问bean的属性值，属性编辑器注册，类型转换等功能。
回顾一下bean实例化过程：
ResourceLoader加载配置信息-》BeanDefinitionReader读取bean标签，并将bean标签的属性转换为BeanDefinition对应的属性，并注册到BeanDefinitionRegistry注册表中-》容器扫描注册表，通过反射机制获取BeanFactoryPostPropcessor类型的工厂处理器，并用这个工厂后处理器对BeanDefinition进行加工-》根据处理过的BeanDefinition，实例化Bean，然后BeanWrapper结合BeanDefitionRegistry和PropertyEditorRegistry对Bean的属性赋值。
思考总结：
1.多例循环依赖可以解决吗？
多例是每次创建对象都会调用doGetBean方法，根本没有使用一二三级缓存，所以多例是无法解决的。
2.构造器。setter注入的方式的循环依赖可以决绝吗？
类A和类B
均采用setter方法注入：可以解决
均采用构造器注入：不可解决
A注入B为setter，B注入A为构造器：可以解决
B注入A为setter，A注入B为构造器：不可决绝
出现循环依赖，只能先用AOP给bean先创建代理，三级缓存singleFactory的目的就是，暴露ObjectFactory而完成AOP代理，对象工厂清楚如何创建对象的AOP代理，但是不会立马创建，而是到合适的时机进行AOP代理对象的创建。
二级缓存存在的目的之一就是保证对象只有一次AOP代理，当调用三级缓存getObject()方法返回的对象会存入二级缓存，这样，当接下来的依赖者调用的时候，会先判断二级缓存是否存在，日过存在直接返回。
总结：
一级缓存为单例池，二级缓存为早期曝光对象，三级缓存为早期曝光对象工厂。
当A、B两类发生循环引用后，将自己提早曝光（加入三级缓存），如果A初始AOP代理，该工厂对象返回的事被代理的对象，若未被代理，返回对象本身。当A进行属性注入时，经过之前实例化步骤，此时轮到B属性注入，调用getBean(a)获取A对象，由于A处理正在创建集合中，此时也发生了循环依赖，所以可以从三级换窜获取对象工厂（如果A被AOP代理，此时返回就是代理对象），并把对象放到二级缓存中，这样保证A只经过一次AOP代理。接下来，B走完Spring生命周期流程，并放入单例池中。当B创建完后，会将B注入A，A走完Spring生命周期流程。到此，循环依赖结束。
