在二手车业务线，现阶段无法实现车辆、人、车商信息的在业务审核流程中的数据查重应用，因此业务方为了达成这一目标，基于数据采集和数据查询，应运而生了关系图谱服务。

本文由于字数太多分为上下篇完成。

一、系统架构

系统架构图

从上述系统架构图我们可以看出：

1、关系图谱服务主要提供两种能力，数据采集和数据查重。
2、数据采集基于接入消息，消费业务线内部的消息通知，基于元数据进行分析并落库。
3、数据查重基于HTTP服务，对业务线提供场景的数据查重服务。
4、关系图谱服务内部引擎主要包括，数据采集、数据加工、数据切分、数据存储。
5、关系图谱服务一期目标基于当前业务量，基于MySQL数据库存储。

二、业务概述

业务流程图

从上述业务流程图我们可以看出：

1、数据采集，基于接入MQ消息，然后业务逻辑层分析数据，进行数据加工与切分，并存储到数据库，数据切分成业务表，主要包括（b_person_info和b_vehicle_info）。
2、数据查重，基于HTTP接口，外部根据关系图谱协议规范，定义查重参数，并返回命中数据。

三、方案设计

需求分析

上图是根据业务梳理出不同场景阶段可以得到的数据，从上图我们可以得到如下结论

1、第一列为人信息的分类，包括：主贷人、配偶、担保人等。
2、第二列为数据维度，其中单元格不同颜色表示在不同场景阶段可以拿到数据。
3、基于MQ消息通知，我们从消息中可以获取到订单号，然后再查询三方数据获取相关数据项。

3.1、数据采集

数据采集主要完成对接MQ消息通知，以及历史数据的同步（上线时必须），然后对数据加工切分并落库。

数据采集

上图是整个代码设计的UML类图，从上述图可以看出：

1、第一层的"应用场景模块"是两个类，一个是消息消费、一个是数据同步。
2、第二层的"事件监听模块"，是按照业务场景划分，对于不同业务场景，然后监听器通知对应的处理类处理即可。
3、第三层的"数据处理模块"，按照数据类型（即主贷人、配偶等）抽象出抽象类，以及派生的子类。

3.1.1、SourceInfoContext

该类主要封装数据处理器上下文数据信息。

/**
 * @description: 来源信息上下文对象
 * @Date : 2020/12/2 5:33 PM
 * @Author : 石冬冬-Seig Heil
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class SourceInfoContext {
    /**
     * 订单号
     */
    private String appCode;
    /**
     * 车商id
     */
    private Long dealerId;
    /**
     * 业务场景
     */
    private SceneEnum scene;
    /**
     * 车商提交信息
     */
    private List<CarDealerInfoDTO> carDealers;
}

/**
 * @description:  1001-秒批提交;1002-准入提交;1003-贷前提交;1004-车辆评估备注;2001-车商账号提交;
 * @Date : 2020/11/27 4:08 PM
 * @Author : 石冬冬-Seig Heil
 */
public enum SceneEnum implements EnumValue {

	SECOND_BATCH_SUBMIT(1001,"秒批提交"),
	ADMITTANCE_SUBMIT(1002,"准入提交"),
	BEFORE_LOAN_SUBMIT(1003,"贷前提交"),
	VEHICLE_EVALUATE_REMARK(1004,"车辆评估备注"),
	MERCHANT_ACCOUNT_SUBMIT(2001,"车商账号提交"),
	;


	private int index;
	private String value;

	SceneEnum(int index, String value ){
		this.value = value;
		this.index = index;
	}

	@Override
	public int getIndex() {
		return index;
	}

	@Override
	public String getName() {
		return value;
	}

	/**
	 * 根据索引获取对象
	 * @param index
	 * @return
	 */
	public static SceneEnum getByIndex(int index){
		return Stream.of(SceneEnum.values()).filter(each -> each.getIndex() == index).findFirst().get();
	}
	/**
	 * 根据索引获取名称
	 * @param index
	 * @return
	 */
	public static String getNameByIndex(int index){
		SceneEnum find = Stream.of(SceneEnum.values()).filter(each -> each.getIndex() == index).findFirst().get();
		return null == find ? "" : find.getName();
	}
}

3.1.2、AbstractInfoHandler

该类主要抽象封装数据处理，是车辆、人、车商信息处理模块的上层抽象类。

AbstractInfoHandler


/**
 * @description: 来源信息数据处理接口
 * @Date : 2020/12/2 6:34 PM
 * @Author : 石冬冬-Seig Heil
 */
public interface SourceInfoHandle {
    /**
     * 数据组装和数据处理
     * @param context
     */
    void handle(SourceInfoContext context);
}


/**
 * @description: 抽象信息处理器
 * @Date : 2020/12/2 5:29 PM
 * @Author : 石冬冬-Seig Heil
 */
@Slf4j
public abstract class AbstractInfoHandler<T> implements SourceInfoHandle{

    protected final static int NORMAL_DATA_STATUS_INDEX = DataStatusEnum.NORMAL.getIndex();
    protected final static int DELETED_DATA_STATUS_INDEX = DataStatusEnum.DELETED.getIndex();

    protected final static String EMPTY_VALUE = "-";
    /**
     * 上下文容器
     */
    protected static final ThreadLocal<SourceInfoContext> CONTEXT = new ThreadLocal<>();
    /**
     * 来源类型
     */
    protected final SourceTypeEnum sourceType;
    /**
     * 是否需要标记删除重复记录
     */
    protected boolean removeDuplicate;

    @Autowired
    protected DiamondConfigProxy diamondConfigProxy;

    @Autowired
    protected SerialNoGenerator serialNoGenerator;

    @Autowired
    protected SourceInfoQuerier sourceInfoQuerier;

    public AbstractInfoHandler(SourceTypeEnum sourceType,boolean removeDuplicate) {
        this.sourceType = sourceType;
        this.removeDuplicate = removeDuplicate;
    }

    /**
     * 执行
     * @param ctx
     */
    public void execute(SourceInfoContext ctx){
        try {
            CONTEXT.set(ctx);
            log.info("[execute]appCode={},Handler={},sourceType={}",ctx.getAppCode(),this.getClass().getSimpleName(),sourceType);
            handle(ctx);
        } catch (Exception e) {
            log.error("[execute]appCode={},Handler={},sourceType={},ex",ctx.getAppCode(),this.getClass().getSimpleName(),sourceType,e);
        }finally {
            CONTEXT.remove();
        }
    }

    /**
     * 已存在的记录集合
     * @param sourceRecord
     * @param context
     * @return
     */
    protected abstract List<T> queryExistsList(T sourceRecord, SourceInfoContext context);

