org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'springTransactionService': Bean with name 'springTransactionService' has been injected into other beans [userService] 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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.

AbstractAutowireCapableBeanFactory.java 
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args){
  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
}

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) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		//检查是否已经对 Bean 定义进行了后处理，如果没有，则调用 applyMergedBeanDefinitionPostProcessors 方法应用后处理器。
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// 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));
		//如果允许循环引用，并且当前 Bean 是单例，则调用 addSingletonFactory 方法，提供一个回调以获取早期 Bean 引用。
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
      // 添加第3级缓存， 此处第二个参数又是一个ObjectFactory的匿名类实现
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			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);
			}
		}
		// 验证循环引用的处理过程是否正确
		if (earlySingletonExposure) {
			// 尝试获取早期引用，那么这个早期引用肯定是因为循环依赖，其他bean在getSingleton(beanName, true)生产出来的
			// 因为该bean 自己的生产过程中，只会主动添加一级、三级缓存
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				// 表示init后，Bean实例未被代理,在未代理的情况下，exposedObject 和 bean 是相同的引用

				if (exposedObject == bean) {
					// 如果存在早期暴露的单例引用，并且exposedObject未被代理，将exposedObject替换为早期暴露的单例引用。
					exposedObject = earlySingletonReference;
				} // 如果在暴露早期引用的情况下，init阶段还存在代理操作时，要确保依赖当前bean 的其他bean 引用到了正确的版本
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					// 获取所有依赖当前Bean的Bean名称。
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						// 尝试移除只为类型检查而创建的单例Bean。如果成功移除，表示这个Bean只是为类型检查而创建的，不是实际使用的Bean。
						// 通过这个循环，Spring会过滤掉那些只为类型检查而创建的Bean，保留那些实际依赖当前Bean的Bean。
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						// 这段逻辑确保在处理循环依赖时，确保依赖的Bean使用的是最终版本的Bean，而不是中间状态的原始Bean。
						// 如果存在实际依赖当前Bean的Bean。抛出BeanCurrentlyInCreationException异常
						// 因为这意味着有Bean在循环依赖的过程中使用了当前Bean的原始版本，但最终当前Bean被包装（如被AOP代理）。
						// 这意味着被依赖的Bean使用的不是最终版本的Bean，这可能导致一些问题。
						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 " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}
		return exposedObject;
	}

	// 验证循环引用的处理过程是否正确
if (earlySingletonExposure) {
	// 尝试获取早期引用，那么这个早期引用肯定是因为循环依赖，其他bean在getSingleton(beanName, true)生产出来的
	// 因为该bean 自己的生产过程中，只会主动添加一级、三级缓存
	Object earlySingletonReference = getSingleton(beanName, false);
	if (earlySingletonReference != null) {
		// 表示init后，Bean实例未被代理,在未代理的情况下，exposedObject 和 bean 是相同的引用

		if (exposedObject == bean) {
			// 如果存在早期暴露的单例引用，并且exposedObject未被代理，将exposedObject替换为早期暴露的单例引用。
			exposedObject = earlySingletonReference;
		} // 如果在暴露早期引用的情况下，init阶段还存在代理操作时，要确保依赖当前bean 的其他bean 引用到了正确的版本
		else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
			// 获取所有依赖当前Bean的Bean名称。
			String[] dependentBeans = getDependentBeans(beanName);
			Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
			for (String dependentBean : dependentBeans) {
				// 尝试移除只为类型检查而创建的单例Bean。如果成功移除，表示这个Bean只是为类型检查而创建的，不是实际使用的Bean。
				// 通过这个循环，Spring会过滤掉那些只为类型检查而创建的Bean，保留那些实际依赖当前Bean的Bean。
				if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
					actualDependentBeans.add(dependentBean);
				}
			}
			if (!actualDependentBeans.isEmpty()) {
				// 这段逻辑确保在处理循环依赖时，确保依赖的Bean使用的是最终版本的Bean，而不是中间状态的原始Bean。
				// 如果存在实际依赖当前Bean的Bean。抛出BeanCurrentlyInCreationException异常
				// 因为这意味着有Bean在循环依赖的过程中使用了当前Bean的原始版本，但最终当前Bean被包装（如被AOP代理）。
				// 这意味着被依赖的Bean使用的不是最终版本的Bean，这可能导致一些问题。
				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 " +
						"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
			}
		}
	}
}

BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);

// bean 指create阶段后获取的引用， 这个引用非常原始，肯定不会是代理对象
Object bean = instanceWrapper.getWrappedInstance();

// exposedObject 是doCreateBean方法最终会返回的数据
// 经过init阶段后，如果执行了代理逻辑，则会产生一个新的代理对象赋值给 exposedObject，这时exposedObject和bean就不相等了
Object exposedObject = bean;
exposedObject = initializeBean(beanName, exposedObject, mbd);


// bean的早期引用， 即三级缓存中第二级缓存
Object earlySingletonReference = getSingleton(beanName, false);

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport  
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
  // 生成了早期引用的bean缓存，
	private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);
  
	@Override  
	public Object getEarlyBeanReference(Object bean, String beanName) {  
		Object cacheKey = getCacheKey(bean.getClass(), beanName);  
		this.earlyProxyReferences.put(cacheKey, bean);  
		return wrapIfNecessary(bean, beanName, cacheKey);  
	}
	
	@Override  
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { 
		// 如果 `bean` 为 `null`，则直接返回 `null`。
		if (bean != null) {  
			Object cacheKey = getCacheKey(bean.getClass(), beanName);  
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {  
				return wrapIfNecessary(bean, beanName, cacheKey);  
			}  
		}  
		return bean;  
	}
  
  	protected Object getCacheKey(Class<?> beanClass, @Nullable String beanName) {
		if (StringUtils.hasLength(beanName)) {
			return (FactoryBean.class.isAssignableFrom(beanClass) ?
					BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
		}
		else {
			return beanClass;
		}
	}
}

