//org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

	/** 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);

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;
	}

//org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
/** Names of beans that are currently in creation. */
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

//org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);

@Component
class A{
  @Autowired
  private B b;
}

@Component
class B{
  @Autowired
  private A a;
}

@Component
@Transactional
class C{
  @Autowired
  private D d;
}

@Component
@Transactional
class D{
  @Autowired
  private C c;
}

@Component
class E{
  @Autowired
  private C c;
}

A a =new A();
put A into cache1
	B b =new B();
	get A from cache1
	b.a = a;
	beanPostProcessors(...aop...) & skip proxy wrap
	put B into cache2
get B from cache2
a.b = b;
beanPostProcessors(...aop...) & skip proxy wrap
put A into cache2

C c = new C();
	D d = new D();
	d.c = proxy(c);
	put proxy(c) to cache1
  beanPostProcessors(...aop...) & proxy wrap & put proxy(d) to cache1
  put D to cache2
get D from cache2
c.d = proxy(d)
beanPostProcessors(...aop...)	& already proxy
put C to cache2
E e =new E()
get proxy(c) from cache1
e.c = proxy(c)
beanPostProcessors(...aop...) & skip proxy wrap
put E to cache2

private Object buildLazyResolutionProxy(
			final DependencyDescriptor descriptor, final @Nullable String beanName, boolean classOnly) {

		BeanFactory beanFactory = getBeanFactory();
		Assert.state(beanFactory instanceof DefaultListableBeanFactory,
				"BeanFactory needs to be a DefaultListableBeanFactory");
		final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;

		TargetSource ts = new TargetSource() {
			@Override
			public Class<?> getTargetClass() {
				return descriptor.getDependencyType();
			}
			@Override
			public boolean isStatic() {
				return false;
			}
			@Override
			public Object getTarget() {
				Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);
				Object target = dlbf.doResolveDependency(descriptor, beanName, autowiredBeanNames, null);
				if (target == null) {
					Class<?> type = getTargetClass();
					if (Map.class == type) {
						return Collections.emptyMap();
					}
					else if (List.class == type) {
						return Collections.emptyList();
					}
					else if (Set.class == type || Collection.class == type) {
						return Collections.emptySet();
					}
					throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
							"Optional dependency not present for lazy injection point");
				}
				if (autowiredBeanNames != null) {
					for (String autowiredBeanName : autowiredBeanNames) {
						if (dlbf.containsBean(autowiredBeanName)) {
							dlbf.registerDependentBean(autowiredBeanName, beanName);
						}
					}
				}
				return target;
			}
			@Override
			public void releaseTarget(Object target) {
			}
		};

		ProxyFactory pf = new ProxyFactory();
		pf.setTargetSource(ts);
		Class<?> dependencyType = descriptor.getDependencyType();
		if (dependencyType.isInterface()) {
			pf.addInterface(dependencyType);
		}
		ClassLoader classLoader = dlbf.getBeanClassLoader();
		return (classOnly ? pf.getProxyClass(classLoader) : pf.getProxy(classLoader));
	}

@Service
public class AService {

    private BService bService;

    /**
     * 非Lazy模式注入LazyBean会导致延迟失效,未达到lazy意图的使用方式
     */
    @Autowired
    private CService cService;

    /**
     * Lazy模式注入LazyBean,bean会在使用时初始化,正确使用方式
     */
    @Autowired
    @Lazy
    private DService dService;


    /**
     * lazy模式注入非LazyBean,不会达到使用时初始化的效果但是可以打破循环依赖，将这种bean创建推迟到靠后的阶段
     * Lazy仅标注在使用处会在beanFactory.preInstantiateSingletons()阶段触发bean创建
     * BService本身并不是延迟初始化bean
     *
     * @param bService
     */
    public AService(@Lazy BService bService) {
        System.out.println("init AService");
        this.bService = bService;
    }

    /**
     * 会在运行时执行该方法时创建DService单例bean
     */
    public void runLazy() {
        dService.test();
    }
}

@Service
public class BService {
    private AService aService;

    public BService(AService aService) {
        this.aService = aService;
        System.out.println("init BService");
    }
}

@Service
@Lazy
public class CService {

    public CService() {
        System.out.println("init CService");
    }
}

@Service
@Lazy
public class DService {
    @Autowired
    private AService aService;

    public DService() {
        System.out.println("init DService");
    }

    public void test() {
        System.out.println("run DService test");
    }
}

init AService
init CService
init BService