    /**
     * 把图谱记录写入库
     * @param sourceRecord 三方查询数据
     * @param context 上下文对象
     */
    protected abstract void store(T sourceRecord,SourceInfoContext context);

    /**
     * 从配置获取对象属性字段
     * @return
     */
    protected List<String> getPropertiesFromConfig(){
        return getPropertiesFromConfigWithScene(CONTEXT.get().getScene());
    }

    /**
     * 从配置获取对象属性字段
     * @return
     */
    protected List<String> getPropertiesFromConfigWithScene(SceneEnum scene){
        Map<SourceTypeEnum,Map<SceneEnum,List<String>>> mapping = JSON.parseObject(diamondConfigProxy.configGatherRules(),
                new TypeReference<Map<SourceTypeEnum,Map<SceneEnum,List<String>>>>(){});
        List<String> properties = mapping.get(sourceType).get(scene);
        return properties;
    }

    /**
     * 检查两个对象相关字段是否全部相同
     * @param source 三方数据源对象
     * @param target 关系图谱数据库对象
     * @return
     */
    protected boolean isSameWithAnyFields(T source,T target){
        List<String> properties = getPropertiesFromConfig();
        if(CollectionsTools.isEmpty(properties)){
            return true;
        }
        Class sourceClazz = source.getClass();
        Class targetClazz = target.getClass();
        Field sourceFiled,targetFiled;
        Object sourceFieldValue,targetFieldValue;
        try {
            for (String property : properties) {
                sourceFiled = sourceClazz.getDeclaredField(property);
                targetFiled = targetClazz.getDeclaredField(property);
                sourceFiled.setAccessible(true);
                targetFiled.setAccessible(true);
                sourceFieldValue = sourceFiled.get(source);
                targetFieldValue = targetFiled.get(target);
                if(!Objects.equals(sourceFieldValue,targetFieldValue)) {
                    return false;
                }
            }
        } catch (NoSuchFieldException e) {
            log.error(e.getMessage(), e);
        } catch (IllegalAccessException e) {
            log.error(e.getMessage(), e);
        }
        return true;
    }

    /**
     * 从目标对象拷贝到
     * @param source 三方数据源对象
     * @param target 关系图谱数据库对象
     */
    protected void copy(T source,T target){
        List<String> properties = getPropertiesFromConfig();
        copy(source, target, properties);
    }

    protected void copy(Object source, Object target, List<String> properties){
        if(CollectionsTools.isEmpty(properties)){
            return;
        }
        Class sourceClazz = source.getClass();
        Class targetClazz = target.getClass();
        Field sourceFiled,targetFiled;
        try {
            for (String property : properties) {
                sourceFiled = sourceClazz.getDeclaredField(property);
                targetFiled = targetClazz.getDeclaredField(property);
                sourceFiled.setAccessible(true);
                targetFiled.setAccessible(true);
                targetFiled.set(target,sourceFiled.get(source));
            }
        } catch (NoSuchFieldException e) {
            log.error(e.getMessage(), e);
        } catch (IllegalAccessException e) {
            log.error(e.getMessage(), e);
        }
    }

    /**
     * 返回处理器类名称
     * @return
     */
    protected String getHandlerClassName(){
        return this.getClass().getSimpleName();
    }
    /**
     * 从上下文容器拿到业务场景
     * @return
     */
    protected SceneEnum getSceneFromContext(){
        return null == CONTEXT.get() ? null : CONTEXT.get().getScene();
    }
}

3.1.3、AbstractVehicleInfoHandler

该类主要抽象封装车辆信息的数据处理，只有一个派生类VehicleInfoHandler。

AbstractVehicleInfoHandler

/**
 * @description: 抽象自然人信息处理器
 * @Date : 2020/12/3 11:32 AM
 * @Author : 石冬冬-Seig Heil
 */
@Slf4j
public abstract class AbstractVehicleInfoHandler extends AbstractInfoHandler<VehicleInfo> {


    @Resource
    protected VehicleInfoService vehicleInfoService;

    public AbstractVehicleInfoHandler(SourceTypeEnum sourceType) {
        super(sourceType,Boolean.FALSE);
    }


    @Override
    protected void store(VehicleInfo record,SourceInfoContext context) {
        if(Objects.nonNull(record)){
            List<VehicleInfo> recordList = queryExistsList(record,context);
            if(CollectionsTools.isNotEmpty(recordList)){
                for (VehicleInfo sourceRecord : recordList) {
                    if(isSameWithAnyFields(sourceRecord.with(),record.with())){
                        return;
                    }
                }
            }

            record.setDataStatus(NORMAL_DATA_STATUS_INDEX);
            record.setDataCode(serialNoGenerator.generalVehicleInfoDataCode());
            record.setScene(context.getScene().getIndex());
            record.setSourceType(sourceType.getIndex());
            log.info("[store][insertRecord]appCode={},Handler={},sourceType={}",record.getAppCode(),getHandlerClassName(),sourceType);
            vehicleInfoService.insertRecord(record.with());
        }
    }

    @Override
    protected List<VehicleInfo> queryExistsList(VehicleInfo sourceRecord,SourceInfoContext context) {
        VehicleInfoForm queryForm = VehicleInfoForm.builder()
                .appCode(context.getAppCode())
                .sourceType(sourceType.getIndex())
                //.scene(context.getScene().getIndex())
                .dataStatus(NORMAL_DATA_STATUS_INDEX)
                .build();
        return vehicleInfoService.queryList(queryForm);
    }
}
/**
 * @description: 车辆信息处理器
 * @Date : 2020/12/2 6:22 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
@Slf4j
public class VehicleInfoHandler extends AbstractVehicleInfoHandler{

    public VehicleInfoHandler() {
        super(SourceTypeEnum.VEHICLE_INFO);
    }

    @Override
    public void handle(SourceInfoContext context) {
        VehicleInfo sourceRecord = sourceInfoQuerier.queryVehicleInfo(context.getAppCode());
        SceneEnum scene = context.getScene();
        if(SceneEnum.ADMITTANCE_SUBMIT == scene){
            super.store(sourceRecord,context);
        }
        if(SceneEnum.BEFORE_LOAN_SUBMIT == scene || SceneEnum.VEHICLE_EVALUATE_REMARK == scene){
            List<VehicleInfo> recordList = queryExistsList(sourceRecord,context);
            Map<String,CarEvaluationBo> vinMapping = sourceInfoQuerier.queryVinMapping(context.getAppCode());
            log.info("[EvaluateRemark],appCode={},vinMapping={}",context.getAppCode(), JSONObject.toJSONString(vinMapping));
            recordList.forEach(each -> {
                CarEvaluationBo apply = vinMapping.get(each.getVin());
                if(Objects.nonNull(apply)){
                    log.info("[EvaluateRemark][Update],appCode={},vin={},remark={}",context.getAppCode(),each.getVin(),apply.getEvaluationRemarks());
                    each.setEvaluateRemark(StringTools.isNotEmpty(apply.getEvaluationRemarks()) ? apply.getEvaluationRemarks() : EMPTY_VALUE);
                    each.setModifiedTime(TimeTools.createNowTime());
                    vehicleInfoService.updateByPrimaryKeySelective(each);
                }
            });
        }
    }
}

3.1.4、AbstractCarDealerInfoHandler

该类主要抽象封装车商信息的数据处理，有三个派生类CarDealerLegalPersonInfoHandler、CarDealerPayeeInfoHandler、CarDealerPrincipalInfoHandler。

AbstractCarDealerInfoHandler

/**
 * @description: 抽象车商信息处理器
 * @Date : 2020/12/7 11:19 AM
 * @Author : 石冬冬-Seig Heil
 */
