Spring Bean解决循环依赖为什么是三级缓存？

public class Main {

    public static void main(String[] args) throws Exception {
        System.out.println(new A());
    }

}

class A {
    public A() {
        new B();
    }
}

class B {
    public B() {
        new A();
    }
}

Exception in thread "main" java.lang.StackOverflowError

@Service
public class AServiceImpl implements AService {
    @Autowired
    private BService bService;
    ...
}
@Service
public class BServiceImpl implements BService {
    @Autowired
    private AService aService;
    ...
}

@Service
public class A {
    public A(B b) {
    }
}
@Service
public class B {
    public B(A a) {
    }
}

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?
 at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:339)
 at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:215)
 at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318)
 at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199)

@Service
public class A {
    @Autowired
    private B b;
}

@Service
public class B {
    @Autowired
    private A a;
}

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Service
public class A {
    @Autowired
    private B b;
}

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Service
public class B {
    @Autowired
    private A a;
}

// 在单例Bean内注入
@Autowired
private A a;

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'mytest.TestSpringBean': Unsatisfied dependency expressed through field 'a'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'a': Unsatisfied dependency expressed through field 'b'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'b': Unsatisfied dependency expressed through field 'a'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?

 at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:596)
 at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:90)
 at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessProperties(AutowiredAnnotationBeanPostProcessor.java:374)

    @Lazy
    @Autowired
    private A a;

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
 ...
 // 从上至下 分表代表这“三级缓存”
 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存
 private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 二级缓存
 private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 三级缓存
 ...
 
 /** Names of beans that are currently in creation. */
 // 这个缓存也十分重要：它表示bean创建过程中都会在里面呆着~
 // 它在Bean开始创建时放值，创建完成时会将其移出~
 private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

 /** Names of beans that have already been created at least once. */
 // 当这个Bean被创建完成后，会标记为这个 注意：这里是set集合 不会重复
 // 至少被创建了一次的  都会放进这里~~~~
 private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
 ...
 @Override
 @Nullable
 public Object getSingleton(String beanName) {
  return getSingleton(beanName, true);
 }
 @Nullable
 protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  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();
      this.earlySingletonObjects.put(beanName, singletonObject);
      this.singletonFactories.remove(beanName);
     }
    }
   }
  }
  return singletonObject;
 }
 ...
 public boolean isSingletonCurrentlyInCreation(String beanName) {
  return this.singletonsCurrentlyInCreation.contains(beanName);
 }
 protected boolean isActuallyInCreation(String beanName) {
  return isSingletonCurrentlyInCreation(beanName);
 }
 ...
}

// 它可以将创建对象的步骤封装到ObjectFactory中 交给自定义的Scope来选择是否需要创建对象来灵活的实现scope。  具体参见Scope接口
@FunctionalInterface
public interface ObjectFactory<T> {
 T getObject() throws BeansException;
}

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
 ...
 protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  ...
  // Eagerly check singleton cache for manually registered singletons.
  // 先去获取一次，如果不为null，此处就会走缓存了~~
  Object sharedInstance = getSingleton(beanName);
  ...
  // 如果不是只检查类型，那就标记这个Bean被创建了~~添加到缓存里 也就是所谓的  当前创建Bean池
  if (!typeCheckOnly) {
   markBeanAsCreated(beanName);
  }
  ...
  // Create bean instance.
  if (mbd.isSingleton()) {
  
   // 这个getSingleton方法不是SingletonBeanRegistry的接口方法  属于实现类DefaultSingletonBeanRegistry的一个public重载方法~~~
   // 它的特点是在执行singletonFactory.getObject();前后会执行beforeSingletonCreation(beanName);和afterSingletonCreation(beanName);  
   // 也就是保证这个Bean在创建过程中，放入正在创建的缓存池里  可以看到它实际创建bean调用的是我们的createBean方法~~~~
   sharedInstance = getSingleton(beanName, () -> {
    try {
     return createBean(beanName, mbd, args);
    } catch (BeansException ex) {
     destroySingleton(beanName);
     throw ex;
    }
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  }
 }
 ...
}

