编码技巧——权益发放（策略模式+抽象模板）

日常开发中，遇到这样一个场景：做一个用户会员权益发放模块，权益的类型可能有：平台积分、礼包、优惠券、支付卷、红包、兑换码、爱奇艺会员兑换码等；这些权益来自不同的部门内外的系统，甚至是跨公司合作。当然可以为每种不同的权益单独设计对应的模块提供服务，但是更合适的做法是：抽象出权益模型，使用权益类型区分，这样权益可以统一存储，打包权益的发放可以由DN事务天然的支持，并且可通过用户表示UID对用户权益分表；

此外，发放权益和查询用户权益这2个功能是每个权益类型服务都应该具备的，因此可以抽象成权益服务模板，让各个权益类型实现这个模板；当需要对接新权益或移除旧权益时，只需要调整实现类和权益类型枚举，而不需要修改主流程的代码逻辑。下面给一个代码示例：

1. 权益发放抽象模板

/**
 * 权益模板：[模板]在于封装共同的处理流程如参数拼装、DB更新/回滚、异常捕获等、先查本地再调用RPCcheck等...其中的细节由子类实现
 */
@Slf4j
public abstract class BenefitBaseTemplate {

    /**
     * 同步发放权益
     */
    public ReceiveBenefitResp syncSendBenefit(ReceiveBenefitReqDTO receiveBenefitReqDTO){
        // 构造请求参数
        SendBenefitReq sendBenefitReq = buildSendBenefitReq(receiveBenefitReqDTO);
        // 请求数据先入库,失败直接返回
        reqDataIntoDB(sendBenefitReq);
        SendBenefitResp sendResult;
        try {
            // 入库成功再调用RPC发放权益
            sendResult = this.sendBenefit(sendBenefitReq);
            // 更新用户权益信息
            updateUserBenefitAfterSendSuc(sendResult);
        } catch (Exception e) {
            // 这里捕获所有Exception,领取链路异常,直接回滚,返回领取失败
			// fixme 注意异常情况
            //  (1)case1: 权益发放成功、接口返回失败，可以尝试按流水号查询;未做强一致性回收权益，因为用户再次领取时会提示领取成功（权益发放是幂等的）
            //  (2)case2: 此时权益可能发放成功、本地更新DB失败，这里也未做权益回收也是认为没有强一致性需求，因为用户再次领取时会提示领取成功（权益发放是幂等的）
            log.error("[benefit receive]syncSendBenefitByType_error_rollback! [receiveBenefitReqDTO={}]", JSON.toJSONString(receiveBenefitReqDTO));
            deleteReqDataInDB(sendBenefitReq);
            throw e;
        }
        return new ReceiveBenefitResp(sendResult);
    }
	
	/**
     * 异步领取权益
     */
    @Override
    public void asyncSendBenefit(ReceiveBenefitReqDTO receiveBenefitReqDTO) {
        // 构造请求参数
        SendBenefitReq sendBenefitReq = buildSendBenefitReq(receiveBenefitReqDTO);
        // 请求数据先入库,失败直接返回
        reqDataIntoDB(sendBenefitReq);
        // 入库成功再发放权益,权益发放走异步方式,带重试补偿机制
        this.asynSendBenefit(sendBenefitReq);
    }

	/**
     * 查询用户权益
     */
    @Override
    public List<UserBenefitDTO> queryUserBenefits(ReceiveBenefitReqDTO receiveBenefitReqDTO) {
        // 1.先查本地
		...
        // 2.未查到则再RPC
		List<UserBenefitDTO>  userBenefits = this.queryUserBenefits(openid, benefitType, instanceIds);
		// 3.异步刷新到本地
		...
		return userBenefits;
    }

    /**
     * 异步发放权益
     */
    private void asynSendBenefit(SendBenefitReq sendBenefitReq) {
        try {
            Integer benefitType = sendBenefitReq.getBenefitType();
            ExecutorService executorService = ExecutorManager.getExecutorService(benefitType);
            executorService.submit(
                    () -> {
                        // 默认重试3次，失败后走定时任务补偿
                        RetryTemplate.getInstance().execute(
                                // 重试方法的实现
                                context -> {
									// 发放权益后更新DB
                                    this.sendBenefit(sendBenefitReq);
									updateUserBenefitAfterSendSuc(sendResult);
                                    return null;
                                },
                                // 重试方法在重试策略结束后依旧没成功(抛出异常) 则执行下面方法
                                context -> {
                                    Throwable lastThrowable = context.getLastThrowable();
                                    ResultCodeEnum facadeResultEnum = ResultCodeEnum.SERVER_ERROR;
                                    if (lastThrowable != null) {
                                        if (lastThrowable instanceof BusinessException) {
                                            BusinessException businessException = (BusinessException) lastThrowable;
                                            ResultCodeEnum resultCodeEnum = businessException.getCode();
                                            log.warn("The_reason_for_reissuing_the_voucher_is_BuException,code={},message={}", resultCodeEnum.getCode(),
                                                    resultCodeEnum.getDesc());
                                        } else {
                                            log.error("The_reason_for_reissuing_the_voucher_is_other_Exception", lastThrowable);
                                        }
                                    }
                                    // 发失败超过3次后创建补偿定时任务
                                    log.warn("async_sendBenefit_fail_after_3_times_try! intoRetryTask.[sendBenefitReq={}]", sendBenefitReq);
                                    this.intoRetryTask(Collections.singletonList(sendBenefitReq));
                                    throw new BusinessException(facadeResultEnum);
                                });
                    }
            );
        } catch (Exception e) {
            log.error("[benefit receive]retry_task_error! e:{}", e);
        }
    }