@Slf4j
public abstract class AbstractCarDealerInfoHandler extends AbstractInfoHandler<DealerInfo> {

    @Resource
    DealerInfoService dealerInfoService;

    public AbstractCarDealerInfoHandler(SourceTypeEnum sourceType) {
        super(sourceType, Boolean.TRUE);
    }
    /**
     * 查询车商信息
     * @param dealerId
     * @return
     */
    protected abstract List<DealerInfo> queryList(Long dealerId);

    /**
     * 是否应该处理
     * @param record
     * @return
     */
    boolean shouldStore(DealerInfo record){
        return Objects.nonNull(record) && StringTools.isNotEmpty(record.getName()) && !Objects.equals(record.getName(),EMPTY_VALUE);
    }


    @Override
    protected void store(DealerInfo record,SourceInfoContext context) {
        if(shouldStore(record)){
            //是否删除历史雷同记录
            if(removeDuplicate){
                List<DealerInfo> recordList = queryExistsList(record,context);
                if(CollectionsTools.isNotEmpty(recordList)){
                    for (DealerInfo sourceRecord : recordList) {
                        if(isSameWithAnyFields(sourceRecord.with(),record.with())){
                            return;
                        }
                    }
                }
            }
            //存入新纪录
            record.setDataCode(serialNoGenerator.generalDealerInfoDataCode());
            record.setDataStatus(NORMAL_DATA_STATUS_INDEX);
            record.setScene(context.getScene().getIndex());
            record.setSourceType(sourceType.getIndex());
            dealerInfoService.insertRecord(record.with());
        }else{
            log.debug("[execute]store NullObject,Handler={},sourceType={},context={}",
                    this.getClass().getSimpleName(),sourceType, JSONObject.toJSONString(context));
        }
    }

    @Override
    public void handle(SourceInfoContext context) {
        List<DealerInfo> listWithoutSameFields = new ArrayList<>();
        List<DealerInfo> list;
        //倘若是车商账户提交推送的消息，则直接获取无需查询；否则，根据车商ID查询信息。
        if(CollectionsTools.isEmpty(context.getCarDealers())){
            list = queryList(context.getDealerId());
        } else {
            list = context.getCarDealers().stream().filter(each -> each.getSourceType().intValue() == sourceType.getIndex())
                .map(
                    source -> DealerInfo.builder()
                    .externalId(Objects.toString(source.getExternalId()))
                    .appCode(Objects.toString(source.getMerchantId()))
                    .sourceType(source.getSourceType())
                    .name(source.getName())
                    .idNo(source.getIdNo())
                    .primaryMobile(source.getCellphone())
                    .companyAddressDetail(source.getDealerAddress())
                    .companyName(source.getDealerName())
                    .creditCardNo(source.getCreditCardNo())
                    .build()
                ).collect(Collectors.toList());
        }
        //本次添加的车商，去除某些字段值雷同的项
        for (DealerInfo person : list) {
            if(listWithoutSameFields.stream().filter(r -> isSameWithAnyFields(r, person)).count() > 0){
                continue;
            }
            listWithoutSameFields.add(person);
        }
        log.info("[storeWithBatch]dealerId={},Handler={},sourceType={},list={}",context.getDealerId(),getHandlerClassName(),sourceType, JSONObject.toJSONString(list));
        this.storeWithBatch(listWithoutSameFields,context);
    }

    @Override
    protected List<DealerInfo> queryExistsList(DealerInfo sourceRecord, SourceInfoContext context) {
        DealerInfoForm queryForm = DealerInfoForm.builder()
                .sourceType(sourceType.getIndex())
                .scene(context.getScene().getIndex())
                .appCode(sourceRecord.getAppCode())
                .dataStatus(NORMAL_DATA_STATUS_INDEX)
                .build();
        List<DealerInfo> recordList = dealerInfoService.queryList(queryForm);
        return recordList;
    }

    /**
     * 批量插入
     * @param recordList
     */
    protected void storeWithBatch(List<DealerInfo> recordList,SourceInfoContext context){
        if(CollectionsTools.isEmpty(recordList)){
            return;
        }
        for (DealerInfo record : recordList) {
            store(record, context);
        }
    }
}

/**
 * @description: 车商法人 （姓名、身份证号、手机号）
 * @Date : 2020/12/2 5:26 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class CarDealerLegalPersonInfoHandler extends AbstractCarDealerInfoHandler {

    public CarDealerLegalPersonInfoHandler() {
        super(SourceTypeEnum.CAR_DEALER_LEGAL_PERSON);
    }

    @Override
    protected List<DealerInfo> queryList(Long dealerId) {
        return sourceInfoQuerier.queryCarDealerLegalInfo(dealerId);
    }
}


/**
 * @description: 车商收款人 （姓名、身份证号、手机号、银行卡号）
 * @Date : 2020/12/2 5:26 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class CarDealerPayeeInfoHandler extends AbstractCarDealerInfoHandler {

    public CarDealerPayeeInfoHandler() {
        super(SourceTypeEnum.CAR_DEALER_PAYEE);
    }

    @Override
    protected List<DealerInfo> queryList(Long dealerId) {
        return sourceInfoQuerier.queryCarDealerPayeeInfo(dealerId);
    }
}

/**
 * @description: 车商负责人信息 （姓名、身份证号、手机号、单位名称、单位地址）
 * @Date : 2020/12/2 5:26 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class CarDealerPrincipalInfoHandler extends AbstractCarDealerInfoHandler {

    public CarDealerPrincipalInfoHandler() {
        super(SourceTypeEnum.CAR_DEALER_PRINCIPAL);
    }

    @Override
    protected List<DealerInfo> queryList(Long dealerId) {
        return sourceInfoQuerier.queryCarDealerPrincipalInfo(dealerId);
    }
}

3.1.5、AbstractPersonInfoHandler

该类主要抽象封装人信息的数据处理，有三个派生类CreditorInfoHandler、MateInfoHandler等。

AbstractPersonInfoHandler

/**
 * @description: 抽象自然人信息处理器
 * @Date : 2020/12/3 11:32 AM
 * @Author : 石冬冬-Seig Heil
 */
