Spring源码分析之IOC循环依赖详解

浅浅的花香味﹌ 2022-12-10 08:48 206阅读 0赞

**直接上源码来说明：**

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry \{  
...  
protected Object getSingleton(String beanName, boolean allowEarlyReference) \{  
   //首先检查一级缓存中是否存在  
   Object singletonObject = this.singletonObjects.get(beanName);   /\*\*  
    \*  如果一级缓存中不存在代表当前 Bean 还未被创建或者正在创建中  
    \*  检查当前 Bean 是否正处于正在创建的状态中(当Bean创建时会将Bean名称存放到 singletonsCurrentlyInCreation 集合中)  
   \*/  
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) \{  
      synchronized (this.singletonObjects) \{         //检查二级缓存中是否存在  
         singletonObject = this.earlySingletonObjects.get(beanName);         /\*\*  
          \* @@如果二级缓存中不存在 并且 允许使用早期依赖  
          \* allowEarlyReference ： 它的含义是是否允许早期依赖  
          \* @@那么什么是早期依赖？   
          \* 就是当Bean还未成为成熟的Bean时就提前使用它，在实例化流程图中我们看到在添加缓存前刚刚实例化Bean但是还未依赖注入时的状态  
         \*/  
         if (singletonObject == null && allowEarlyReference) \{  
                        //获取三级缓存中的 Bean ObjectFactory  
            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);            //如果 Bean 对应的 ObjectFactory 存在  
            if (singletonFactory != null) \{  
               //使用 getObject 方法获取到 Bean 的实例  
               singletonObject = singletonFactory.getObject();               //将 bean 从三级缓存提升至二级缓存  
               this.earlySingletonObjects.put(beanName, singletonObject);               this.singletonFactories.remove(beanName);            \}         \}      \}   \}   return singletonObject;  
\}

据我在网上查找的资料，spring可以帮我们处理bean的scope为singleton的field循环依赖，个人感觉应该也是这样，下面说一下它的处理过程。  
简单说一下bean的加载过程，当spring启动的时候，首先加载进beanFactory的是beanDefinition，之后会根据beanDefinition判断其是否为sington并且为非抽象类非懒加载，那么之后会去创建bean，bean的创建分为三步：  
1.调用构造方法创建对象实例(这一步完成之后其它对象实例就可以引用它)  
2.填充实例内部属性(会依次从三级缓存中获取依赖的bean，如果没有找到，则会先去创建依赖的bean，之后再返回继续填充属性)  
3.执行initializeBean方法，进行初始化

当bean进行创建时，会先调用getbean方法->执行doGetBean方法，在doGetBean方法中会调用getSingleton方法，  
这一步就是从三级缓存中获取对象缓存，因为是刚开始创建bean所以缓存中肯定没有，之后会调用createBean方法，  
在createBean方法中会调用doCreateBean执行bean的创建过程就是上面的那三步，当bean创建成功之后会将其放入一级缓存之中  
，此时会将它从三级和二级缓存中删除。

SpringBoot应用开发已经非常普遍，的确，SpringBoot给我们的开发带来了很多便利，但其实，SpringBoot并没有增加什么新特性，只不过是在Spring注解的基础上做了升级版混合使用。SpringBoot的精髓就是**自动装配（@EnableAutoConfiguration）**，我们不需要像以前使用Maven搭建项目时，引入过多的依赖包，同时还需要处理各种包冲突问题，简直是烦的要死，现在只需依赖SpringBoot核心包就能完成简单的应用开发了，所以了解Spring核心原理就非常重要了，下面我们开始从源码角度分析Spring底层原理。

下面我们首先定义一个实体类和配置类

/**
     * @Description: Dog实体类
     * @Auther: Java思享汇
     */
    @Data
    @ToString
    public class Dog  {
        private String name;
        private Integer age;
        public Dog(){
            System.out.println("------>构造函数调用");
        }    public void init(){
            System.out.println("------>init函数调用");
        }}

/**
     * @Description: Configuration配置类
     * @Auther: Java思享汇
     */
    @ComponentScan("com.study.spring")
    @Configuration
    public class DogConfiguration {
        public Dog dog(){
            return new Dog();
        }}

接下来定一个测试类

/**
     * @Description: 测试类
     * @Auther: Java思享汇
     */
    public class Test {
        @org.junit.Test
        public void test(){
            AnnotationConfigApplicationContext ac =new AnnotationConfigApplicationContext(DogConfiguration.class);
            Dog dog = (Dog) ac.getBean("dog");
            System.out.println(dog);    }}

