面向复杂业务场景的微中台框架设计实践

陈德付(星翼)

一、介绍前言

在面对平时的业务功需求迭代时，相信大家都会面临一个代码复杂度和后续的维护高成本的问题，下面我们主要针对营销返利活动场景，对复杂的业务场景的代码设计进行详细的讲解。

二、微中台研发复杂度背景

1、负责的业务中，规则比较多，大部分情况大家是不是会不自觉的试图使用if...else...解决一切问题，这样就会存在一个问题，逻辑在日常的需求迭代中是不是会变的越来越复杂？越来越乱？可读性越来越差？最终慢慢的就会演变成一个看不懂，改不动的黑盒子，没有人搞清楚黑盒子里面到底发生了什么？测试的可测性也大大的降低。
2、在实际的业务开发中，业务场景多，迭代频繁，变化快，规则可能由很多人掌握，没有办法通过一个人了解整个业务规则的全貌的。还有加上业务在行业固有的复杂度和历史包袱，这些问题都会让我们感到痛苦。不知道在哪里改代码，如何下手，改了这块代码会不会带来其他的影响，影响面无法评估。
3、每次需求迭代，研发人力成本投入过多，测试回归成本较高，对应业务需求支撑比较慢，目前比较繁重，对新业务的支持，需要大量的人力成本投入。

三、针对营销活动产品框架

在了解设计背景下，先看下目前主推的营销返利活动的几个玩法。

活动类型	描述
单品返利	购买指定活动商品，进行活动返利。
普通累返	累计活动期限内，按照下单量或者下单GMV，进行奖励累计发放。
实货累返	活动推广门店购买提货卡，后面再转成实货的时候，再返点，让门店自提优惠券，或系统自动发放对应奖励。
年框累返	以年为单位，进行签署奖励合同，按照下单GMV为坎级算返点，按转实货部分进行算奖励，自提发放优惠券。
抽奖	达到一定条件，给用户抽奖机会。

了解了上面的活动玩法，针对产品框架设计，总结出如下图的统一的活动处理产品中台架构设计。

四、架构框架演变升级过程

原代码设计，在面对业务需求功能开发时

直接烟囱式开发，没有组件沉淀
逻辑全部耦合在各自的service中，业务代码复用度不高，
针对不同场景的活动玩法，没有统一消息入口。

如下图：

这样的代码开发设计，就是上面所说的带来的弊端。

每次业务需求迭代，改动的地方比较大，成本高，不知道从何处下手
影响面评估难度大，导致测试回归的工作量也变大。

于是针对这类的问题做了概念上的抽象和代码框架的设计：
返利型业务的抽象，实际本质就是了解每种业务玩法特性公共点的抽象，app层从上到下过程分析，模型层从下而上分析结合。能力下层保持模型不断演进，能力下层标准：复用，内聚。
我们举个例子：

需求描述	case1: 在活动期间内（10.1-10.7），累计购买金额达到1000元，活动结束后返100元优惠券。case2: 预热期间有报名，并且在活动期间内（10.1-10.7），累计购买实货（提货卡除外）金额达到1000元，活动结束后返100元优惠券。case3: 在活动期间内（10.1-10.7），累计购买实货（提货卡除外）金额达到1000元，活动结束后第3天返100元优惠券，并可以抽奖一次。caseN: ....
需求分析过程	1. 语义分解，抽象，从case描述看我们大致可以抽象为，怎么累计，怎么返利。怎么累还可以细拆为何时，何人等。怎么返还可以细拆为何时返，返什么，返多少等等。 a. "在活动期间内（10.1-10.7）"，"预热期间有报名" → 前置条件 b. "累计购买金额" → 执行累计 c. "达到1000元"，"活动结束后" → 返利前置条件 d. 返100元优惠券 → 执行返利 2. 系统流程，框架，模型能力层次抽象，如下图

需求描述