@Slf4j
public abstract class AbstractPersonInfoHandler extends AbstractInfoHandler<PersonInfo>{


    @Autowired
    protected PersonInfoService personInfoService;

    public AbstractPersonInfoHandler(SourceTypeEnum sourceType, boolean removeDuplicate) {
        super(sourceType, removeDuplicate);
    }

    /**
     * 是否应该处理
     * @param record
     * @return
     */
    protected boolean shouldStore(PersonInfo record){
        return Objects.nonNull(record) && StringTools.isNotEmpty(record.getName()) && !Objects.equals(record.getName(),EMPTY_VALUE);
    }


    @Override
    protected void store(PersonInfo record,SourceInfoContext context) {
        if(shouldStore(record)){
            //是否删除历史雷同记录
            if(removeDuplicate){
                List<PersonInfo> recordList = queryExistsList(record,context);
                if(CollectionsTools.isNotEmpty(recordList)){
                    for (PersonInfo sourceRecord : recordList) {
                        if(isSameWithAnyFields(sourceRecord.with(),record.with())){
                            return;
                        }
                    }
                }
            }
            //存入新纪录
            record.setDataCode(serialNoGenerator.generalPersonInfoDataCode());
            record.setDataStatus(NORMAL_DATA_STATUS_INDEX);
            record.setScene(context.getScene().getIndex());
            record.setSourceType(sourceType.getIndex());
            personInfoService.insertRecord(record.with());
        }else{
            log.debug("[execute]store NullObject,Handler={},sourceType={},context={}",
                    this.getClass().getSimpleName(),sourceType, JSONObject.toJSONString(context));
        }
    }

    @Override
    protected List<PersonInfo> queryExistsList(PersonInfo sourceRecord, SourceInfoContext context) {
        PersonInfoForm queryForm = PersonInfoForm.builder()
                .sourceType(sourceType.getIndex())
                .scene(context.getScene().getIndex())
                .appCode(context.getAppCode())
                .dataStatus(NORMAL_DATA_STATUS_INDEX)
                .build();
        List<PersonInfo> recordList = personInfoService.queryList(queryForm);
        return recordList;
    }

    /**
     * 批量插入
     * @param recordList
     */
    protected void storeWithBatch(List<PersonInfo> recordList,SourceInfoContext context){
        if(CollectionsTools.isEmpty(recordList)){
            return;
        }
        recordList.forEach(each -> {
            log.info("[storeWithBatch]appCode={},Handler={},sourceType={}",each.getAppCode(),getHandlerClassName(),sourceType);
            each.setDataCode(serialNoGenerator.generalPersonInfoDataCode());
            each.setDataStatus(NORMAL_DATA_STATUS_INDEX);
            each.setSourceType(sourceType.getIndex());
            each.setScene(context.getScene().getIndex());
            each.with();
        });
        personInfoService.batchInsert(recordList);
    }
}


/**
 * @description: 主贷人信息 （姓名、身份证号、手机号、单位名称、单位地址、座机号、户籍地址、居住地址、居住电话、银行卡号）
 * @Date : 2020/12/2 5:26 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class CreditorInfoHandler extends AbstractPersonInfoHandler {

    public CreditorInfoHandler() {
        super(SourceTypeEnum.CREDITOR_INFO, Boolean.FALSE);
    }

    @Override
    public void handle(SourceInfoContext context) {
        //查询新的修改记录
        PersonInfo record = sourceInfoQuerier.queryCreditorInfo(context.getAppCode());
        if(!shouldStore(record)){
            return;
        }
        record.with();

        //删除【当前场景】【之前场景】的【子集数据】
        List<String> propertiesSecond = super.getPropertiesFromConfigWithScene(SceneEnum.SECOND_BATCH_SUBMIT);
        PersonInfoForm propertiesSecondForm = PersonInfoForm.builder().appCode(context.getAppCode())
                .sourceType(sourceType.getIndex())
                .scene(SceneEnum.SECOND_BATCH_SUBMIT.getIndex())
                .dataStatus(NORMAL_DATA_STATUS_INDEX)
                .build();
        List<String> propertiesAdmittance = super.getPropertiesFromConfigWithScene(SceneEnum.ADMITTANCE_SUBMIT);
        PersonInfoForm propertiesAdmittanceForm = PersonInfoForm.builder().appCode(context.getAppCode())
                .sourceType(sourceType.getIndex())
                .scene(SceneEnum.ADMITTANCE_SUBMIT.getIndex())
                .dataStatus(NORMAL_DATA_STATUS_INDEX)
                .build();
        List<String> propertiesBeforeLoan = super.getPropertiesFromConfigWithScene(SceneEnum.BEFORE_LOAN_SUBMIT);
        PersonInfoForm propertiesBeforeLoanForm = PersonInfoForm.builder().appCode(context.getAppCode())
                .sourceType(sourceType.getIndex())
                .scene(SceneEnum.BEFORE_LOAN_SUBMIT.getIndex())
                .dataStatus(NORMAL_DATA_STATUS_INDEX)
                .build();

        switch (context.getScene()){
            case SECOND_BATCH_SUBMIT:
                //软删除【秒批提交】子集
                copy(record, propertiesSecondForm, propertiesSecond);
                personInfoService.updateByQuery(propertiesSecondForm);
                break;
            case ADMITTANCE_SUBMIT:
                //软删除【秒批提交】子集
                copy(record, propertiesSecondForm, propertiesSecond);
                personInfoService.updateByQuery(propertiesSecondForm);
                //软删除【准入提交】子集
                propertiesAdmittance.addAll(propertiesSecond);
                copy(record, propertiesAdmittanceForm, propertiesAdmittance);
                personInfoService.updateByQuery(propertiesAdmittanceForm);
                break;
            case BEFORE_LOAN_SUBMIT:
                //软删除【秒批提交】子集
                copy(record, propertiesSecondForm, propertiesSecond);
                personInfoService.updateByQuery(propertiesSecondForm);
                //软删除【准入提交】子集
                propertiesAdmittance.addAll(propertiesSecond);
                copy(record, propertiesAdmittanceForm, propertiesAdmittance);
                personInfoService.updateByQuery(propertiesAdmittanceForm);
                //软删除【贷前提交】子集
                propertiesBeforeLoan.addAll(propertiesAdmittance);
                copy(record, propertiesBeforeLoanForm, propertiesBeforeLoan);
                personInfoService.updateByQuery(propertiesBeforeLoanForm);
                break;
            default:
                break;
        }

        //补录新的修改记录
        super.store(record,context);
    }
}


/**
 * @description: 配偶信息 （姓名、身份证号、手机号、单位名称）
 * @Date : 2020/12/2 5:26 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class MateInfoHandler extends AbstractPersonInfoHandler {

    public MateInfoHandler() {
        super(SourceTypeEnum.MATE, Boolean.TRUE);
    }

    @Override
    public void handle(SourceInfoContext context) {
        PersonInfo record = sourceInfoQuerier.queryMateInfo(context.getAppCode());
        super.store(record,context);
    }
}


/**
 * @description: 担保人信息 （姓名、身份证号、手机号、单位名称、单位地址、座机号、户籍地址）
 * @Date : 2020/12/2 5:26 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class GuarantorInfoHandler extends AbstractPersonInfoHandler {

    public GuarantorInfoHandler() {
        super(SourceTypeEnum.GUARANTOR_INFO, Boolean.TRUE);
    }

    @Override
    public void handle(SourceInfoContext context) {
        PersonInfo record = sourceInfoQuerier.queryGuarantorInfo(context.getAppCode());
        super.store(record,context);
    }
}

3.1.6、SourceInfoQuerier

该类主要抽象对service查询数据的获取，并封装处理器内部所需的POJO。

SourceInfoQuerier

/**
 * @description: 来源信息查询器
 * @Date : 2020/12/3 10:55 AM
 * @Author : 石冬冬-Seig Heil
 */