// 抽象方法createBean所在地  这个接口方法是属于抽象父类AbstractBeanFactory的   实现在这个抽象类里
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
 ...
 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
  ...
  // 创建Bean对象，并且将对象包裹在BeanWrapper 中
  instanceWrapper = createBeanInstance(beanName, mbd, args);
  // 再从Wrapper中把Bean原始对象（非代理~~~）  这个时候这个Bean就有地址值了，就能被引用了~~~
  // 注意：此处是原始对象，这点非常的重要
  final Object bean = instanceWrapper.getWrappedInstance();
  ...
  // earlySingletonExposure 用于表示是否”提前暴露“原始对象的引用，用于解决循环依赖。
  // 对于单例Bean，该变量一般为 true   但你也可以通过属性allowCircularReferences = false来关闭循环引用
  // isSingletonCurrentlyInCreation(beanName) 表示当前bean必须在创建中才行
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
  if (earlySingletonExposure) {
   if (logger.isTraceEnabled()) {
    logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
   }
   // 上面讲过调用此方法放进一个ObjectFactory，二级缓存会对应删除的
   // getEarlyBeanReference的作用：调用SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference()这个方法  否则啥都不做
   // 也就是给调用者个机会，自己去实现暴露这个bean的应用的逻辑~~~
   // 比如在getEarlyBeanReference()里可以实现AOP的逻辑~~~  参考自动代理创建器AbstractAutoProxyCreator  实现了这个方法来创建代理对象
   // 若不需要执行AOP的逻辑，直接返回Bean
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  }
  Object exposedObject = bean; //exposedObject 是最终返回的对象
  ...
  // 填充属于，解决@Autowired依赖~
  populateBean(beanName, mbd, instanceWrapper);
  // 执行初始化回调方法们~~~
  exposedObject = initializeBean(beanName, exposedObject, mbd);
  
  // earlySingletonExposure：如果你的bean允许被早期暴露出去 也就是说可以被循环引用  那这里就会进行检查
  // 此段代码非常重要~~~~~但大多数人都忽略了它
  if (earlySingletonExposure) {
   // 此时一级缓存肯定还没数据，但是呢此时候二级缓存earlySingletonObjects也没数据
   //注意，注意：第二参数为false  表示不会再去三级缓存里查了~~~

   // 此处非常巧妙的一点：：：因为上面各式各样的实例化、初始化的后置处理器都执行了，如果你在上面执行了这一句
   //  ((ConfigurableListableBeanFactory)this.beanFactory).registerSingleton(beanName, bean);
   // 那么此处得到的earlySingletonReference 的引用最终会是你手动放进去的Bean最终返回，完美的实现了"偷天换日" 特别适合中间件的设计
   // 我们知道，执行完此doCreateBean后执行addSingleton()  其实就是把自己再添加一次  **再一次强调，完美实现偷天换日**
   Object earlySingletonReference = getSingleton(beanName, false);
   if (earlySingletonReference != null) {
   
    // 这个意思是如果经过了initializeBean()后，exposedObject还是木有变，那就可以大胆放心的返回了
    // initializeBean会调用后置处理器，这个时候可以生成一个代理对象，那这个时候它哥俩就不会相等了 走else去判断吧
    if (exposedObject == bean) {
     exposedObject = earlySingletonReference;
    } 

    // allowRawInjectionDespiteWrapping这个值默认是false
    // hasDependentBean：若它有依赖的bean 那就需要继续校验了~~~(若没有依赖的 就放过它~)
    else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
     // 拿到它所依赖的Bean们~~~~ 下面会遍历一个一个的去看~~
     String[] dependentBeans = getDependentBeans(beanName);
     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
     
     // 一个个检查它所以Bean
     // removeSingletonIfCreatedForTypeCheckOnly这个放见下面  在AbstractBeanFactory里面
     // 简单的说，它如果判断到该dependentBean并没有在创建中的了的情况下,那就把它从所有缓存中移除~~~  并且返回true
     // 否则（比如确实在创建中） 那就返回false 进入我们的if里面~  表示所谓的真正依赖
     //（解释：就是真的需要依赖它先实例化，才能实例化自己的依赖）
     for (String dependentBean : dependentBeans) {
      if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
       actualDependentBeans.add(dependentBean);
      }
     }

     // 若存在真正依赖，那就报错（不要等到内存移除你才报错，那是非常不友好的） 
     // 这个异常是BeanCurrentlyInCreationException，报错日志也稍微留意一下，方便定位错误~~~~
     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.");
     }
    }
   }
  }
  
  return exposedObject;
 }

 // 虽然是remove方法 但是它的返回值也非常重要
 // 该方法唯一调用的地方就是循环依赖的最后检查处~~~~~
 protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName) {
  // 如果这个bean不在创建中  比如是ForTypeCheckOnly的  那就移除掉
  if (!this.alreadyCreated.contains(beanName)) {
   removeSingleton(beanName);
   return true;
  }
  else {
   return false;
  }
 }

}