case1: 在活动期间内（10.1-10.7），累计购买金额达到1000元，活动结束后返100元优惠券。case2: 预热期间有报名，并且在活动期间内（10.1-10.7），累计购买实货（提货卡除外）金额达到1000元，活动结束后返100元优惠券。case3: 在活动期间内（10.1-10.7），累计购买实货（提货卡除外）金额达到1000元，活动结束后第3天返100元优惠券，并可以抽奖一次。caseN: ....

需求分析过程

1. 语义分解，抽象，从case描述看我们大致可以抽象为，怎么累计，怎么返利。怎么累还可以细拆为何时，何人等。怎么返还可以细拆为何时返，返什么，返多少等等。
a. "在活动期间内（10.1-10.7）"，"预热期间有报名" → 前置条件
b. "累计购买金额" → 执行累计
c. "达到1000元"，"活动结束后" → 返利前置条件
d. 返100元优惠券 → 执行返利
2. 系统流程，框架，模型能力层次抽象，如下图

于是就推演升级出现有架构模式，收敛消息入口，抽象大的的业务领域模块，沉淀通用组件，不同业务域的解耦，提高内部业务逻辑的复用性和高内聚。抽象一套业务执行框架，让开发更专注每个业务需求本身的业务逻辑代码开发。如下图：

整体业务模块的系统架构：

沉淀通用组件，在复用通用场景组件时，只需编排已有组件，更快的支持业务需求的迭代。

五、详细代码设计实现

代码业务框架和业务逻辑分离，实际业务开发中更关注业务模块的开发。详细对应代码设计实现模型：

框架骨架代码执行类图和业务模块核心类图和模型关系：

骨架框架业务执行时序图：

框架骨架核心代码实现伪代码：

/**
 * <功能介绍><br>
 * <p>
 * <>
 *
 * @author xy on 2022/2/25.
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Service
public class RebateBizOptServiceImpl implements RebateBizOptService {

    private static final YtLogger LOGGER = YtLoggerFactory.getLogger(RebateBizOptServiceImpl.class);

    private static final Long SMALL_AMOUNT = 1L;

    @Resource
    private RebateRefundShareAmountComponent rebateRefundShareAmountComponent;

    @Resource
    private CacheProxy cacheProxy;

    @Resource
    private RebateBizExecutor rebateBizExecutor;

    /**
     * 门店自提现金券发奖处理
     *
     * @param rebateActivityGiftExtract 提取优惠券参数
     *
     * @return 处理结果
     */
    @Override
    public Boolean rebateActivityGitExtract(RebateActivityGiftExtractDTO rebateActivityGiftExtract) {
        RebateActivityGiftExtractValidator.validate(rebateActivityGiftExtract);
        rebateBizExecutor.execute(MultiRebateCmdDTO.builder()
                                                   .rebateSceneCode(RebateSceneEnum.PRIZE.getSceneCode())
                                                   .rebateActivityGiftExtract(rebateActivityGiftExtract)
                                                   .async(RebateSceneEnum.PRIZE.getAsync())
                                                   .build());
        return Boolean.TRUE;
    }

    /**
     * 交易订单支付完成，计算流水处理
     *
     * @param trade           支付交易订单信息
     * @param rebateBizHandle 业务模块
     */
    @Override
    public void rebateActForPaid(TradeDTO trade, Integer rebateBizHandle) {
        rebateBizExecutor.execute(MultiRebateCmdDTO.builder()
                                                   .rebateSceneCode(RebateSceneEnum.PAID.getSceneCode())
                                                   .trade(trade)
                                                   .async(RebateSceneEnum.PAID.getAsync())
                                                   .rebateBizHandle(rebateBizHandle)
                                                   .build()
        );
    }

    /**
     * 退款关闭，返利逻辑处理
     *
     * @param orderRefund     退款订单信息
     * @param rebateBizHandle 业务模块
     *
     * @return 处理结果
     */
    @Override
    public void rebateActForRefundClose(OrderRefundDTO orderRefund, Integer rebateBizHandle) {
        rebateBizExecutor.execute(MultiRebateCmdDTO.builder()
                                                   .rebateSceneCode(RebateSceneEnum.REFUND_CLOSED.getSceneCode())
                                                   .orderRefund(orderRefund)
                                                   .async(RebateSceneEnum.REFUND_CLOSED.getAsync())
                                                   .rebateBizHandle(rebateBizHandle)
                                                   .build()
        );
    }
}