@Component
@Slf4j
public class SourceInfoQuerier {
    
    //省略依赖注入Service
    
    /**
         * 查询主贷人信息
         * @param appCode
         * @return
         */
        public PersonInfo queryCreditorInfo(String appCode){
            CustomerPersonInfo record = customerPersonInfoService.queryByAppCode(appCode);
            if(Objects.isNull(record)){
                return null;
            }
            List<CustomerCardInfo> customerCardInfos = customerCardInfoService.queryList(CustomerCardInfoForm.builder().appCode(appCode).build());
            CustomerCardInfo customerCardInfo = CollectionsTools.isNotEmpty(customerCardInfos) ? customerCardInfos.get(0) : customerCardInfo_NULL;
            return PersonInfo.builder()
                    .externalId(Objects.toString(record.getId()))
                    .appCode(appCode)
                    .name(record.getName())
                    .idNo(record.getIdNumber())
                    .primaryMobile(record.getMobile())
                    .secondMobile(record.getMobile2())
                    .companyName(record.getNowCompany())
                    .companyAddressOrigin(record.getNowUnitAddress())
                    .companyAddressProvince(record.getNowUnitProvinceName())
                    .companyAddressCity(record.getNowUnitCityName())
                    .companyAddressDistrict(record.getNowUnitDistrictName())
                    .companyAddressDetail(record.getNowUnitAddress())
                    .companyTelephone(record.getNowUnitTel())
                    .censusAddressOrigin(record.getHometownAddress())
                    .censusAddressProvince(record.getHometownProvinceName())
                    .censusAddressCity(record.getHometownCityName())
                    .censusAddressDistrict(record.getHometownDistrictName())
                    .censusAddressDetail(record.getHometownAddress())
                    .residenceAddressOrigin(record.getResidenceAddress())
                    .residenceAddressProvince(record.getResidenceProvinceName())
                    .residenceAddressCity(record.getResidenceCityName())
                    .residenceAddressDistrict(record.getResidenceDistrictName())
                    .residenceAddressDetail(record.getResidenceAddress())
                    .residenceTelephone(record.getResidenceTel())
                    .creditCardNo(Objects.nonNull(customerCardInfo) ? customerCardInfo.getRepAccountNo() : EMPTY_VALUE)
                    .build();
        }
    
        /**
         * 查询担保人信息
         * @param appCode
         * @return
         */
        public PersonInfo queryGuarantorInfo(String appCode){
            CustomerRelatedInfo record = customerRelatedInfoService.queryByAppCode(appCode);
            if(Objects.isNull(record)){
                return null;
            }
            return PersonInfo.builder()
                    .externalId(Objects.toString(record.getId()))
                    .appCode(appCode)
                    .name(record.getDbName())
                    .idNo(record.getDbIdNo())
                    .primaryMobile(record.getDbMobile())
                    .companyName(record.getDbNowCompany())
                    .companyAddressOrigin(record.getDbNowUnitAddress())
                    .companyAddressProvince(record.getDbNowUnitProvinceName())
                    .companyAddressCity(record.getDbNowUnitCityName())
                    .companyAddressDistrict(record.getDbNowUnitDistrictName())
                    .companyAddressDetail(record.getDbNowUnitAddress())
                    //.companyTelphone()
                    .censusAddressOrigin(record.getDbAddress())
                    .censusAddressProvince(record.getDbProvinceName())
                    .censusAddressCity(record.getDbCityName())
                    .censusAddressDistrict(record.getDbDistrictName())
                    .censusAddressDetail(record.getDbAddress())
                    .build();
        }
        
        //省略其他成员方法
}

3.1.7、SubmitEventContext

/**
 * @description: 提交事件上下文对象
 * @Date : 2020/12/2 6:29 PM
 * @Author : 石冬冬-Seig Heil
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class SubmitEventContext {
    /**
     * 订单号
     */
    @NotNull
    private String appCode;
    /**
     * 车商ID
     */
    @NotNull
    private Long merchantId;
    /**
     * 业务场景
     */
    @NotNull
    private SceneEnum scene;
    /**
     * 车商提交信息
     */
    private List<CarDealerInfoDTO> carDealers;
}

3.1.8、AbstractSubmitListener

监听器抽象类，维护监听器通知的数据处理器成员。

AbstractSubmitListener

/**
 * @description: 提交事件监听接口
 * @Date : 2020/12/2 6:29 PM
 * @Author : 石冬冬-Seig Heil
 */
public interface SubmitEventListen {
    /**
     * 订阅事件
     * @param context
     */
    void subscribe(SubmitEventContext context);
}

/**
 * @description: 抽象提交 事件监听器
 * @Date : 2020/12/2 5:19 PM
 * @Author : 石冬冬-Seig Heil
 */
@Slf4j
public abstract class AbstractSubmitListener implements SubmitEventListen {
    /**
     * 关注场景
     */
    protected SceneEnum sceneEnum;
    /**
     * 处理器集合
     */
    protected List<AbstractInfoHandler> handlers = Lists.newArrayListWithExpectedSize(20);

