Bean with name 'xxx' has been injected into other beans
in its raw version as part of a circular reference,
but has eventually been wrapped.

A
↓
B
↓
Repository
↓
A

UserRepository

UserRepository$$SpringCGLIB$$0

Early Bean != Final Bean

@Transactional

AbstractAutoProxyCreator

getEarlyBeanReference()

postProcessAfterInitialization()

findEligibleAdvisors()

getEarlyBeanReference()

事务代理并不是最终代理来源

Object bean = applicationContext.getBean("userRepository");

Advised advised = (Advised) bean;

for (Advisor advisor : advised.getAdvisors()) {
    System.out.println(advisor);
}

PersistenceExceptionTranslationAdvisor

PersistenceExceptionTranslationPostProcessor

@Repository

@Repository
public class UserRepository {
}

SQLException
PersistenceException
HibernateException

DataAccessException
DuplicateKeyException

AbstractAutoProxyCreator

SmartInstantiationAwareBeanPostProcessor

getEarlyBeanReference()

Early Bean = Proxy
Final Bean = Proxy

PersistenceExceptionTranslationPostProcessor

BeanPostProcessor

getEarlyBeanReference()

postProcessAfterInitialization()

Bean 创建
↓
加入三级缓存
↓
发生循环依赖
↓
获取 Early Bean
↓
拿到原始对象
↓
初始化完成
↓
PersistenceExceptionTranslationPostProcessor
创建代理
↓
Final Bean 变成代理对象

Early Bean != Final Bean

getEarlyBeanReference()

影响 Bean 核心行为

@Transactional
@Aspect
@Cacheable

Early = Final

@Repository

SQLException

AbstractAutoProxyCreator

public Object getEarlyBeanReference(
        Object bean,
        String beanName) {

    Object cacheKey = getCacheKey(bean.getClass(), beanName);

    this.earlyProxyReferences.put(cacheKey, bean);

    return wrapIfNecessary(bean, beanName, cacheKey);
}

public Object postProcessAfterInitialization(
        Object bean,
        String beanName) {

    Object cacheKey = getCacheKey(bean.getClass(), beanName);

    if (this.earlyProxyReferences.remove(cacheKey) != bean) {
        return wrapIfNecessary(bean, beanName, cacheKey);
    }

    return bean;
}

Early Proxy

Early Bean == Final Bean

PersistenceExceptionTranslationPostProcessor

@Repository

三级缓存暴露的是原始对象

PersistenceExceptionTranslationPostProcessor
再次包装代理

Raw Bean 被注入
Final Bean 变成 Proxy

Service
↓
Repository

Service
↓
Repository
↓
Service

@Repository
public class XxxManager {
}

@Component

@Service

@Autowired
@Lazy
private UserRepository repository;

PersistenceExceptionTranslationPostProcessor

Spring 三级缓存解决了循环依赖
=
所有代理都能正常工作

Spring 三级缓存
只能保证支持 Early Proxy 的代理机制正常工作

PersistenceExceptionTranslationPostProcessor
MethodValidationPostProcessor
部分 Async/Scheduled 后处理器
自定义 BeanPostProcessor

postProcessAfterInitialization()

Early Bean ≠ Final Bean

Spring 三级缓存
≠
解决所有循环依赖问题

Spring 三级缓存
只能解决支持 Early Proxy 的循环依赖问题

postProcessAfterInitialization()

Early Bean ≠ Final Bean