spring解决依赖循环

搭建源码调试环境

• 安装gradle
• github上下载spring-framework 源码，我下载的是spring-framework-4.3.13.RELEASE.zip
• 解压到本地，执行根目录下的import-into-eclipse.bat 批处理文件，可以自动将整个项目生成为eclipse
  工程文件
• 使用eclipse 打开工程根目录，可以发现所有spring 项目都导入了eclipse
• 找到测试文件，打开spring-beans 工程，里面有一个src/test/java 的文件夹，里面有专门测试依赖循环的类org.springframework.beans.factory
  对应的bean 配置文件在src/test/resources 的FactoryBeanTest-circular.xml 文件中。

bean 配置文件和测试类

配置文件

类定义

BeanImpl1和BeanImpl2互相依赖，可以看到他们的类定义

public static class BeanImpl1 {

    private BeanImpl2 impl2;

    public BeanImpl2 getImpl2() {
      return impl2;
    }

    public void setImpl2(BeanImpl2 impl2) {
      this.impl2 = impl2;
    }
  }


  public static class BeanImpl2 {

    private BeanImpl1 impl1;

    public BeanImpl1 getImpl1() {
      return impl1;
    }

    public void setImpl1(BeanImpl1 impl1) {
      this.impl1 = impl1;
    }
  }

每个类有一个PassThroughFactoryBean工厂类，工厂类实现了FactoryBean和BeanFactoryAware接口,作用未知。

测试类

自定义了一个最简的测试类

  public void testMyCircularReferenceWithPostProcessor() {
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();  
    new XmlBeanDefinitionReader(factory).loadBeanDefinitions(MY_CIRCULAR_CONTEXT);
    CountingPostProcessor counter = new CountingPostProcessor();
    factory.addBeanPostProcessor(counter);

    BeanImpl1 impl1 = factory.getBean(BeanImpl1.class);
    System.out.println(impl1);
  }

调试过程

在BeanImpl1 impl1 = factory.getBean(BeanImpl1.class)打上断点，跟踪发现进入了
org.springframework.beans.factory.support.DefaultListableBeanFactory类

  public  T getBean(Class requiredType) throws BeansException {
    return getBean(requiredType, (Object[]) null);
  }

//实际执行的方法
  public  T getBean(Class requiredType, Object... args) throws BeansException {
    //实际bean的创建是由resolveNameBean完成的
    NamedBeanHolder namedBean = resolveNamedBean(requiredType, args);
    if (namedBean != null) {
      return namedBean.getBeanInstance();
    }
    BeanFactory parent = getParentBeanFactory();
    if (parent != null) {
      return parent.getBean(requiredType, args);
    }
    throw new NoSuchBeanDefinitionException(requiredType);
  }

跟踪DefaultListableBeanFactory.resolveNamedBean(requiredType, args),requiredType=org.springframework.beans.factory.FactoryBeanTests$BeanImpl1,args=null。
该函数调用了DefaultListableBeanFactory.getBeanNamesForType(Class type),type=org.springframework.beans.factory.FactoryBeanTests$BeanImpl1
在其内部调用了DefaultListableBeanFactory.getBeanNamesForType(Class type, boolean includeNonSingletons, boolean allowEagerInit)。
在其内部调用了AbstractBeanFactory.isTypeMatch(String name, ResolvableType typeToMatch)，name=beanImpl1，
typeToMatch=org.springframework.beans.factory.FactoryBeanTests$BeanImpl1,其中AbstractBeanFactory是
DefaultListableBeanFactory的爷爷类
以上描述完，弯弯绕绕其实spring想干的是就是根据beanType去获取beanInstance，上面并不是主题。
在isTypeMatch函数中第一次调用到了DefaultSingletonBeanRegistry.getSingleton(String beanName, boolean allowEarlyReference)函数，这时beanImpl1还没有创建，现在只知道beanImpl1的beanName和beanType,也就是只知道xml配置中的内容。
现在的目标是创建一个benaImpl1。在初次调用getSingleton(String beanName, boolean allowEarlyReference)的时候
beanName=beanImpl1,allowEarlyReference=false。这里设置allowEarlyRefernce为false的原因是spring还什么都没干，
如果有人想在他创建完成之间引用他，是不被允许的。
查看源码