/**
 * <功能介绍><br>
 * <p>
 * <返利业务执行器>
 *
 * @author xy on 2022/6/14.
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Service
public class RebateBizExecutor {

    private static final YtLogger LOGGER = YtLoggerFactory.getLogger(RebateBizExecutor.class);

    @Resource
    private SkeletonHandleBuildBiz skeletonHandleBuildBiz;

    @Resource
    private DefaultRebateHandleFrameBuilder defaultRebateHandleFrameBuilder;

    @Resource
    private YearRebateHandleFrameBuilder yearRebateHandleFrameBuilder;

    @Resource
    private MaterialRebateHandleFrameBuilder materialRebateHandleFrameBuilder;

    /**
     * 返利中台骨架业务执行
     *
     * @param multiRebateCmd 执行参数
     *
     * @return 处理结果
     */
    public List<MultiRebateResult> execute(MultiRebateCmdDTO multiRebateCmd) {
        //请求参数检查验证
        validateRebateCmdParams(multiRebateCmd);

        //初始化上下文信息
        MultiRebateContext context = MultiRebateContextDelegation.initContext(multiRebateCmd);

        //获取通用资源数据
        fetchCommonResource(context);

        //加载返利骨架窗口
        loadHandleFrame(context);

        //执行骨架构建和业务模块处理
        List<MultiRebateResult> resultList = skeletonHandleBuildBiz.buildHandles(context);

        //返回结果解析聚合
        return assembleResults(resultList, multiRebateCmd);
    }

    /**
     * 返回结果解析聚合
     *
     * @param resultList     业务执行结果
     * @param multiRebateCmd 请求入参
     *
     * @return 解析后的处理结果
     */
    private List<MultiRebateResult> assembleResults(List<MultiRebateResult> resultList, MultiRebateCmdDTO multiRebateCmd) {
        List<MultiRebateResult> failResults = StreamUtil.filter(resultList, BaseRebateResult::filterFail);
        if (CollectionUtils.isEmpty(failResults)) {
            return resultList;
        }
        LOGGER.src(REBATE_BIZ_FRAMEWORK).warn("开始执行返利业务处理，参数信息：{}，处理失败结果：{}", JSONObject.toJSONString(multiRebateCmd), JSONObject.toJSONString(failResults));
        throw new SmcException(Boolean.TRUE, failResults.get(0).getMessage());
    }

    /**
     * 加载返利骨架窗口
     *
     * @param context 上下文信息
     */
    private void loadHandleFrame(MultiRebateContext context) {
        HandleFrame handleFrame;
        if (RebateBizHandleEnum.YEAR_HANDLE.eq(context.getRebateBizHandle())
                || (RebateSceneEnum.PRIZE.equal(context.getRebateSceneCode())) && PromotionActTypeEnum.REBATE_ACTIVITY.equal(context.getRebateActivityGiftExtract().getActType())) {
            handleFrame = yearRebateHandleFrameBuilder.build(context);
        } else if (RebateBizHandleEnum.MATERIAL_HANDLE.eq(context.getRebateBizHandle())
                || (RebateSceneEnum.PRIZE.equal(context.getRebateSceneCode())) && PromotionActTypeEnum.MATERIAL_REBATE.equal(context.getRebateActivityGiftExtract().getActType())) {
            handleFrame = materialRebateHandleFrameBuilder.build(context);
        } else {
            handleFrame = defaultRebateHandleFrameBuilder.build(context);
        }
        context.setHandleFrame(handleFrame);
    }

    /**
     * 获取通用资源数据
     *
     * @param context 上下文信息
     */
    private void fetchCommonResource(MultiRebateContext context) {
    }

    /**
     * 请求参数检查验证
     *
     * @param multiRebateCmd 请求参数指令
     */
    private void validateRebateCmdParams(MultiRebateCmdDTO multiRebateCmd) {
        SmcValidate.notNull(multiRebateCmd, "处理请求参数不能为空");
    }