if (exposedObject == bean) {
 exposedObject = earlySingletonReference;
}

protected <T> T doGetBean(...){
 ... 
 // 标记beanName a是已经创建过至少一次的~~~ 它会一直存留在缓存里不会被移除（除非抛出了异常）
 // 参见缓存Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256))
 if (!typeCheckOnly) {
  markBeanAsCreated(beanName);
 }

 // 此时a不存在任何一级缓存中，且不是在创建中  所以此处返回null
 // 此处若不为null，然后从缓存里拿就可以了(主要处理FactoryBean和BeanFactory情况吧)
 Object beanInstance = getSingleton(beanName, false);
 ...
 // 这个getSingleton方法非常关键。
 //1、标注a正在创建中~
 //2、调用singletonObject = singletonFactory.getObject();（实际上调用的是createBean()方法）  因此这一步最为关键
 //3、此时实例已经创建完成  会把a移除整整创建的缓存中
 //4、执行addSingleton()添加进去。（备注：注册bean的接口方法为registerSingleton，它依赖于addSingleton方法）
 sharedInstance = getSingleton(beanName, () -> { ... return createBean(beanName, mbd, args); });
}

protected Object doCreateBean(){
 ...
 // 使用构造器/工厂方法   instanceWrapper是一个BeanWrapper
 instanceWrapper = createBeanInstance(beanName, mbd, args);
 // 此处bean为"原始Bean"   也就是这里的A实例对象：A@1234
 final Object bean = instanceWrapper.getWrappedInstance();
 ...
 // 是否要提前暴露（允许循环依赖）  现在此处A是被允许的
 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
 
 // 允许暴露，就把A绑定在ObjectFactory上，注册到三级缓存`singletonFactories`里面去保存着
 // Tips:这里后置处理器的getEarlyBeanReference方法会被促发，自动代理创建器在此处创建代理对象（注意执行时机 为执行三级缓存的时候）
 if (earlySingletonExposure) {
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
 }
 ...
 // exposedObject 为最终返回的对象，此处为原始对象bean也就是A@1234,下面会有用处
 Object exposedObject = bean; 
 // 给A@1234属性完成赋值，@Autowired在此处起作用~
 // 因此此处会调用getBean("b")，so 会重复上面步骤创建B类的实例
 // 此处我们假设B已经创建好了 为B@5678
 
 // 需要注意的是在populateBean("b")的时候依赖有beanA，所以此时候调用getBean("a")最终会调用getSingleton("a")，
 //此时候上面说到的getEarlyBeanReference方法就会被执行。这也解释为何我们@Autowired是个代理对象，而不是普通对象的根本原因
 
 populateBean(beanName, mbd, instanceWrapper);
 // 实例化。这里会执行后置处理器BeanPostProcessor的两个方法
 // 此处注意：postProcessAfterInitialization()是有可能返回一个代理对象的，这样exposedObject 就不再是原始对象了  特备注意哦~~~
 // 比如处理@Aysnc的AsyncAnnotationBeanPostProcessor它就是在这个时间里生成代理对象的（有坑，请小心使用@Aysnc）
 exposedObject = initializeBean(beanName, exposedObject, mbd);

 ... // 至此，相当于A@1234已经实例化完成、初始化完成（属性也全部赋值了~）
 // 这一步我把它理解为校验：校验：校验是否有循环引用问题~~~~~

 if (earlySingletonExposure) {
  // 注意此处第二个参数传的false，表示不去三级缓存里singletonFactories再去调用一次getObject()方法了~~~
  // 上面建讲到了由于B在初始化的时候，会触发A的ObjectFactory.getObject()  所以a此处已经在二级缓存earlySingletonObjects里了
  // 因此此处返回A的实例：A@1234
  Object earlySingletonReference = getSingleton(beanName, false);
  if (earlySingletonReference != null) {
  
   // 这个等式表示，exposedObject若没有再被代理过，这里就是相等的
   // 显然此处我们的a对象的exposedObject它是没有被代理过的  所以if会进去~
   // 这种情况至此，就全部结束了~~~
   if (exposedObject == bean) {
    exposedObject = earlySingletonReference;
   }
 
   // 继续以A为例，比如方法标注了@Aysnc注解，exposedObject此时候就是一个代理对象，因此就会进到这里来
   //hasDependentBean(beanName)是肯定为true，因为getDependentBeans(beanName)得到的是["b"]这个依赖
   else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    String[] dependentBeans = getDependentBeans(beanName);
    Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);

    // A@1234依赖的是["b"]，所以此处去检查b
    // 如果最终存在实际依赖的bean：actualDependentBeans不为空 那就抛出异常  证明循环引用了~
    for (String dependentBean : dependentBeans) {
     // 这个判断原则是：如果此时候b并还没有创建好，this.alreadyCreated.contains(beanName)=true表示此bean已经被创建过，就返回false
     // 若该bean没有在alreadyCreated缓存里，就是说没被创建过(其实只有CreatedForTypeCheckOnly才会是此仓库)
     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.");
    }
   }
  }
 }
}