    /* ... */

    /* abstract method below */

    /**
     * 发放权益
     *
     * @param sendBenefitReq
     * @return
     */
    public abstract SendBenefitResp sendBenefit(SendBenefitReq sendBenefitReq);

    /**
     * 查询用户权益
     *
     * @param openid
     * @param benefitType
     * @param instanceIds
     * @return
     */
    public abstract List<UserBenefitDTO> queryUserBenefits(@NotNull String openid, @NotNull Integer benefitType, List<String> instanceIds);

}

2. 权益发放实现类

/**
 * 礼券服务
 */
@Slf4j
@Service("ticketService")
public class TicketServiceImpl extends BenefitBaseTemplate implements TicketService {

	/*...*/

    @Override
    public List<BenefitDTO> queryBenefitDTOs(List<String> benefitIds, Integer benefitType) { 	/*...*/ }

    @Override
    public List<UserBenefitDTO> queryUserBenefits(@NotNull String openid, @NotNull Integer benefitType, List<String> instanceIds) {
		/*...*/
        List<MemberBenefitDO> memberBenefitDOs = memberBenefitDAO.selectBenefitByTypeAndInstanceIds(openid, benefitType, instanceIds);
        /*...*/
	}

    @HystrixCommand(groupKey = "TicketServiceGroupKey", commandKey = "sendTicketCommandKey", fallbackMethod = "sendTicketFallback", ignoreExceptions = BusinessException.class)
    @Override
    public SendBenefitResp sendBenefit(SendBenefitReq sendTicketReq) {
        /*...*/
        ResponseInfo<List<SaveTicketVO>> facadeResult;
        try {
            facadeResult = platformUserTicketFacade.sendUserTickets(param);
        } catch (Throwable e) {
            log.error("[SERIOUS_DUBBO]UserTicketFacade.sendUserTicket_error! [openid={} ticketId={} sendNo={}] e:{}",
                    sendTicketReq.getOpenid(), sendTicketReq.getBenefitId(), sendTicketReq.getSendNo(), e);
            throw new RuntimeException();
        }
        /*...*/
    }

}

3. 权益发放Service工厂

/**
 * 权益工厂
 */
@Service
public class BenefitServiceFactory {

    @Resource
    private BenefitBaseTemplate ticketService;
    @Resource
    private BenefitBaseTemplate gameWelfareService;
    @Resource
    private BenefitBaseTemplate couponService;
    @Resource
    private BenefitBaseTemplate pointService;
    @Resource
    private BenefitBaseTemplate exchangeCodeService;
    @Resource
    private BenefitBaseTemplate payCouponService;

    private static Map<Integer, BenefitBaseTemplate> typeServiceMap = Maps.newConcurrentMap();

    @PostConstruct
    public void init() {
        typeServiceMap.put(BenefitTypeEnum.NONTHRESHHOLD_TICKET.getBenefitType(), ticketService);
        typeServiceMap.put(BenefitTypeEnum.DISCOUNT_TICKET.getBenefitType(), ticketService);
        typeServiceMap.put(BenefitTypeEnum.GAME_BENEFIT_PKG.getBenefitType(), gameWelfareService);
        typeServiceMap.put(BenefitTypeEnum.GAME_BENEFIT_TICKET.getBenefitType(), ticketService);
        typeServiceMap.put(BenefitTypeEnum.MEMBER_POINT.getBenefitType(), pointService);
        typeServiceMap.put(BenefitTypeEnum.MALL_TICKET.getBenefitType(), couponService);
        typeServiceMap.put(BenefitTypeEnum.THEME_TICKET.getBenefitType(), payCouponService);
        typeServiceMap.put(BenefitTypeEnum.EBOOK_EXCHANGECODE.getBenefitType(), exchangeCodeService);
        typeServiceMap.put(BenefitTypeEnum.ONDEMAND_TICKET.getBenefitType(), ticketService);
        typeServiceMap.put(BenefitTypeEnum.PAY_COUPON.getBenefitType(), payCouponService);
        typeServiceMap.put(BenefitTypeEnum.GAME_VOUCHER.getBenefitType(), ticketService);
    }

    /**
     * 根据权益类型获取对应服务
     * @param benefitType
     * @return
     */
    public BenefitBaseTemplate getService(Integer benefitType) {
        return typeServiceMap.get(benefitType);
    }

}

策略执行，通过权益类型type取出权益发放Service，执行对应的权益发放

	// 取出service
	BenefitBaseTemplate benefitService = benefitServiceFactory.getService(receiveBenefitReqDTO.getBenefitType());
	// 同步
	benefitService.syncSendBenefit(receiveBenefitReqDTO);
	// 异步
	benefitService.asyncSendBenefit(receiveBenefitReqDTO);