if (this.earlyProxyReferences.remove(cacheKey) != bean)

@Service
public class SpringTransactionService {
    @Autowired
    UserService userService;

    public void performTransaction() {
        // 模拟业务逻辑
        System.out.println("performTransaction");
    }
}

@Service
public class UserService implements UserI {

    @Autowired
    SpringTransactionService springTransactionService;
    @Override
    public void createUser(String username) {
        // 模拟业务处理
        System.out.println("Creating user: " + username);
    }

    @Override
    public void deleteUser(String username) {
        // 模拟业务处理
        System.out.println("Deleting user: " + username);
    }
}

@Aspect
@Component
public class LoggingAspect {
    //定义一个匹配userService中所有方法的切点表达式
    @Pointcut("execution(* com.example.codingInAction.service.*.*(..))")
    public void userServiceAllMethod() {
    }

    // 在方法执行之前执行的通知
    @Before("userServiceAllMethod()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    // 在方法执行之后执行的通知
    @After("userServiceAllMethod()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }

    // 定义一个只匹配 UserService.createUser 方法的切点表达式
    @Around("execution(* com.example.codingInAction.service.UserService.createUser(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println(joinPoint.getSignature().getName() + " 方法开始执行");

        Object result = joinPoint.proceed();  // 执行目标方法

        long endTime = System.currentTimeMillis();
        System.out.println(joinPoint.getSignature().getName() + " 方法执行时间: " + (endTime - startTime) + "ms");

        return result;
    }
}

// 示例代码启动入口
@SpringBootApplication
public class CodingInActionApplication {

    public static void main(String[] args) {
        SpringApplication.run(CodingInActionApplication.class, args);

public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements BeanPostProcessor {
  @Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (this.advisor == null || bean instanceof AopInfrastructureBean) {
			// Ignore AOP infrastructure such as scoped proxies.
			return bean;
		}

		if (bean instanceof Advised) {
			Advised advised = (Advised) bean;
			if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
				// Add our local Advisor to the existing proxy's Advisor chain...
				if (this.beforeExistingAdvisors) {
					advised.addAdvisor(0, this.advisor);
				}
				else {
					advised.addAdvisor(this.advisor);
				}
				return bean;
			}
		}

		if (isEligible(bean, beanName)) {
			ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
			if (!proxyFactory.isProxyTargetClass()) {
				evaluateProxyInterfaces(bean.getClass(), proxyFactory);
			}
			proxyFactory.addAdvisor(this.advisor);
			customizeProxyFactory(proxyFactory);
			return proxyFactory.getProxy(getProxyClassLoader());
		}

		// No proxy needed.
		return bean;
	}
}

public class ProxyFactory extends ProxyCreatorSupport { 
	public Object getProxy(@Nullable ClassLoader classLoader) { 
		return createAopProxy().getProxy(classLoader);  
	}
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
    @AliasFor(annotation = Component.class)
    String value() default "";
}

@Service
public class SpringTransactionService {
    @Autowired
    UserService userService;

    public void performTransaction() {
        // 模拟业务逻辑
        System.out.println("performTransaction");
    }
}

org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'springTransactionService': Bean with name 'springTransactionService' has been injected into other beans [userService] 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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.

@EnableAsync  
@Service  
public class SpringTransactionService {  
   
	@Autowired  
	UserService userService;  
  
	@Async  
	public void performTransaction() {  
		// 模拟业务逻辑  
		System.out.println("performTransaction");
	}
}

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory  
implements AutowireCapableBeanFactory {	

	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {  
		Object exposedObject = bean;  
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  
			for (BeanPostProcessor bp : getBeanPostProcessors()) {  
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {  
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;  
					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);  
				}  
			}  
		}  
		return exposedObject;  
	}
	
	@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
}

@EnableAsync  
@Repository
public class SpringTransactionService {  
	@Async  
	public void performTransaction() {  
		// 模拟业务逻辑  
		System.out.println("performTransaction");
	}
}

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory  
implements AutowireCapableBeanFactory {
	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
				exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
			}
		}
		return exposedObject;
	}

}

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport  
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
	@Override  
	public Object getEarlyBeanReference(Object bean, String beanName) {  
		Object cacheKey = getCacheKey(bean.getClass(), beanName);  
		this.earlyProxyReferences.put(cacheKey, bean);  
		return wrapIfNecessary(bean, beanName, cacheKey);  
	}
}

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport  
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
  // 生成了早期引用的bean缓存，
	private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);
	@Override  
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) { 
		// 如果 `bean` 为 `null`，则直接返回 `null`。
		if (bean != null) {  
			Object cacheKey = getCacheKey(bean.getClass(), beanName);  
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {  
				return wrapIfNecessary(bean, beanName, cacheKey);  
			}  
		}  
		return bean;  
	}
}

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport  
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
	@Override  
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {  
		if (bean != null) {  
			Object cacheKey = getCacheKey(bean.getClass(), beanName);  
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {  
				return wrapIfNecessary(bean, beanName, cacheKey);  
			}  
		}  
		return bean;  
	}
}