浅挖编码中遇到的循环依赖问题

redeemer
89 阅读4分钟

以下文章来源  果而 [阿里开发者]

一、问题简述

// 在离线打标服务类中注入审批服务，在“申请打标”时调用 public class PortraitOfflineLabelingServiceImpl implements PortraitOfflineLabelingService {

@Resource
private AuditService auditService;

/** 申请打标 */
Boolean applyOdpsOfflineLabeling(Request request);

/** 执行打标 */
Boolean executeOdpsOfflineLabeling(Request request);

}

// 审批服务类，定义了操作类型-审批回调服务的map映射 @Transactional(rollbackFor = Throwable.class) public class AuditServiceImpl implements AuditService,ApplicationContextAware,InitializingBean {

private Map<EntityOperation<?>, AuditCallback> auditCallbackMap = new HashMap<>();

@Override
public void afterPropertiesSet() throws Exception {
    Map<EntityOperation<?>, AuditCallback> auditCallbackMap = new HashMap<>();

    Collection<AuditCallback> beans = applicationContext.getBeansOfType(AuditCallback.class)
            .values();

    beans.forEach(auditCallback -> auditCallback.supportBizOperations()
            .forEach(item -> auditCallbackMap.put(item, auditCallback)));

    this.auditCallbackMap = auditCallbackMap;
}

}

// 在离线打标审批回调类中注入离线打标服务类，用于调用“执行打标”的服务 public class OdpsOfflineLabelingCallback implements AuditCallback {

@Resource
private PortraitOfflineLabelingService offlineLabelingService;

@Override
public List<EntityOperation<?>> supportBizOperations() {
    return Lists.newArrayList(OdpsOfflineLabelingOperation.CREATE_ODPS_OFFLINE_LABELING_INFO);
}

}

形成循环依赖：PortraitOfflineLabelingServiceImpl -> AuditServiceImpl -> AuditCallback -> PortraitOfflineLabelingServiceImpl 图片 二、为什么会出现循环依赖报错？

2.1. Spring Bean加载过程

图片 引用自阿里其他文章 Spring中以do开头的方法一般都是[干大事]的方法，doGetBean是用来获取bean的，doCreateBean是用来创建bean的，三个步骤包括：实例化bean->bean属性注入->初始化bean。 2.1.1. doGetBean 2.1.1.1. Spring三级缓存 图片 singletonObjects: 一级缓存，保存实例化&属性注入&初始化完成的bean实例。数据结构是bean名称->bean实例的映射。

earlySingletonObjects: 二级缓存，用于保存实例化完成，但为属性注入和初始化完成的bean实例。数据结构是bean名称->bean实例的映射。

singletonFactories: 三级缓存，用于保存bean创建工厂，以便于后面扩展有机会创建代理对象并放入二级缓存。数据结构是bean名称->bean创建工厂的映射。

2.1.1.2. 通过三级缓存获取bean实例 protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 尝试从一级缓存中获取已经初始化完成的bean实例（完全装载好的bean） Object singletonObject = this.singletonObjects.get(beanName); // 如果一级缓存中没有该实例 if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) { // 跑去二级缓存中获取创建中的实例 singletonObject = this.earlySingletonObjects.get(beanName); // 如果二级缓存中也没有该实例 if (singletonObject == null && allowEarlyReference) { // 加锁 synchronized(this.singletonObjects) { // 二次判断一级缓存和二级缓存中是否存在该实例（加锁时间差） singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null) { // 还是没有取到实例，尝试从三级缓存中获取创建该实例的工厂 ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName); if (singletonFactory != null) { // 通过工厂获取该实例的单例 singletonObject = singletonFactory.getObject(); // 将获取的bean从三级缓存中移除，并且升级到二级缓存中 this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } } }

// 返回获取的单例bean
return singletonObject;

} 2.1.2. doCreateBean Bean的加载最核心的代码就在doCreateBean方法中，包括三个阶段： createBeanInstance: 实例化Bean，获得未被填充属性的原始Bean。

