// 在离线打标服务类中注入审批服务，在“申请打标”时调用publicclassPortraitOfflineLabelingServiceImplimplementsPortraitOfflineLabelingService {
@ResourceprivateAuditServiceauditService;
/** 申请打标 */BooleanapplyOdpsOfflineLabeling(Requestrequest);
/** 执行打标 */BooleanexecuteOdpsOfflineLabeling(Requestrequest);
}
// 审批服务类，定义了操作类型-审批回调服务的map映射@Transactional(rollbackFor=Throwable.class)
publicclassAuditServiceImplimplementsAuditService,ApplicationContextAware,InitializingBean {
privateMap<EntityOperation<?>, AuditCallback>auditCallbackMap=newHashMap<>();
@OverridepublicvoidafterPropertiesSet() throwsException {
Map<EntityOperation<?>, AuditCallback>auditCallbackMap=newHashMap<>();
Collection<AuditCallback>beans=applicationContext.getBeansOfType(AuditCallback.class)
                .values();
beans.forEach(auditCallback->auditCallback.supportBizOperations()
                .forEach(item->auditCallbackMap.put(item, auditCallback)));
this.auditCallbackMap=auditCallbackMap;
    }
}
// 在离线打标审批回调类中注入离线打标服务类，用于调用“执行打标”的服务publicclassOdpsOfflineLabelingCallbackimplementsAuditCallback {
@ResourceprivatePortraitOfflineLabelingServiceofflineLabelingService;
@OverridepublicList<EntityOperation<?>>supportBizOperations() {
returnLists.newArrayList(OdpsOfflineLabelingOperation.CREATE_ODPS_OFFLINE_LABELING_INFO);
    }
}

protectedObjectgetSingleton(StringbeanName, booleanallowEarlyReference) {
// 尝试从一级缓存中获取已经初始化完成的bean实例（完全装载好的bean）ObjectsingletonObject=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);
                        }
                    }
                }
            }
        }
    }
// 返回获取的单例beanreturnsingletonObject;
}

protectedObjectdoCreateBean(finalStringbeanName, finalRootBeanDefinitionmbd, finalObject[] args)
throwsBeanCreationException {
// 1.实例化bean// 封装被创建的Bean对象BeanWrapperinstanceWrapper=null;
if (mbd.isSingleton()) {
instanceWrapper=this.factoryBeanInstanceCache.remove(beanName);
    }
if (instanceWrapper==null) {
instanceWrapper=createBeanInstance(beanName, mbd, args);
    }
// 获取实例化对象的类型Objectbean=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 (Throwableex) {
thrownewBeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
            }
mbd.postProcessed=true;
        }
    }
// 当允许提前暴露时，将实例化好的bean放进singletonFactories三级缓存，用来解决循环依赖导致的问题。booleanearlySingletonExposure= (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));
    }
ObjectexposedObject=bean;
try {
// 2.开始填充bean属性（依赖注入）populateBean(beanName, mbd, instanceWrapper);
// 3.执行初始化方法（包括前后置的处理器）exposedObject=initializeBean(beanName, exposedObject, mbd);
    }
catch (Throwableex) {
if (exinstanceofBeanCreationException&&beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
        }
else {
thrownewBeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }
// 当通过提早暴露解决循环依赖问题时，需要进行单例校验；这里也是本次报错的地方，后面会讲到为啥报错。if (earlySingletonExposure) {
ObjectearlySingletonReference=getSingleton(beanName, false);
if (earlySingletonReference!=null) {
if (exposedObject==bean) {
exposedObject=earlySingletonReference;
            }
elseif (!this.allowRawInjectionDespiteWrapping&&hasDependentBean(beanName)) {
String[] dependentBeans=getDependentBeans(beanName);
Set<String>actualDependentBeans=newLinkedHashSet<>(dependentBeans.length);
for (StringdependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
                    }
                }
if (!actualDependentBeans.isEmpty()) {
thrownewBeanCurrentlyInCreationException(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 (BeanDefinitionValidationExceptionex) {
thrownewBeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }
returnexposedObject;
}

// 拆分申请打标和执行打标到两个服务中，打破循环依赖publicclassPortraitApplyOfflineLabelingServiceImplimplementsPortraitApplyOfflineLabelingService {
@ResourceprivateAuditServiceauditService;
/** 申请打标 */BooleanapplyOdpsOfflineLabeling(Requestrequest);
}
publicclassPortraitExecuteOfflineLabelingServiceImplimplementsPortraitExecuteOfflineLabelingService {
/** 执行打标 */BooleanexecuteOdpsOfflineLabeling(Requestrequest);
}

publicclassOdpsOfflineLabelingCallbackimplementsAuditCallback {
// 在属性注入的时候增加懒加载的注解@Lazy@ResourceprivatePortraitOfflineLabelingServiceofflineLabelingService;
@OverridepublicList<EntityOperation<?>>supportBizOperations() {
returnLists.newArrayList(OdpsOfflineLabelingOperation.CREATE_ODPS_OFFLINE_LABELING_INFO);
    }
}