【Spring】IOC&DI：循环依赖相关源码分析

客官°小女子只卖身不卖艺 2022-11-14 00:58 150阅读 0赞

> 前言：[【Spring】IOC&DI：循环依赖问题及解决方案][Spring_IOC_DI]…

Spring 在启动过程中，使用到了三个 map，称为三级缓存

// 一级缓存：用于存放 beanName 和初始化好的 bean 对象(属性已经初始化好的)  
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256); 
    
     // 二级缓存：用于存放 beanName 和一个原始 bean 早期 bean(属性未初始化)  
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16); 
     
    // 三级缓存：存放 bean 工厂对象，用于解决 AOP 需要代理对象的循环依赖问题
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

由于 getBean() 最终是走到了 doGetBean() 方法，所以我们现在来看 AbstractBeanFactory\#doGetBean() 的核心逻辑

### doGetBean() ###

@SuppressWarnings("unchecked")
    // 真正实现向IOC容器获取Bean的功能，也是触发依赖注入功能的地方
    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
    		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        
        
        //......
        
        // 先从缓存中取是否已经有被创建过的单态类型的 Bean
    	// 对于单例模式的Bean整个IOC容器中只创建一次，不需要重复创建
    	Object sharedInstance = getSingleton(beanName);
    	// IOC容器创建单例模式Bean实例对象
    	if (sharedInstance != null && args == null) {
        
    		// 获取给定Bean的实例对象，主要是完成FactoryBean的相关处理
    		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        } else {
        
    		// 创建单例模式Bean的实例对象
    		if (mbd.isSingleton()) {
        
    			// 这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象
    			sharedInstance = getSingleton(beanName, () -> {
        
    				try {
        
    					// 创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义
    					return createBean(beanName, mbd, args);
    				}
    			});
    			// 获取给定Bean的实例对象
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    		}
        }
        
        //......
        	
    	return (T) bean;
    }

根据上诉代码 doGetBean()方法中 Object sharedInstance = getSingleton(beanName) 去缓存中获取 sharedInstance 对象 。

### getSingleton() ###

在这里获取的对象，可能是完全实例化好的,也有可能是一个早期对象

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        
       // 检查缓存中是否有初始化好的bean 
       Object singletonObject = this.singletonObjects.get(beanName);
       // 判断 beanName 对应的 bean 是否正在创建中 
       if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        
           // 加锁，防止多线程并发创建 
          synchronized (this.singletonObjects) {
        
             // 从 earlySingletonObjects 中获取提前曝光的 bean 
             singletonObject = this.earlySingletonObjects.get(beanName);
             // 没有获取到
             if (singletonObject == null && allowEarlyReference) {
        
                // 获取相应的 bean 工厂 
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
        
                   // 提前曝光 bean 实例（raw bean）也是早期bean ，用于解决循环依赖 
                   singletonObject = singletonFactory.getObject();
                   // 将 singletonObject 放入缓存中，并将 singletonFactory 从缓存中移除 
                   this.earlySingletonObjects.put(beanName, singletonObject);
                   this.singletonFactories.remove(beanName);
                }
             }
          }
       }
       return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

再回到最上面的 doGetBean()，由于没有在缓存中获取到 sharedInstance==null，那么就调用了 `getSingleton(String beanName, ObjectFactory<?> singletonFactory)`

### getSingleton() ###

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
              
        ..........      
        // 调用getObject()----> createBean()去创建对象   
        singletonObject = singletonFactory.getObject();   
        newSingleton = true;  
        ..................  
        // 把创建的对象加入缓存中，并且把早期对象从缓存中移除 
        addSingleton(beanName, singletonObject);   
        return (singletonObject != NULL_OBJECT ? singletonObject : null);  
    }   
    
    protected void addSingleton(String beanName, Object singletonObject) {
           
        synchronized (this.singletonObjects) {
               
          // 放入到缓存对象中  
          this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
          // 暴露对象缓存移除   
          this.singletonFactories.remove(beanName);   
          // 早期对象移除    
          this.earlySingletonObjects.remove(beanName);    
          this.registeredSingletons.add(beanName); 
        } 
    }

createBean() 最终调用的是 AbstractAutowireCapableBeanFactory\#doCreateBean()

### doCreateBean() ###

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)    
        throws BeanCreationException {
         
        
      	// Instantiate the bean.  
      	BeanWrapper instanceWrapper = null;        
      	............................        
      	// 调用构造方法创建 bean对象,并且把bean对象包裹成一个beanwrapper对象
      	instanceWrapper = createBeanInstance(beanName, mbd, args);            
         /*       
          * earlySingletonExposure 用于表示是否”提前暴露“原始对象的引用，用于解决循环依赖。       
          * 对于单例 bean，该变量一般为 true       
          */   
       	  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation 
          if (earlySingletonExposure) {
          
            ..................   
          /*    
           * 把 beanName--和 ObjectFacotry 对象存放在 singletonFactories 缓存中      
           */    
           addSingletonFactory(beanName, new ObjectFactory<Object>() {
           
               /*   
                * 在这里......获取原始对象早期的引用,   
                * 在getEarlyBeanReference中没有被aop拦截器改造，原样返回早期引用      
                */  
               public Object getObject() throws BeansException {
            
                   return getEarlyBeanReference(beanName, mbd, bean); 
               }  
           }); 
          } 
      	 // Initialize the bean instance.   
         Object exposedObject = bean;  
         //......对早期原始对象进行赋值。   
         populateBean(beanName, mbd, instanceWrapper);     
         // 调用bean的后置处理器以及bean的初始化方法   
         exposedObject = initializeBean(beanName, exposedObject, mbd); 
         if (earlySingletonExposure) {
        
    			// 获取指定名称的已注册的单例模式Bean对象
    			Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) {
        
    				// 根据名称获取的已注册的Bean和正在实例化的Bean是同一个
    				if (exposedObject == bean) {
        
    					// 当前实例化的Bean初始化完成
    					exposedObject = earlySingletonReference;
    				}
    				
    				// 当前Bean依赖其他Bean，并且当发生循环引用时不允许新创建实例对象
    				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) 
                    {
        
    					String[] dependentBeans = getDependentBeans(beanName);
    					Set<String> actualDependentBeans = new LinkedHashSet<>
                            (dependentBeans.length);
    					// 获取当前Bean所依赖的其他Bean
    					for (String dependentBean : dependentBeans) {
        
    						// 对依赖Bean进行类型检查
    						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
        
    							actualDependentBeans.add(dependentBean);
    						}
    					}
    				}
    			}
    		}
          // 返回bean  
          return exposedObject;
    }

下面来看 addSingletonFactory()，把提早暴露的 objectFactory 对象存放在 singletonFactories

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        
       Assert.notNull(singletonFactory, "Singleton factory must not be null");
       synchronized (this.singletonObjects) {
        
          if (!this.singletonObjects.containsKey(beanName)) {
        
             this.singletonFactories.put(beanName, singletonFactory);
             this.earlySingletonObjects.remove(beanName);
             this.registeredSingletons.add(beanName);
          }
       }
    }

[Spring_IOC_DI]: https://blog.csdn.net/weixin_43935927/article/details/115275080