populateBean: 如果Bean有需要注入的属性，则进行属性填充，前提是需要填充的属性已经存在于Spring容器中，否则会先加载该属性再进行填充。如果有循环依赖，问题就是在这个过程中发生的。

initializeBean: 执行bean的初始化过程，包括执行前置方法->执行初始化->执行后置方法。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException {

// 1.实例化bean
// 封装被创建的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;
}

// 调用PostProcessor后置处理器对bean进行一些操作
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;
    }
}

// 当允许提前暴露时，将实例化好的bean放进singletonFactories三级缓存，用来解决循环依赖导致的问题。
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");
    }
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

Object exposedObject = bean;
try {
    // 2.开始填充bean属性（依赖注入）
    populateBean(beanName, mbd, instanceWrapper);
    // 3.执行初始化方法（包括前后置的处理器）
    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) {
    Object earlySingletonReference = getSingleton(beanName, false);
    if (earlySingletonReference != null) {
        if (exposedObject == bean) {
            exposedObject = earlySingletonReference;
        }
        else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            String[] dependentBeans = getDependentBeans(beanName);
            Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
            for (String dependentBean : dependentBeans) {
                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 " +
                        "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
            }
        }
    }
}

try {
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
    throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}

return exposedObject;

} 2.2. 循环依赖情况下bean的加载过程

案例：Bean A和Bean B互相依赖对方。 图片

2.3. Spring三级缓存没有解决本次报错的原因

前提：Spring管理的Bean默认都是单例的，所以Spring默认需要保证所有使用此Bean的地方都指向的是同一个地址，也就是最终版本的Bean，否则可能就乱套了。Bean在初始化完成后，也提供了单例校验的逻辑。 结论：AOP代理导致单例校验失败抛错。 图片 initializeBean方法对传入的bean进行了初始化处理，当被AOP代理时会导致返回的bean和传入的bean不是同一个bean对象。AuditServiceImpl类上加了@Transactional注解，导致bean初始化的时候会被AOP代理，填充的属性为代理而非本体，从而导致单例校验抛错。 图片 尝试去除AuditServiceImpl类上的@Transactional注解后，能够部署成功： 图片 三、怎么解决本次报错

3.1. 从根源解决-去除循环依赖

// 拆分申请打标和执行打标到两个服务中，打破循环依赖 public class PortraitApplyOfflineLabelingServiceImpl implements PortraitApplyOfflineLabelingService {

@Resource
private AuditService auditService;

/** 申请打标 */
Boolean applyOdpsOfflineLabeling(Request request);

}

public class PortraitExecuteOfflineLabelingServiceImpl implements PortraitExecuteOfflineLabelingService {

/** 执行打标 */
Boolean executeOdpsOfflineLabeling(Request request);

} 3.2. @Lazy

public class OdpsOfflineLabelingCallback implements AuditCallback {

// 在属性注入的时候增加懒加载的注解
@Lazy
@Resource
private PortraitOfflineLabelingService offlineLabelingService;

@Override
public List<EntityOperation<?>> supportBizOperations() {
    return Lists.newArrayList(OdpsOfflineLabelingOperation.CREATE_ODPS_OFFLINE_LABELING_INFO);
}

} 创建AuditServiceImpl并填充属性PortraitOfflineLabelingServiceImpl的时候，发现是@Lazy懒注入，则生成一个代理对象直接赋值了，不会再执行去缓存中寻找PortraitOfflineLabelingServiceImpl、找不到再创建的步骤了，而是AuditServiceImpl直接正常走完后续生命周期流程，最终放入单例池。 而到单例PortraitOfflineLabelingServiceImpl创建的时候，填充属性AuditServiceImpl时直接能从单例池拿到完整的bean，因此PortraitOfflineLabelingServiceImpl也能正常走完后续生命周期流程。 最后，当AuditServiceImpl真正用到懒加载的属性，执行其方法的时候，才会去单例池中寻找真正的bean。

avatar
文章
阅读
粉丝