@Service
public class HelloServiceImpl implements HelloService {
    @Autowired
    private HelloService helloService;
    
    @Transactional
    @Override
    public Object hello(Integer id) {
        return "service hello";
    }
}

protected Object doCreateBean( ... ){
 ...
 
 // 这段告诉我们：如果允许循环依赖的话，此处会添加一个ObjectFactory到三级缓存里面，以备创建对象并且提前暴露引用~
 // 此处Tips：getEarlyBeanReference是后置处理器SmartInstantiationAwareBeanPostProcessor的一个方法，它的功效为：
 // 保证自己被循环依赖的时候，即使被别的Bean @Autowire进去的也是代理对象~~~~  AOP自动代理创建器此方法里会创建的代理对象~~~
 // 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) { // 需要提前暴露（支持循环依赖），就注册一个ObjectFactory到三级缓存
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
 }

 // 此处注意：如果此处自己被循环依赖了  那它会走上面的getEarlyBeanReference，从而创建一个代理对象从三级缓存转移到二级缓存里
 // 注意此时候对象还在二级缓存里，并没有在一级缓存。并且此时可以知道exposedObject仍旧是原始对象~~~
 populateBean(beanName, mbd, instanceWrapper);
 exposedObject = initializeBean(beanName, exposedObject, mbd);
 
 // 经过这两大步后，exposedObject还是原始对象（注意此处以事务的AOP为例子的，
 // 因为事务的AOP自动代理创建器在getEarlyBeanReference创建代理后，initializeBean就不会再重复创建了，二选一的，下面会有描述~~~）
 
 ...
 
 // 循环依赖校验（非常重要）~~~~
 if (earlySingletonExposure) {
  // 前面说了因为自己被循环依赖了，所以此时候代理对象还在二级缓存里~~~（备注：本利讲解的是自己被循环依赖了的情况）
  // so，此处getSingleton，就会把里面的对象拿出来，我们知道此时候它已经是个Proxy代理对象~~~
  // 最后赋值给exposedObject  然后return出去，进而最终被addSingleton()添加进一级缓存里面去  
  // 这样就保证了我们容器里**最终实际上是代理对象**，而非原始对象~~~~~
  Object earlySingletonReference = getSingleton(beanName, false);
  if (earlySingletonReference != null) {
   if (exposedObject == bean) { // 这个判断不可少（因为如果initializeBean改变了exposedObject ，就不能这么玩了，否则就是两个对象了~~~）
    exposedObject = earlySingletonReference;
   }
  }
  ...
 }
 
}