    public AbstractSubmitListener(SceneEnum sceneEnum) {
        this.sceneEnum = sceneEnum;
    }

    @Override
    public void subscribe(SubmitEventContext context) {
        String appCode = context.getAppCode();
        if(context.getScene() == sceneEnum){
            log.info("[SubmitEventListen],appCode={},handlers={}",appCode,handlers.toArray());
            handlers.forEach(each -> {
                SourceInfoContext sourceInfoContext = SourceInfoContext.builder()
                        .appCode(appCode)
                        .dealerId(context.getMerchantId())
                        .carDealers(context.getCarDealers())
                        .scene(context.getScene())
                        .build();
                each.execute(sourceInfoContext);
            });
        }
    }
}


/**
 * @description: 准入提交 事件监听器
 * @Date : 2020/12/2 5:17 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class AdmittanceSubmitListener extends AbstractSubmitListener {

    @Resource
    CreditorInfoHandler creditorInfoHandler;

    @Resource
    MateInfoHandler mateInfoHandler;

    @Resource
    GuarantorInfoHandler guarantorInfoHandler;

    @Resource
    SellerInfoOfOldCarHandler sellerInfoOfOldCarHandler;

    @Resource
    EmergencyContactOneInfoHandler emergencyContactOneInfoHandler;

    @Resource
    EmergencyContactTwoInfoHandler emergencyContactTwoInfoHandler;

    @Resource
    VehicleInfoHandler vehicleInfoHandler;

    public AdmittanceSubmitListener() {
        super(SceneEnum.ADMITTANCE_SUBMIT);
    }

    @PostConstruct
    void init(){
        this.handlers.add(creditorInfoHandler);
        this.handlers.add(mateInfoHandler);
        this.handlers.add(guarantorInfoHandler);
        this.handlers.add(sellerInfoOfOldCarHandler);
        this.handlers.add(emergencyContactOneInfoHandler);
        this.handlers.add(emergencyContactTwoInfoHandler);
        this.handlers.add(vehicleInfoHandler);
    }
}

/**
 * @description: 贷前提交 事件监听器
 * @Date : 2020/12/2 5:17 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class BeforeLoanSubmitListener extends AbstractSubmitListener {

    @Resource
    CreditorInfoHandler creditorInfoHandler;

    @Resource
    VehicleInfoHandler vehicleInfoHandler;

    public BeforeLoanSubmitListener() {
        super(SceneEnum.BEFORE_LOAN_SUBMIT);
    }

    @PostConstruct
    void init(){
        this.handlers.add(creditorInfoHandler);
        this.handlers.add(vehicleInfoHandler);
    }
}


/**
 * @description: 车商账号提交 事件监听器
 * @Date : 2020/12/2 5:17 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class MerchantSubmitListener extends AbstractSubmitListener {

    @Resource
    CarDealerLegalPersonInfoHandler carDealerLegalPersonInfoHandler;

    @Resource
    CarDealerPrincipalInfoHandler carDealerPrincipalInfoHandler;

    @Resource
    CarDealerPayeeInfoHandler carDealerPayeeInfoHandler;

    public MerchantSubmitListener() {
        super(SceneEnum.MERCHANT_ACCOUNT_SUBMIT);
    }

    @PostConstruct
    void init(){
        this.handlers.add(carDealerLegalPersonInfoHandler);
        this.handlers.add(carDealerPrincipalInfoHandler);
        this.handlers.add(carDealerPayeeInfoHandler);
    }

}

/**
 * @description: 秒批提交 事件监听器
 * @Date : 2020/12/2 5:17 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class SecondBatchSubmitListener extends AbstractSubmitListener {

    @Resource
    CreditorInfoHandler creditorInfoHandler;

    @Resource
    SellerInfoHandler sellerInfoHandler;

    @Resource
    SalesManagerInfoHandler salesManagerInfoHandler;

    public SecondBatchSubmitListener() {
        super(SceneEnum.SECOND_BATCH_SUBMIT);
    }

    @PostConstruct
    void init(){
        this.handlers.add(creditorInfoHandler);
        this.handlers.add(sellerInfoHandler);
        this.handlers.add(salesManagerInfoHandler);
    }
}

/**
 * @description:  车辆评估备注 事件监听器
 * 关注订单状态：
 * 1、复审退回至授信-2101、
 * 2、二次风控（终审）拒绝-3910、
 * 3、等待贷前审核（已提交贷前资料）-4000
 * @Date : 2020/12/29 3:22 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
public class VehicleEvaluateRemarkListener extends AbstractSubmitListener {

    @Resource
    VehicleInfoHandler vehicleInfoHandler;

    public VehicleEvaluateRemarkListener() {
        super(SceneEnum.VEHICLE_EVALUATE_REMARK);
    }

    @PostConstruct
    void init(){
        this.handlers.add(vehicleInfoHandler);
    }
}

3.1.9、SubmitEventMulticaster

该类基于观察者模式，通知所有监听器处理，诸如SecondBatchSubmitListener、AdmittanceSubmitListener等。

/**
 * @description: 提交事件广播器
 * @Date : 2020/12/2 6:45 PM
 * @Author : 石冬冬-Seig Heil
 */
@Component
@Slf4j
public class SubmitEventMulticaster {
    /**
     * 监听器成员
     */
    protected final List<SubmitEventListen> listeners = new ArrayList<>();

    @Resource
    SecondBatchSubmitListener secondBatchSubmitListener;

    @Resource
    AdmittanceSubmitListener admittanceSubmitListener;

    @Resource
    BeforeLoanSubmitListener beforeLoanSubmitListener;

    @Resource
    MerchantSubmitListener merchantAccountSubmitEvent;

    @Resource
    VehicleEvaluateRemarkListener vehicleEvaluateRemarkListener;

    @PostConstruct
    void init(){
        listeners.add(secondBatchSubmitListener);
        listeners.add(admittanceSubmitListener);
        listeners.add(beforeLoanSubmitListener);
        listeners.add(merchantAccountSubmitEvent);
        listeners.add(vehicleEvaluateRemarkListener);
    }

    /**
     * 对外暴露接口
     * @param context 上下文
     */
    public void execute(SubmitEventContext context){
        log.info("[execute]appCode={},ctx={}",context.getAppCode(),JSONObject.toJSONString(context));
        listeners.forEach(event -> event.subscribe(context));
    }
}

3.1.10、HistoryDataSynchronizer

历史数据同步器

/**
 * @description: 历史数据（订单|车商）同步器
 * @Date : 2020/12/7 11:49 AM
 * @Author : 石冬冬-Seig Heil
 */
@Component
@Slf4j
public class HistoryDataSynchronizer {