/**
 * <功能介绍><br>
 * <p>
 * <默认返利模块构建器>
 *
 * @author xy on 2022/6/14.
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Component
public class DefaultRebateHandleFrameBuilder implements RebateHandleFrameBuilder {

    @Resource
    private MaterialMultiRebateHandle materialMultiRebateHandle;

    @Resource
    private YearMultiRebateHandle yearMultiRebateHandle;

    @Override
    public HandleFrame build(MultiRebateContext rebateContext) {
        return HandleFrame.instance()
                          .addConfig(HandleFrame.HandleConfig.of(materialMultiRebateHandle.getIdentifier()))
                          .addConfig(HandleFrame.HandleConfig.of(yearMultiRebateHandle.getIdentifier()));
    }
}

/**
 * <功能介绍><br>
 * <p>
 * <处理器构建业务执行>
 *
 * @author xy on 2022/6/14.
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@SuppressWarnings("ALL")
@Component
public class SkeletonHandleBuildBiz {

    private static final YtLogger LOGGER = YtLoggerFactory.getLogger(SkeletonHandleBuildBiz.class);

    @Resource
    private AsdThreadPool rebateHandleThreadPool;

    /**
     * 构架构建并执行业务模块
     *
     * @param context 上下文信息
     *
     * @return 执行结果
     */
    public List<MultiRebateResult> buildHandles(MultiRebateContext context) {
        try {
            List<Callable<MultiRebateResult>> callableList = buildCallableList(context);

            List<Future<MultiRebateResult>> futures = rebateHandleThreadPool.invokeAll(callableList);
            if (CollectionUtils.isEmpty(futures)) {
                return Lists.newArrayList();
            }

            List<MultiRebateResult> rebateResults = Lists.newArrayList();
            for (Future<MultiRebateResult> future : futures) {
                rebateResults.add(future.get());
            }
            return rebateResults;
        } catch (InterruptedException | ExecutionException e) {
            LOGGER.src(REBATE_BIZ_FRAMEWORK).error("并行执行骨架业务处理异常，请求参数：{}", JSONObject.toJSONString(context), e);
        }
        return Lists.newArrayList();
    }

    private List<Callable<MultiRebateResult>> buildCallableList(MultiRebateContext context) {
        List<Callable<MultiRebateResult>> callableList = Lists.newArrayList();
        for (HandleFrame.HandleConfig handleConfig : context.getHandleFrame().getHandles()) {

            RebateHandle rebateHandle = getRebateHandle(handleConfig.getIdentifier());
            RebateMatcher rebateMatcher = getRebateMatcher(handleConfig.getMatcherIdentifier());
            RebateProcessor rebateProcessor = getRebateProcessor(handleConfig.getProcessorIdentifier());
            RebateExtension rebateExtension = getRebateExtension(handleConfig.getExtensionIdentifier());

            callableList.add(new Callable<MultiRebateResult>() {
                @Override
                public MultiRebateResult call() throws Exception {
                    MultiRebateResult result = buildSingleHandle(context, rebateHandle, rebateProcessor, rebateMatcher, rebateExtension);
                    return Optional.ofNullable(result).orElseGet(() ->
                            MultiRebateResult.buildFailResult(handleConfig.getIdentifier() + "模块未返回结果")
                    );
                }
            });
        }
        return callableList;
    }

    private MultiRebateResult buildSingleHandle(BaseRebateContext context,
                                    RebateHandle<BaseRebateHandleDTO, BaseRebateContext, MultiRebateResult> handle,
                                    RebateProcessor<BaseRebateHandleDTO, MultiRebateResult> processor,
                                    RebateMatcher<BaseRebateHandleDTO, BaseRebateContext> matcher,
                                    RebateExtension<BaseRebateHandleDTO> extension) {
        try {
            return (MultiRebateResult) handle.execute(context, matcher, processor, extension);
        } catch (DeadlockLoserDataAccessException e) {
            LOGGER.src(REBATE_BIZ_FRAMEWORK).warn("handle：{},执行处理异常.获取数据库锁失败", handle.getIdentifier(), e);
            return MultiRebateResult.buildFailResult("获取锁失败");
        } catch (DuplicateKeyException e) {
            LOGGER.src(REBATE_BIZ_FRAMEWORK).warn("handle：{},执行处理异常.唯一键冲突，重复处理", handle.getIdentifier(), e);
            return MultiRebateResult.buildFailResult(RebateResultEnum.NOT_CONFORM_RULE_ACT_FAIL);
        } catch (Throwable e) {
            LOGGER.src(REBATE_BIZ_FRAMEWORK).error("handle：{},执行处理异常.", handle.getIdentifier(), e);
            return MultiRebateResult.buildFailResult(e.getMessage());
        }
    }

    private RebateHandle getRebateHandle(String handleId) {
        return StringUtils.isBlank(handleId) ? null : RebateHandleIndex.getHandleIndex().get(handleId);
    }

    private RebateMatcher getRebateMatcher(String matcherId) {
        return StringUtils.isBlank(matcherId) ? null : RebateHandleIndex.getMatcherIndex().get(matcherId);
    }

    private RebateProcessor getRebateProcessor(String processorId) {
        return StringUtils.isBlank(processorId) ? null : RebateHandleIndex.getProcessorIndex().get(processorId);
    }

    private RebateExtension getRebateExtension(String extensionId) {
        return StringUtils.isBlank(extensionId) ? null : RebateHandleIndex.getExtensionIndex().get(extensionId);
    }
}