protected Object doCreateBean( ... ) {
  ...
  // 这些语句依旧会执行，三级缓存里是会加入的  表示它支持被循环引用嘛~~~
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
 ...
 
 // 此处注意，因为它没有被其它Bean循环引用（注意是循环引用，而不是直接引用~）,所以上面getEarlyBeanReference不会执行~
 // 也就是说此时二级缓存里并不会存在它~~~ 知晓这点特别的重要
 populateBean(beanName, mbd, instanceWrapper);
 // 重点在这：AnnotationAwareAspectJAutoProxyCreator自动代理创建器此处的postProcessAfterInitialization方法里，会给创建一个代理对象返回
 // 所以此部分执行完成后，exposedObject **已经是个代理对象**而不再是个原始对象了~~~~ 此时二级缓存里依旧无它，更别提一级缓存了
 exposedObject = initializeBean(beanName, exposedObject, mbd);

 ...
 
 // 循环依赖校验
 if (earlySingletonExposure) {
  // 前面说了一级、二级缓存里都木有它，然后这里传的又是false（表示不看三级缓存~~）
  // 所以毋庸置疑earlySingletonReference = null  so下面的逻辑就不用看了，直接return出去~~
  // 然后执行addSingleton()方法，由此可知  容器里最终存在的也还是代理对象~~~~~~
  Object earlySingletonReference = getSingleton(beanName, false);
  if (earlySingletonReference != null) {
   if (exposedObject == bean) { // 这个判断不可少（因为如果initializeBean改变了exposedObject ，就不能这么玩了，否则就是两个对象了~~~）
    exposedObject = earlySingletonReference;
   }
  }...
  ...
  ...
 }
}

// 它用于关闭循环引用（关闭后只要有循环引用现象就直接报错~~）
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(false);
    }
}

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?
 at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:339)
 at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:215)

@Service
public class HelloServiceImpl implements HelloService {

 // 因为管理了循环依赖，所以此处不能再依赖自己的
 // 但是：我们的此bean还是需要AOP代理的~~~
    //@Autowired
    //private HelloService helloService;
    
    @Transactional
    @Override
    public Object hello(Integer id) {
        return "service hello";
    }
}

protected Object doCreateBean( ... ) {
 // 毫无疑问此时候earlySingletonExposure = false  也就是Bean都不会提前暴露引用了  显然就不能被循环依赖了~
 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
 ...
 populateBean(beanName, mbd, instanceWrapper);
 // 若是事务的AOP  在这里会为源生Bean创建代理对象（因为上面没有提前暴露这个代理）
 exposedObject = initializeBean(beanName, exposedObject, mbd);

 if (earlySingletonExposure) {
  ... 这里更不用说，因为earlySingletonExposure=false  所以上面的代理对象exposedObject 直接return了~
 }
}

// @since 13.10.2003  它实现代理创建的方法有如下两个
// 实现了SmartInstantiationAwareBeanPostProcessor 所以有方法getEarlyBeanReference来只能的解决循环引用问题：提前把代理对象暴露出去~
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
 ...
 // 下面两个方法是自动代理创建器创建代理对象的唯二的两个节点~

 // 提前暴露代理对象的引用  它肯定在postProcessAfterInitialization之前执行
 // 所以它并不需要判断啥的~~~~  创建好后放进缓存earlyProxyReferences里  注意此处value是原始Bean
 @Override
 public Object getEarlyBeanReference(Object bean, String beanName) {
  Object cacheKey = getCacheKey(bean.getClass(), beanName);
  this.earlyProxyReferences.put(cacheKey, bean);
  return wrapIfNecessary(bean, beanName, cacheKey);
 }

 // 因为它会在getEarlyBeanReference之后执行，所以此处的重要逻辑是下面的判断
 @Override
 public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
  if (bean != null) {
   Object cacheKey = getCacheKey(bean.getClass(), beanName);
   // remove方法返回被移除的value，上面说了它记录的是原始bean
   // 若被循环引用了，那就是执行了上面的`getEarlyBeanReference`方法，所以此时remove返回值肯定是==bean的（注意此时方法入参的bean还是原始对象）
   // 若没有被循环引用，getEarlyBeanReference()不执行 所以remove方法返回null，所以就进入if执行此处的创建代理对象方法~~~
   if (this.earlyProxyReferences.remove(cacheKey) != bean) {
    return wrapIfNecessary(bean, beanName, cacheKey);
   }
  }
  return bean;
 }
 ...
}