我们就从AnnotationConfigApplicationContext这个类开始，探究下Spring的IOC容器是如何装载Bean的，源码如下：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    		this();
    		register(annotatedClasses);
    		//重点在下面这个方法，创建刷新容器
    		refresh();
    	}

然后，我们继续向下跟踪这个refresh()方法，这个方法在抽象类AbstractApplicationContext下

@Override
    public void refresh() throws BeansException, IllegalStateException {	synchronized (this.startupShutdownMonitor) {		// 1、刷新前的预处理
    		prepareRefresh();		// 2、获取BeanFactory
    		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();		// 3、BeanFactory的预准备工作（BeanFactory进行一些设置）
    		prepareBeanFactory(beanFactory);		try {			// 4、BeanFactory准备工作完成后进行的后置处理工作
    			postProcessBeanFactory(beanFactory);			// 5、执行BeanFactoryPostProcessor的方法
    			invokeBeanFactoryPostProcessors(beanFactory);			// 6、注册BeanPostProcessor（Bean的后置处理器）,不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的
    			registerBeanPostProcessors(beanFactory);			// 7、初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
    			initMessageSource();			// 8、初始化事件派发器；
    			initApplicationEventMulticaster();			// 9、留给子容器（子类）,空方法
    			onRefresh();			// 10、给容器中将所有项目里面的ApplicationListener注册进来
    			registerListeners();			// 11、重点在这，初始化所有剩下的单实例bean（自定义的单例bean）
    			finishBeanFactoryInitialization(beanFactory);			// 12、完成BeanFactory的初始化创建工作；IOC容器就创建完成
    			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();
    		}
    	}
    }

通过以上步骤，我们发现Spring的IOC容器主要完成了以下操作：

1、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；

1.  xml注册bean；
2.  注解注册Bean；@Service、@Component、@Bean

2、Spring容器会合适的时机创建这些Bean

1.  用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
2.  统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；

3、后置处理器；BeanPostProcessor

1.  每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；AutowiredAnnotationBeanPostProcessor:处理自动注入AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；xxx…增强的功能注解：AsyncAnnotationBeanPostProcessor…

4⃣️、事件驱动模型；

1.  ApplicationListener；事件监听；
2.  ApplicationEventMulticaster；事件派发：

接下来，我们看下装载我们自己定义的单例bean的过程，主要通过11、**finishBeanFactoryInitialization**(beanFactory);方法来进行处理。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    	// 1、判断有无ConversionService(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));
    	}
    	// 2、如果beanFactory中不包含EmbeddedValueResolver,则向其中添加一个EmbeddedValueResolver
      // EmbeddedValueResolver-->解析bean中的占位符和表达式
    	if (!beanFactory.hasEmbeddedValueResolver()) {
    		beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
    			@Override
    			public String resolveStringValue(String strVal) {
    				return getEnvironment().resolvePlaceholders(strVal);
    			}
    		});
    	}
    	// 3、初始化LoadTimeWeaverAware类型的bean
      // LoadTimeWeaverAware-->加载Spring Bean时织入第三方模块,如AspectJ
    	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    	for (String weaverAwareName : weaverAwareNames) {
    		getBean(weaverAwareName);
    	}
    	// 4、释放临时类加载器
    	beanFactory.setTempClassLoader(null);
    	// 5、冻结缓存的BeanDefinition元数据
    	beanFactory.freezeConfiguration();
    	// 6、重点来了，实例化所有剩余的（非lazy init）单例(包含自定义单例bean)
    	beanFactory.preInstantiateSingletons();
    }

继续向下跟踪代码，6、beanFactory.preInstantiateSingletons()位于类DefaultListableBeanFactory下，源码如下：