/**
 * <功能介绍><br>
 * <p>
 * <基础返利处理器>
 *
 * @author xy on 2022/6/14.
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public interface RebateHandle<H extends BaseRebateHandleDTO, C extends BaseRebateContext, R> extends ClassNameIdentifiable {

    YtLogger LOGGER = YtLoggerFactory.getLogger(RebateHandle.class);

    @SuppressWarnings("AlibabaThreadShouldSetName")
    ExecutorService EXECUTOR = new ThreadPoolExecutor(20, 30, 0L,
                                                        TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(2048));

    /**
     * 执行业务
     *
     * @param context   上下文参数
     * @param matcher   返利匹配器
     * @param processor 返利处理器
     * @param extension 扩展处理器
     *
     * @return 执行结果
     */
    default R execute(@NotNull C context, @Nullable RebateMatcher<H, C> matcher, @Nullable RebateProcessor<H, R> processor,
                      RebateExtension<H> extension) {

        if (Objects.isNull(matcher) || Objects.isNull(processor)) {
            return null;
        }

        H matchHandleDTO = matcher.match(context);

        matchHandleDTO = post(matchHandleDTO, context);

        R process = processor.process(matchHandleDTO);

        Optional.ofNullable(matchHandleDTO).ifPresent(o -> Optional.ofNullable(extension).ifPresent(x -> {
            if (BooleanUtils.isTrue(o.getAsync())) {
                EXECUTOR.execute(() -> expand(x, o));
            } else {
                expand(x, o);
            }
        }));

        return process;
    }

    /**
     * 内部转换器
     *
     * @param handleDTO  数据模型
     * @param context    上下文参数
     *
     * @return 处理结果
     */
    default H post(H handleDTO, C context) {
        if (Objects.isNull(handleDTO)) {
            return null;
        }

        handleDTO.setRebateSceneCode(context.getRebateSceneCode());
        handleDTO.setAsync(context.getAsync());

        return handleDTO;
    }

    /**
     * 扩展逻辑执行
     *
     * @param extension 扩展器
     * @param handle    数据模型
     */
    default void expand(RebateExtension<H> extension, H handle) {
        try {
            extension.expand(handle);
        } catch (Throwable e) {
            LOGGER.src(REBATE_BIZ_FRAMEWORK).error("执行后置扩展器：{} 执行异常，参数信息：{}", extension.getIdentifier(), JSONObject.toJSONString(handle), e);
        }
    }
}