//这里尝试从缓存中获取singletonObject
  protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //singletonObjects这时候是空的
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
          ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
          if (singletonFactory != null) {
            singletonObject = singletonFactory.getObject();
            //可以看到earlySingletonObjects的赋值条件是当这个bean的ObjectFactory已经注册到了
            //singletonFactories中，关于singletonFactories请看下方
            this.earlySingletonObjects.put(beanName, singletonObject);
            this.singletonFactories.remove(beanName);
          }
        }
      }
    }
    //最终返回null
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
  }

看到this.singletonObjects,查看定义发现在DefaultSingletonBeanRegistry类中定义了一系列需要用到的缓存内容。
这些在实现singleton，解决singleton循环依赖中是非常重要的,以下列出

/** Cache of singleton objects: bean name --> bean instance */
/*singleton对象缓存*/
  private final Map singletonObjects = new ConcurrentHashMap(256);

  /** Cache of singleton factories: bean name --> ObjectFactory */
  /*singleton工厂类缓存是解决依赖循环的关键，singleton工厂类作用以后会细说*/
  private final Map> singletonFactories = new HashMap>(16);

  /** 在创建中的singleton 类缓存，我本以为解决依赖循环一定用到他，后来发现他的使用是有条件的
   * 因为他还需要Object
   */
  private final Map earlySingletonObjects = new HashMap(16);

  /** Set of registered singletons, containing the bean names in registration order */
  private final Set registeredSingletons = new LinkedHashSet(256);

  /** Names of beans that are currently in creation */
  /*正在创建的bean类，这里只存储他们的beanName，不需要Object*/
  private final Set singletonsCurrentlyInCreation =
      Collections.newSetFromMap(new ConcurrentHashMap(16));

回到原来的地方，从缓存中获取singletonObject失败了，其中由于在检查beanName和beanType是否配对的时候，
需要遍历所有的bean定义，这里将调用到DefaultSingletonBeanRegistry.getSingleton(String beanName, boolean allowEarlyReference)，其中beanName=beanImpl2,allowEarlyReference=false,不过依旧是返回null,缓存内容也没有变化。

在获取了和beanType对应的beanName之后,由于此处对应的beanName只有一个,会直接构建
NamedBeanHolder(beanName, getBean(beanName, requiredType, args))作为resolveNamedBean的返回结果。
注意这里调用了一个不同的getBean函数AbstractBeanFactory.getBean(String name, Class requiredType, Object... args)
是爷爷类AbstractBeanFactory中定义的函数，

  public  T getBean(String name, Class requiredType, Object... args) throws BeansException {
    return doGetBean(name, requiredType, args, false);
  }
  //实际干活的函数
  protected  T doGetBean(
      final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
      throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    //立即检查缓存，这里返回null，但这个doGetBean函数里存在递归调用，以后就有货了
    Object sharedInstance = getSingleton(beanName);
    //无关代码
    ...
      
      //typeCheckOnly=false
      if (!typeCheckOnly) {
        //这个函数的作用:
        //AbstractBeanFactory有这样一个私有成员
        //private final Set alreadyCreated =
      //Collections.newSetFromMap(new ConcurrentHashMap(256));
      //注释是‘Names of beans that have already been created at least once’
      //这个函数的作用就是检查alreadyCreated是否有这个变量，如果没有则加入，
      //但此处bean还没有被创建，仅仅是访问到了。
      //可能与循环依赖有关，先进行注意。
        markBeanAsCreated(beanName);
      }

      try {
        //合并父bean定义
        final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        checkMergedBeanDefinition(mbd, beanName, args);

        // Guarantee initialization of beans that the current bean depends on.
        //由于我们此处没有设置depend-on属性，所以返回null
        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);
            getBean(dep);
          }
        }

        // Create bean instance.
       //创建bean instance
        if (mbd.isSingleton()) {
          //出现了新的getSingleton函数，这里有一个匿名内部类ObjectFactory,
         //其中createBean()方法可以根据名称判定是一个干活型的方法,现在这里进入getSingleton方法
          sharedInstance = getSingleton(beanName, new ObjectFactory