@Override
    public void preInstantiateSingletons() throws BeansException {	if (this.logger.isDebugEnabled()) {
    		this.logger.debug("Pre-instantiating singletons in " + this);
    	}	// 1、获取Bean的定义信息
    	List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
    	// 2、触发初始化非懒加载单例beans
    	for (String beanName : beanNames) {
    		// 2.1、根据beanName获取bean的RootBeanDefinition
    		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    		    // 2.2、判断为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 {
    					isEagerInit = (factory instanceof SmartFactoryBean &&
    							((SmartFactoryBean<?>) factory).isEagerInit());				}				if (isEagerInit) {
    				    // 2.2.1、重点在这，获取创建bean	
    					getBean(beanName);				}			}			// 非FactoryBean
    			else { 
    				getBean(beanName);			}		}	}   // 3、所有Bean都利用getBean创建完成以后，检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；
    	for (String beanName : beanNames) {
    		Object singletonInstance = getSingleton(beanName);		if (singletonInstance instanceof SmartInitializingSingleton) {
    			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;			if (System.getSecurityManager() != null) {
    				AccessController.doPrivileged(new PrivilegedAction<Object>() {
    					@Override					public Object run() {						smartSingleton.afterSingletonsInstantiated();						return null;
    					}				}, getAccessControlContext());			}			else {
    				smartSingleton.afterSingletonsInstantiated();			}		}	}}

重点代码在 2.2.1、getBean(beanName);，根据beanName去获取单例bean信息，我们继续跟踪代码，位于类AbstractBeanFactory

@Override
    public Object getBean(String name) throws BeansException {	return doGetBean(name, null, null, false);
    }protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,	@Nullable final Object[] args, boolean typeCheckOnly)			throws BeansException {    // 1、转换bean的名称,去掉&前缀,且如果bean有别名的话,优先使用别名
        final String beanName = transformedBeanName(name);    Object bean;    // 2、从缓存中获取bean
        Object sharedInstance = getSingleton(beanName);    if (sharedInstance != null && args == null) {
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }    // 3、如果未能从缓存中获取到bean,则要重新创建bean
        else {
            // Fail if we're already creating this bean instance: We're assumably within a circular reference.
            // 3.1判断指定的原型模式的bean是否当前正在创建(在当前线程内),如果是->则抛出异常(Spring不会解决原型模式bean的循环依赖)
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }        // Check if bean definition exists in this factory.
            // 3.2 检测bean definition是否存在beanFactory中
            BeanFactory parentBeanFactory = getParentBeanFactory();        // 如果当前BeanFactory中不包含给定beanName的beanDefinition定义,且父beanFactory不为空,则去父beanFactory中再次查找
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // 3.3 将name转换为原始beanName
                // 	   因为这里的name已经经过beanName的规范处理,例如:&myBean-->规范-->myBean
                // 	   所以当我们再次去父beanFactory查找时,要将beanName再次转换为原始的beanName,myBean-->回转-->&myBean
                String nameToLookup = originalBeanName(name);            // 3.4 下面会递归调用各种getBean的方法重载,从当前bean的父factoryBean中加载bean
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    // 参数不为空,则委托parentBeanFactory使用显式参数调动
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) {
                    // 参数为空,则委托parentBeanFactory使用标准的getBean方法获取bean
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
                    // 否则委托parentBeanFactory使用默认的getBean方法
                    return (T) parentBeanFactory.getBean(nameToLookup);
                }
            }
            // 3.3 如果当前bean不是用于类型检查,则将该bean标记为已经被创建或者即将被创建
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }
            try {
                // 3.4 合并beanDefinition,如果指定的bean是一个子bean的话,则遍历其所有的父bean
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                // 校验合并的beanDefinition,如果验证失败,则抛出异常
                checkMergedBeanDefinition(mbd, beanName, args);
                // 3.5 确保初始化当前bean所依赖的bean。
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    // 循环所有的依赖bean,并递归实例化
                    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 {
                            // 实例化依赖的bean
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }
                // 3.6 创建单例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);
                }
                // 创建原型模式bean
                else if (mbd.isPrototype()) {
                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);                    prototypeInstance = createBean(beanName, mbd, args);                }                finally {
                        afterPrototypeCreation(beanName);                }                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);            }            else {
                    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 {
                        Object scopedInstance = scope.get(beanName, () -> {
                            beforePrototypeCreation(beanName);                        try {
                                return createBean(beanName, mbd, args);
                            }                        finally {
                                afterPrototypeCreation(beanName);                        }                    });                    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) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }    }    return (T) bean;
    }

该过程是为创建当前单例bean的准备工作。其中包括了：对BeanDefinition的检测、如果当前BeanFactory中不包含BeanDefinition则对父BeanFactory的检测、BeanDefinition的合并、依赖bean的初始化等。获取bean时，先从缓存Map中缓存中取，如果缓存中没有则到第3.6步，开始创建单例bean。好的，在以后的文章我们继续介绍**Bean的创建过程**～