    @Resource
    SubmitEventMulticaster submitEventMulticaster;

    @Resource
    OrderInfoService orderInfoService;

    @Resource
    DealerService dealerService;

    @Resource
    ExecutorService synchronizeThreadPoolExecutor;
    /**
     * 同步订单
     * @param request
     */
    public void synchronizeOrders(Request<String> request){
        boolean byScope = CollectionsTools.isNotEmpty(request.getScope());
        List<OrderInfo.SimpleEntity> recordList = byScope ? orderInfoService.queryTargets(request.getScope()) : orderInfoService.queryAll();
        Map<String,Integer> orderMap = recordList.stream()
                .collect(Collectors.toMap(OrderInfo.SimpleEntity::getAppCode,OrderInfo.SimpleEntity::getStatus));
        Set<String> appCodes = orderMap.keySet();
        if(request.getLimit() > 0){
            appCodes = appCodes.stream().limit(request.getLimit()).collect(Collectors.toSet());
        }

        //订单3种场景
        List<SceneEnum> sceneEnumList;
        List<SubmitEventContext> contextList;
        SubmitEventContext context;

        StopWatch stopWatch = new StopWatch();
        stopWatch.start("synchronizeOrders");
        log.info("[synchronizeOrders]count={}",appCodes.size());
        LongAdder adder = new LongAdder();

        //遍历订单执行 3种场景场景事件
        for(String appCode : appCodes){
            Integer status = orderMap.get(appCode);
            sceneEnumList = OrderScene.getScene(status);
            if(!CollectionUtils.isEmpty(sceneEnumList)){
                contextList = new ArrayList<>(sceneEnumList.size());
                for (SceneEnum sceneEnum: sceneEnumList) {
                    context = SubmitEventContext.builder()
                            .appCode(appCode)
                            .scene(sceneEnum)
                            .build();
                    contextList.add(context);
                    adder.increment();
                    log.info("[synchronizeOrders]current={},appCode={},context={}",adder.intValue(), appCode, JSON.toJSONString(context));
                    //asyncCall(context);
                }
                asyncCall(contextList);
            }else {
                log.warn("[synchronizeOrders][sceneEnum] warning!!! appCode={},status={}", appCode, status);
            }
        }
        stopWatch.stop();
        log.info("[synchronizeOrders]finished,total={},duration={}",adder.intValue(),stopWatch.getLastTaskTimeMillis() / 1000);
    }

    /**
     * 同步车商
     * @param request
     */
    public void synchronizeDealers(Request<Long> request){
        boolean byScope = CollectionsTools.isNotEmpty(request.getScope());
        List<Long> ids = byScope ? dealerService.queryTargets(request.getScope()) : dealerService.queryAllIds();
        if(request.getLimit() > 0){
            ids = ids.stream().limit(request.getLimit()).collect(Collectors.toList());
        }
        SubmitEventContext context;
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        log.info("[synchronizeDealers]count={}",ids.size());
        LongAdder adder = new LongAdder();
        for(Long merchantId : ids){
            context = SubmitEventContext.builder()
                    .appCode(Objects.toString(merchantId))
                    .merchantId(merchantId)
                    .scene(SceneEnum.MERCHANT_ACCOUNT_SUBMIT)
                    .build();
            adder.increment();
            log.info("[synchronizeDealers]current={},merchantId={},context={}",adder.intValue(),merchantId, JSON.toJSONString(context));
            asyncCall(context);
        }
        stopWatch.stop();
        log.info("[synchronizeDealers]finished,total={},,duration={}",adder.intValue(),stopWatch.getLastTaskTimeMillis() / 1000);
    }

    /**
     * 异步写入
     * @param context
     */
    void asyncCall(SubmitEventContext context){
        try {
            synchronizeThreadPoolExecutor.execute(() -> submitEventMulticaster.execute(context));
        } catch (Exception e) {
            log.error("[asyncCall]appCode={},context={}",context.getAppCode(),JSON.toJSONString(context));
        }
    }
    void asyncCall(List<SubmitEventContext> contextList){
        try {
            synchronizeThreadPoolExecutor.execute(() -> {
                for (SubmitEventContext context : contextList) {
                    submitEventMulticaster.execute(context);
                }
            });
        } catch (Exception e) {
            log.error("[asyncCall]size={},contextList={}",contextList.size(),JSON.toJSONString(contextList));
        }
    }

    /**
     * @description: 订单状态与场景的映射配置枚举类
     * @Date : 2020/12/11 10:20 AM
     * @Author : 石冬冬-Seig Heil
     */
    enum OrderScene{
        /**
         * 秒批提交
         */
        SECOND_BATCH_SUBMIT(status -> status.intValue() <= 1200, SceneEnum.SECOND_BATCH_SUBMIT),
        /**
         * 准入提交
         */
        ADMITTANCE_SUBMIT(status -> status.intValue() > 1200 &&  status.intValue() <= 2100, SceneEnum.SECOND_BATCH_SUBMIT, SceneEnum.ADMITTANCE_SUBMIT),
        /**
         * 贷前提交
         */
        LOAN_BEFORE_SUBMIT(status -> status.intValue() > 2100 &&  status.intValue() < 9999, SceneEnum.SECOND_BATCH_SUBMIT, SceneEnum.ADMITTANCE_SUBMIT, SceneEnum.BEFORE_LOAN_SUBMIT);

        private Predicate<Integer> predicate;
        private List<SceneEnum> sceneEnumList;

        OrderScene(Predicate<Integer> predicate, SceneEnum... scenes){
            this.predicate = predicate;
            this.sceneEnumList = Arrays.stream(scenes).collect(Collectors.toList());
        }
        /**
         * 根据状态获取场景
         * @param status
         * @return
         */
        public static List<SceneEnum> getScene(Integer status){
            Optional<OrderScene> optional = Stream.of(OrderScene.values()).filter(each -> each.predicate.test(status)).findFirst();
            return optional.isPresent() ? optional.get().sceneEnumList : null;
        }
    }

    /**
     * @description: 包装请求参数
     * @Date : 2020/12/11 10:19 AM
     * @Author : 石冬冬-Seig Heil
     */
    @Data
    @NoArgsConstructor
    public static class Request<T> {
        /**
         * 限制条数
         */
        @ApiModelProperty(value = "限制条数",dataType = "java.lang.Integer")
        protected int limit;
        /**
         * 指定范围
         */
        @ApiModelProperty(value = "指定范围",dataType = "java.lang.List<T>")
        protected List<T> scope;
    }
}

