Spring 循环依赖

Spring 循环依赖

1. Spring的循环依赖
   • Spring 的循环依赖主要是是指，两个类互相引用，在IOC注入时，互相创建引用。有两种依赖方式：属性注入依赖，构造方法注入依赖
   • 如何解决？
   • 对于属性注入依赖Spring通过三重缓存的机制来解决，类实例化以后在内存中的引用不会变化，剩下的只是注入一些属性,如果是构造器注入依赖则无解

   
   /** Cache of singleton objects: bean name to bean instance. */
   private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
   
   /** Cache of singleton factories: bean name to ObjectFactory. */
   private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
   
   /** Cache of early singleton objects: bean name to bean instance. */
   private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
   
   /**
   * singletonObjects          缓存已经初始化完成的bean
   * earlySingletonObjects     缓存正在初始中，且产生循环引用的bean
   * singletonFactories        缓存正在初始化的org.springframework.beans.factory.ObjectFactory
   **/
   @Nullable
   protected Object getSingleton(String beanName, boolean allowEarlyReference) {
       // Quick check for existing instance without full singleton lock
       Object singletonObject = this.singletonObjects.get(beanName);
       if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
           singletonObject = this.earlySingletonObjects.get(beanName);
           if (singletonObject == null && allowEarlyReference) {
               synchronized (this.singletonObjects) {
                   // Consistent creation of early reference within full singleton lock
                   singletonObject = this.singletonObjects.get(beanName);
                   if (singletonObject == null) {
                       singletonObject = this.earlySingletonObjects.get(beanName);
                       if (singletonObject == null) {
                           ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                           if (singletonFactory != null) {
                               singletonObject = singletonFactory.getObject();
                               this.earlySingletonObjects.put(beanName, singletonObject);
                               this.singletonFactories.remove(beanName);
                           }
                       }
                   }
               }
           }
       }
       return singletonObject;
   }
   
   
   // 方法doCreateBean 中将实例化的bean，包装进 ObjectFactory 放进 singletonFactories
   
   
   protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
           throws BeanCreationException {
   
       // Instantiate the bean.
       BeanWrapper instanceWrapper = null;
       if (mbd.isSingleton()) {
           instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
       }
       if (instanceWrapper == null) {
           //创建实例，创建策略有工厂方法，构造器注入，简单创建
           //org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors  查找构造器注入方法=
           instanceWrapper = createBeanInstance(beanName, mbd, args);
       }
       Object bean = instanceWrapper.getWrappedInstance();
       …………
       // Eagerly cache singletons to be able to resolve circular references
       // even when triggered by lifecycle interfaces like BeanFactoryAware.
       boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
               isSingletonCurrentlyInCreation(beanName));
       if (earlySingletonExposure) {
           //将实例化的bean包装成ObjectFactory,并缓存
           addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
       }
   
       // Initialize the bean instance.
       Object exposedObject = bean;
       try {
           //将依赖的的类初始化并注入
          // org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessProperties
           populateBean(beanName, mbd, instanceWrapper);
           //初始化
           //Initialize the given bean instance, applying factory callbacks
           //as well as init methods and bean post processors.
           //org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor#postProcessBeforeInitialization  注入属性 @ConfigurationProperties
           exposedObject = initializeBean(beanName, exposedObject, mbd);
       }
       catch (Throwable ex) {
           if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
               throw (BeanCreationException) ex;
           }
           else {
               throw new BeanCreationException(
                       mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
           }
       }
   
      …………
   
       return exposedObject;
   }
   
   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);
           }
       }
   }