其中CreatBean方法调用继承的抽象类方法。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory  
        implements AutowireCapableBeanFactory \{

。。。

@Override  
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object\[\] args)  
            throws BeanCreationException \{

if (logger.isTraceEnabled()) \{  
            logger.trace("Creating instance of bean '" + beanName + "'");  
        \}  
        RootBeanDefinition mbdToUse = mbd;

// Make sure bean class is actually resolved at this point, and  
        // clone the bean definition in case of a dynamically resolved Class  
        // which cannot be stored in the shared merged bean definition.  
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);  
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) \{  
            mbdToUse = new RootBeanDefinition(mbd);  
            mbdToUse.setBeanClass(resolvedClass);  
        \}

// Prepare method overrides.  
        try \{  
            mbdToUse.prepareMethodOverrides();  
        \}  
        catch (BeanDefinitionValidationException ex) \{  
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),  
                    beanName, "Validation of method overrides failed", ex);  
        \}

try \{  
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.  
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);  
            if (bean != null) \{  
                return bean;  
            \}  
        \}  
        catch (Throwable ex) \{  
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,  
                    "BeanPostProcessor before instantiation of bean failed", ex);  
        \}

try \{  
            Object beanInstance = **doCreateBean**(beanName, mbdToUse, args);  
            if (logger.isTraceEnabled()) \{  
                logger.trace("Finished creating instance of bean '" + beanName + "'");  
            \}  
            return beanInstance;  
        \}  
        catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) \{  
            // A previously detected exception with proper bean creation context already,  
            // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.  
            throw ex;  
        \}  
        catch (Throwable ex) \{  
            throw new BeanCreationException(  
                    mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);  
        \}  
    \}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object\[\] args)  
      throws BeanCreationException \{  
   /\*\*  
    \* 我们一开始通过 getSingleton() 方法中获取三级缓存中存放的Bean，这里就是向三级缓存中添加 bean 的地方  
    \* 流程:  
    \* 1.检查当前 bean 是否为单例模式，并且是否允许循环引用\[讲解1\],并且当前是否正在创建中(在getSingleton方法中添加的)  
    \* 2.如果允许提前曝光\[讲解2\]，addSingletonFactory() 方法向缓存中添加当前 bean 的 ObjectFactory  
    \*  
    \* \[讲解1\]：当前 Bean 如果不允许循环引用(循环依赖也就是被依赖)，则这里就不会提前曝光，对应的 ObjectFactory  
    \* 则当发生循环依赖时会抛出 BeanCreationException 异常  
    \*  
    \* \[讲解2\]：提前曝光的含义就是说当 bean 还未创建完毕时就先将创建中状态的bean放到指定缓存中，为循环依赖提供支持  
   \*/  
   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&  
         isSingletonCurrentlyInCreation(beanName));  
   //需要提前曝光  
   if (earlySingletonExposure) \{  
      /\*\*  
       \* 向缓存(三级缓存)中添加当前 bean 的 ObjectFactory  
      \*/  
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));  
   \}  
   /\*\*  
    \* Initialize the bean instance.  
    \* 初始化 Bean 实例阶段  
   \*/  
   Object exposedObject = bean;  
   try \{  
      /\*\*  
       \*  依赖注入这时会递归调用getBean  
      \*/  
      populateBean(beanName, mbd, instanceWrapper);  
      //调用初始化方法，如：init-method  
      exposedObject = initializeBean(beanName, exposedObject, mbd);  
   \}  
      /\*\*  
    \* 当允许提前曝光时进入判断  
    \* @这里做了什么？  
    \* 1.检查当前bean是否经历了一场循环依赖  
    \*   - 通过 getSingleton(beanName,false) 获取缓存中的 bean，传入 false 代表不获取三级缓存中的bean  
    \*   - 为什么说 检查当前bean是否经历了一场循环依赖呢？ 因为上述说了传入 false 代表不获取三级缓存的  
    \*   - 那么什么情况下才会存在与一级缓存和二级缓存呢？答案就是循环依赖后 \[解释1\] 和bean实例化完成后  
    \*   - 所以如果 getSingleton 返回的 bean 不为空，则这个bean就是刚刚经历了循环依赖  
    \*  
    \* 2.检查提前曝光的bean和当前的Bean是否一致  
    \*   - 下面有个判断 if (exposedObject == bean) ，这个判断从缓存中获取的bean 和 经历过初始化后的 bean  
    \*   - 是否一致，可能我们有点晕，这里解释一下，缓存从的bean是什么时候存进去的？是在 addSingletonFactory 方法(649行)  
    \*   - 然后这里存进去的 bean 只是提前曝光的 bean，还没有依赖注入和初始化，但是在依赖注入和初始化时都是可能直接改变  
    \*   - 当前 bean 的实例的，这意味着什么？意味着经历了依赖注入和初始化的bean很可能和缓存中的bean就已经完全不是一个 bean了  
    \*   下面讲解当一致或不一致时的逻辑：  
    \* 2.1 一致：  
    \*  不是很理解，直接赋值，可是经历了各种 BeanPostProsser 或者依赖注入和初始化后不是就不一样了吗  
    \* 2.2 不一致:  
    \*  看下方对于 else if 代码块的解释  
    \*  
    \* @\[解释1\]  
    \* 当循环依赖时，A依赖着B，B依赖着A，实例化A首先将A放到三级缓存中然后发现依赖着B，然后去实例化B，发现依赖着A  
    \* 发现A在三级缓存，然后获取三级缓存中的bean并且将A从三级缓存中提升到二级缓存中，实例化B完成，接着实例化A也完成。  
    \*  
    \* @通俗讲解  
    \* 假设我们业务上对某种数据加了缓存，假设 i 在缓存中存的值为1，当我在数据库中把 i 的值改成 2 时，缓存中的 i 还没有被改变还是 1  
    \* 这时的数据已经和我们的真实数据偏离了，不一致了，这时有两种解决方式：1.服务器检查到数据不一致抛出异常。(也就是进入else if 代码块)  
    \* 2.直接使用原始值也就是1(也就是将 allowRawInjectionDespiteWrapping 改成 true),当然这两种方式明显不是我们正常数据库的操作，只是  
    \* 为了说明当前的这个例子而已。  
    \*  
   \*/  
   if (earlySingletonExposure) \{  
      //获取缓存中(除三级缓存) beanName 对应的 bean  
      Object earlySingletonReference = getSingleton(beanName, false);  
      //当经历了一场循环依赖后 earlySingletonReference 就不会为空  
      if (earlySingletonReference != null) \{  
         //如果 exposedObject 没有在初始化方法中被改变，也就是没有被增强  
         if (exposedObject == bean) \{  
            //直接赋值? 可是经历了各种 BeanPostProsser 或者依赖注入和初始化后不是就不一样了吗  
            exposedObject = earlySingletonReference;  
         \}  
         /\*\*  
          \*  
          \* 走到 else if  时说明 当前 Bean 被 BeanPostProessor 增强了  
          \* 判断的条件为：  
          \* 1.如果允许使用被增强的  
          \* 2.检查是否存在依赖当前bean的bean  
          \*  
          \* 如果存在依赖的bean已经被实例化完成的，如果存在则抛出异常  
          \* 为什么抛出异常呢？  
          \* 因为依赖当前bean 的bean 已经在内部注入了当前bean的旧版本，但是通过初始化方法后这个bean的版本已经变成新的了  
          \* 旧的哪个已经不适用了，所以抛出异常  
          \*  
         \*/  
         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) \{  
            String\[\] dependentBeans = getDependentBeans(beanName);  
            Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);  
            for (String dependentBean : dependentBeans) \{  
               if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) \{  
                  actualDependentBeans.add(dependentBean);  
               \}  
            \}  
            if (!actualDependentBeans.isEmpty()) \{  
               throw new BeanCurrentlyInCreationException(beanName,  
                     "Bean with name '" + beanName + "' has been injected into other beans \[" +  
                     StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +  
                     "\] in its raw version as part of a circular reference, but has eventually been " +  
                     "wrapped. This means that said other beans do not use the final version of the " +  
                     "bean. This is often the result of over-eager type matching - consider using " +  
                     "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");  
            \}  
         \}  
      \}  
   \}  
   try \{  
      /\*\*  
       \* Register bean as disposable.  
       \* 注册 Bean 的销毁方法拓展  
      \*/  
      registerDisposableBeanIfNecessary(beanName, bean, mbd);  
   \}  
   catch (BeanDefinitionValidationException ex) \{  
      throw new BeanCreationException(  
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);  
   \}  
   return exposedObject;  
\}