/**
 * @description: 车辆评估业务对象
 * @Date : 2020/12/12 9:55 AM
 * @Author : 石冬冬-Seig Heil
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CarEvaluationBo {
    /**
     * car_price_evaluation_apply.id
     */
    @ApiModelProperty(value="主键",name="id",dataType="java.lang.Integer")
    private Integer id;

    /**
     * car_price_evaluation_apply.app_code
     */
    @ApiModelProperty(value="订单号",name="app_code",dataType="java.lang.String")
    private String appCode;
    /**
     * car_price_evaluation_apply.vin
     */
    @ApiModelProperty(value="vin码",name="vin",dataType="java.lang.String")
    private String vin;
    /**
     * car_price_evaluation_apply.evaluation_remarks
     */
    @ApiModelProperty(value="评估备注",name="evaluation_remarks",dataType="java.lang.String")
    private String evaluationRemarks;
}

3.1.11、RabbitConsumer

/**
 * @description: rabbitmq消费者
 * @Date : 2020/7/10 下午4:02
 * @Author : 石冬冬-Seig Heil
 */
@Component
@Slf4j
public class RabbitConsumer {

    final static SceneEnum SCENE_MERCHANT_ACCOUNT_SUBMIT = SceneEnum.MERCHANT_ACCOUNT_SUBMIT;

    static String HOST_ADDRESS;

    static {
        try {
            HOST_ADDRESS = InetAddress.getLocalHost().getHostAddress();
            log.info("[RabbitConsumer],HOST_ADDRESS={}",HOST_ADDRESS);
        } catch (UnknownHostException e) {
            log.error("[RabbitConsumer],init HOST_ADDRESS exception",e);
            HOST_ADDRESS = "127.0.0.0";
        }
    }

    @Autowired
    ExecutorService commonThreadPoolExecutor;

    @Autowired
    SubmitEventMulticaster submitEventMulticaster;

    @Autowired
    DiamondConfigProxy diamondConfigProxy;

    @Autowired
    RedisService redisService;

    @Autowired
    TraceLogFacade traceLogFacade;

    /**
     * 订阅订单中心变化
     * @param message
     */
    public void subscribeOrderStatus(String message){
        final String LOG_TITLE = "subscribeOrderStatus#orderCenterStatus|ordercenter-key-node-message";
        String appCode = null;
        Integer status = null;
        try {
            BusMessage busMessage = JSON.parseObject(message,new TypeReference<BusMessage>(){});
            log.info("{}, params={}", LOG_TITLE, JSON.toJSONString(busMessage));
            appCode = busMessage.getAppCode();
            status = busMessage.getStatus();
            // 2. 查询是否在处理的状态范围
            OrderStatusAttention orderStatusAttention = diamondConfigProxy.orderStatusAttention();
            List<Integer> attentionStatusScope = orderStatusAttention.getScope();
            if(status != null && !attentionStatusScope.contains(status)) {
                log.debug("{}, 不需要关注状态 appCode={}, status={}", LOG_TITLE, appCode, status);
                return;
            }
            SceneEnum scene = SceneEnum.valueOf(orderStatusAttention.getMapping().get(status));
            SubmitEventContext context = SubmitEventContext.builder()
                    .appCode(appCode)
                    .scene(scene)
                    .build();
            log.info("{} appCode={}, SubmitEventContext={}", LOG_TITLE, appCode, JSON.toJSONString(context));
            //3、记录图谱记录
            if(diamondConfigProxy.switchConfig().subscribeOrderStatus){
                submitEventMulticaster.execute(context);
            }
            //4、记录链路日志
            syncSaveTraceRecord(appCode,message,traceLog -> {
                traceLog.setUrl("[" + HOST_ADDRESS + "]rabbitConsumer.subscribeOrderStatus");
                traceLog.setResponseBody(JSONObject.toJSONString(context));
            });
        } catch (Exception e) {
            log.error("[subscribeOrderStatus]异常,appCode={},message={}", appCode,JSONObject.toJSONString(message),e);
        }
    }

    /**
     * 订阅车商账号提交
     * @param message
     */
    public void subscribeMerchantAccountSubmit(String message){
        final String LOG_TITLE = "subscribeOrderStatus#subscribeMerchantAccountSubmit|ordercenter-key-node-message";
        Long dealerId = null;
        try {
            List<CarDealerInfoDTO> carDealerList = JSON.parseArray(message,CarDealerInfoDTO.class);
            log.info("{}, params={}", LOG_TITLE, JSON.toJSONString(carDealerList));
            if(CollectionsTools.isEmpty(carDealerList)){
                log.warn("{}, params={}", LOG_TITLE, JSON.toJSONString(carDealerList));
                return;
            }
            dealerId = carDealerList.get(0).getMerchantId();
            SubmitEventContext context = SubmitEventContext.builder()
                    .merchantId(dealerId)
                    .carDealers(carDealerList)
                    .scene(SCENE_MERCHANT_ACCOUNT_SUBMIT)
                    .build();
            log.info("{} merchantId={}, SubmitEventContext={}", LOG_TITLE, dealerId, JSON.toJSONString(context));
            //1、记录图谱记录
            if(diamondConfigProxy.switchConfig().subscribeMerchantAccountSubmit){
                submitEventMulticaster.execute(context);
            }
            //2、记录链路日志
            syncSaveTraceRecord(Objects.toString(dealerId),message,traceLog -> {
                traceLog.setUrl("[" + HOST_ADDRESS + "]rabbitConsumer.subscribeMerchantAccountSubmit");
                traceLog.setResponseBody(JSONObject.toJSONString(context));
            });
        } catch (Exception e) {
            log.error("[subscribeMerchantAccountSubmit]异常,dealerId={},message={}", dealerId,message,e);
        }
    }

    /**
     * 记录链路日志
     * @param appCode
     * @param message
     * @param caller
     */
    void syncSaveTraceRecord(String appCode, String message, Consumer<TraceLog> caller){
        TraceLog traceLog = TraceLog.builder()
                .appCode(appCode)
                .target(this.getClass().getPackage().getName() + "." + this.getClass().getSimpleName())
                .requestBody(message)
                .requestTime(TimeTools.createNowTime())
                .responseTime(TimeTools.createNowTime())
                .traceType(TraceTypeEnum.RABBIT_CONSUMER.getIndex()).build();
        caller.accept(traceLog);
        commonThreadPoolExecutor.execute(() -> traceLogFacade.saveRecord(traceLog));
    }


    @Data
    static class BusMessage implements Serializable {
        private Long messageId;
        private String messageCode;
        private String channel;
        private String appCode;
        //上一个状态
        private Integer lastStatus;
        //当前状态
        private Integer status;
        private String data;
        private Date sendTime;
        //初审增加征信类型
        private Integer creditAuthType;
    }
}

关系图谱服务的技术方案设计（上篇）