Lottery抽奖系统项目记录
DDD领域驱动架构
架构图
各层分工
应用层{application}
- 应用服务位于应用层。用来表述应用和用户行为，负责服务的组合、编排和转发，负责处理业务用例的执行顺序以及结果的拼装。
- 应用层的服务包括应用服务和领域事件相关服务。
- 应用服务可对微服务内的领域服务以及微服务外的应用服务进行组合和编排，或者对基础层如文件、缓存等数据直接操作形成应用服务，对外提供粗粒度的服务。
- 领域事件服务包括两类：领域事件的发布和订阅。通过事件总线和消息队列实现异步数据传输，实现微服务之间的解耦。
领域层{domain}
微服务内部解耦，各功能模块划分为各个领域，vo、res、req等各不相通
领域中的repository仓储服务将会调用infrastructure层中的sql操作
- 领域服务位于领域层，为完成领域中跨实体或值对象的操作转换而封装的服务，领域服务以与实体和值对象相同的方式参与实施过程。
- 领域服务对同一个实体的一个或多个方法进行组合和封装，或对多个不同实体的操作进行组合或编排，对外暴露成领域服务。领域服务封装了核心的业务逻辑。实体自身的行为在实体类内部实现，向上封装成领域服务暴露。
- 为隐藏领域层的业务逻辑实现，所有领域方法和服务等均须通过领域服务对外暴露。
- 为实现微服务内聚合之间的解耦，原则上禁止跨聚合的领域服务调用和跨聚合的数据相互关联。
基础层{infrastructure}
pojo和具体的持久层操作
- 基础服务位于基础层。为各层提供资源服务（如数据库、缓存等），实现各层的解耦，降低外部资源变化对业务逻辑的影响。
- 基础服务主要为仓储服务，通过依赖反转的方式为各层提供基础资源服务，领域服务和应用服务调用仓储服务接口，利用仓储实现持久化数据对象或直接访问基础资源。
接口层{interfaces}
- 接口服务位于用户接口层，用于处理用户发送的Restful请求和解析用户输入的配置文件等，并将信息传递给应用层。
项目结构
其中lottery-rpc用于提供Dubbo接口声明
领域服务内部结构
-
model，用于提供vo、req、res 和 aggregates 聚合对象。
-
repository，提供仓储服务，其实也就是对Mysql、Redis等数据的统一包装。
-
service，是具体的业务领域逻辑实现层，在这个包下定义了algorithm抽奖算法实现和具体的抽奖策略包装 draw 层，对外提供抽奖接口 IDrawExec#doDrawExec
斐波那契散列索引
相比HashMap，使用该算法能进一步减少哈希碰撞
在本项目中主要用于将奖品根据抽中概率散列到一个数组中，在后面决定抽中哪个奖品时，同样生成一个随机数，并使用斐波那契散列算法计算其索引值，即可在o(1)时间内取得中奖结果
代码
protected int hashIdx(int val) {
int hashCode = val * HASH_INCREMENT + HASH_INCREMENT;
return hashCode & (RATE_TUPLE_LENGTH - 1);
}
奖池散列
// 循环填充概率范围值
// 例如奖品A的中奖概率为20%，则在rateTuple中散列填充20个奖品A，
for (int i = cursorVal + 1; i <= (rateVal + cursorVal); i++) {
// 此处将会直接影响到rateTupleMap中的对应策略id的奖池散列
rateTuple[hashIdx(i)] = awardRateInfo.getAwardId();
}
策略模式编写两种抽奖策略
策略模式是一种行为模式，也是替代大量ifelse的利器。它所能帮你解决的是场景，一般是具有同类可替代的行为逻辑算法场景。比如；不同类型的交易方式(信用卡、支付宝、微信)、生成唯一ID策略(UUID、DB自增、DB+Redis、雪花算法、Leaf算法)等，都可以使用策略模式进行行为包装，供给外部使用。
项目结构
流程
algorithm中共定义了两种抽奖算法，整体概率型EntiretyRandomDrawAlgorithm和单项概率型SingleRateRandomDrawAlgorithmk，且都继承自BaseAlgorithm(实现了IDrawAlgorithm接口)，定义抽奖执行方法时，入参可直接设置为IDrawAlgorithm类型，后根据活动策略中实际选用的抽奖算法，调用对应的抽奖算法策略实例，即可实现相对应的抽奖规则。
后续需要增加新的抽奖策略时，只需定义新的类并实现BaseAlgorithm即可
策略模式的优点
当有多种抽奖策略时，若不使用策略模式，将需要多个if-else进行逐个判断，并在if的语句块内写入执行流程，代码冗杂，也不易于后续扩展。
PostConstruct注解
在完成依赖注入后，将会自动执行使用了该注解的方法
模板模式编排抽奖流程
模板模式的核心设计思想是通过在抽象类中定义抽象方法的执行顺序，并将抽象方法设定为只有子类实现，但不设计独立访问的方法。
项目结构
程序流程
AbstractDrawBase即是所定义的那个抽象模板类，内部定义抽奖流程所需要执行的所有抽象方法，且其具有唯一的非抽象方法doDrawExec，内部编排好了所有的抽奖流程方法的执行顺序。AbstractDrawBase的实现类只需要根据具体的业务需求实现抽象方法即可，无论哪个实现类，最终都调用抽象类编排好的抽象流程方法。
代码
抽象模板类
public abstract class AbstractDrawBase extends DrawStrategySupport implements IDrawExec {
private Logger logger = LoggerFactory.getLogger(AbstractDrawBase.class);
@Override
public DrawResult doDrawExec(DrawReq req) {
// 1. 获取抽奖策略
StrategyRich strategyRich = super.queryStrategyRich(req.getStrategyId());
StrategyBriefVO strategy = strategyRich.getStrategy();
// 2. 校验抽奖策略是否已经初始化到内存
this.checkAndInitRateData(req.getStrategyId(), strategy.getStrategyMode(), strategyRich.getStrategyDetailList());
// 3. 获取不在抽奖范围内的列表，包括：奖品库存为空、风控策略、临时调整等
List<String> excludeAwardIds = this.queryExcludeAwardIds(req.getStrategyId());
// 4. 执行抽奖算法
String awardId = this.drawAlgorithm(req.getStrategyId(), drawAlgorithmGroup.get(strategy.getStrategyMode()), excludeAwardIds);
// 5. 包装中奖结果
return buildDrawResult(req.getuId(), req.getStrategyId(), awardId);
}
/**
* 获取不在抽奖范围内的列表，包括：奖品库存为空、风控策略、临时调整等，这类数据是含有业务逻辑的，所以需要由具体的实现方决定
*
* @param strategyId 策略ID
* @return 排除的奖品ID集合
*/
protected abstract List<String> queryExcludeAwardIds(Long strategyId);
/**
* 执行抽奖算法
*
* @param strategyId 策略ID
* @param drawAlgorithm 抽奖算法模型
* @param excludeAwardIds 排除的抽奖ID集合
* @return 中奖奖品ID
*/
protected abstract String drawAlgorithm(Long strategyId, IDrawAlgorithm drawAlgorithm, List<String> excludeAwardIds);
/**
* 校验抽奖策略是否已经初始化到内存
*
* @param strategyId 抽奖策略ID
* @param strategyMode 抽奖策略模式
* @param strategyDetailList 抽奖策略详情
*/
private void checkAndInitRateData(Long strategyId, Integer strategyMode, List<StrategyDetailBriefVO> strategyDetailList) {
// 非单项概率，不必存入缓存
if (!Constants.StrategyMode.SINGLE.getCode().equals(strategyMode)) {
return;
}
IDrawAlgorithm drawAlgorithm = drawAlgorithmGroup.get(strategyMode);
// 已初始化过的数据，不必重复初始化
if (drawAlgorithm.isExistRateTuple(strategyId)) {
return;
}
// 解析并初始化中奖概率数据到散列表
List<AwardRateInfo> awardRateInfoList = new ArrayList<>(strategyDetailList.size());
for (StrategyDetailBriefVO strategyDetail : strategyDetailList) {
awardRateInfoList.add(new AwardRateInfo(strategyDetail.getAwardId(), strategyDetail.getAwardRate()));
}
drawAlgorithm.initRateTuple(strategyId, awardRateInfoList);
}
/**
* 包装抽奖结果
*
* @param uId 用户ID
* @param strategyId 策略ID
* @param awardId 奖品ID，null 情况：并发抽奖情况下，库存临界值1 -> 0，会有用户中奖结果为 null
* @return 中奖结果
*/
private DrawResult buildDrawResult(String uId, Long strategyId, String awardId) {
if (null == awardId) {
logger.info("执行策略抽奖完成【未中奖】，用户：{} 策略ID：{}", uId, strategyId);
return new DrawResult(uId, strategyId, Constants.DrawState.FAIL.getCode());
}
AwardBriefVO award = super.queryAwardInfoByAwardId(awardId);
DrawAwardInfo drawAwardInfo = new DrawAwardInfo(award.getAwardId(), award.getAwardType(), award.getAwardName(), award.getAwardContent());
logger.info("执行策略抽奖完成【已中奖】，用户：{} 策略ID：{} 奖品ID：{} 奖品名称：{}", uId, strategyId, awardId, award.getAwardName());
return new DrawResult(uId, strategyId, Constants.DrawState.SUCCESS.getCode(), drawAwardInfo);
}
}
实现子类
@Service("drawExec")
public class DrawExecImpl extends AbstractDrawBase {
private Logger logger = LoggerFactory.getLogger(DrawExecImpl.class);
@Override
protected List<String> queryExcludeAwardIds(Long strategyId) {
List<String> awardList = strategyRepository.queryNoStockStrategyAwardList(strategyId);
logger.info("执行抽奖策略 strategyId：{}，无库存排除奖品列表ID集合 awardList：{}", strategyId, JSON.toJSONString(awardList));
return awardList;
}
@Override
protected String drawAlgorithm(Long strategyId, IDrawAlgorithm drawAlgorithm, List<String> excludeAwardIds) {
// 执行抽奖
String awardId = drawAlgorithm.randomDraw(strategyId, excludeAwardIds);
// 判断抽奖结果
if (null == awardId) {
return null;
}
/*
* 扣减库存，暂时采用数据库行级锁的方式进行扣减库存，后续优化为 Redis 分布式锁扣减 decr/incr
* 注意：通常数据库直接锁行记录的方式并不能支撑较大体量的并发，但此种方式需要了解，因为在分库分表下的正常数据流量下的个人数据记录中，是可以使用行级锁的，因为他只影响到自己的记录，不会影响到其他人
*/
boolean isSuccess = strategyRepository.deductStock(strategyId, awardId);
// 返回结果，库存扣减成功返回奖品ID，否则返回NULL 「在实际的业务场景中，如果中奖奖品库存为空，则会发送兜底奖品，比如各类券」
return isSuccess ? awardId : null;
}
}
工厂模式编写发奖流程
工厂模式又称工厂方法模式，是一种创建型设计模式，其在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。
这种设计模式也是 Java 开发中最常见的一种模式，它的主要意图是定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
简单说就是为了提供代码结构的扩展性，屏蔽每一个功能类中的具体实现逻辑。让外部可以更加简单的只是知道调用即可，同时，这也是去掉众多ifelse的方式。当然这可能也有一些缺点，比如需要实现的类非常多，如何去维护，怎样减低开发成本。但这些问题都可以在后续的设计模式结合使用中，逐步降低
项目结构
IDistributionGoods
定义了发奖接口，所有奖品类型都需要实现该接口
DistributionBase
定义了各类型发奖都需要执行的且相同的流程，如数据库更新操作
/impl
存放各类型奖品的发奖流程实现类
程序流程
DistributionGoodsFactory即创建类的工厂，只需传入奖品类型，将自动返回对应奖品类型的发奖流程对象，而无需使用if-else判断奖品的类型再调用对应的发奖流程
代码
GoodsConfig
public class GoodsConfig {
/** 奖品发放策略组 */
protected static Map<Integer, IDistributionGoods> goodsMap = new ConcurrentHashMap<>();
@Resource
private DescGoods descGoods;
@Resource
private RedeemCodeGoods redeemCodeGoods;
@Resource
private CouponGoods couponGoods;
@Resource
private PhysicalGoods physicalGoods;
@PostConstruct
public void init() {
goodsMap.put(Constants.AwardType.DESC.getCode(), descGoods);
goodsMap.put(Constants.AwardType.RedeemCodeGoods.getCode(), redeemCodeGoods);
goodsMap.put(Constants.AwardType.CouponGoods.getCode(), couponGoods);
goodsMap.put(Constants.AwardType.PhysicalGoods.getCode(), physicalGoods);
}
}
DistributionGoodsFactory
@Service
public class DistributionGoodsFactory extends GoodsConfig {
public IDistributionGoods getDistributionGoodsService(Integer awardType){
return goodsMap.get(awardType);
}
}
状态模式实现活动状态流转
状态不同则行为不同
状态模式描述的是一个行为下的多种状态变更，比如我们最常见的一个网站的页面，在你登录与不登录下展示的内容是略有差异的(不登录不能展示个人信息)，而这种登录与不登录就是我们通过改变状态，而让整个行为发生了变化。
在本项目中，不同的活动转换可以实现不同的状态流转，例如处于通过状态的活动无法转为提审，但可以转为开启或关闭状态
代码实现
结构
AbstractState中定义了所有活动状态可以执行的流转操作，但不同活动状态的流转操作结果是不相同的，可能为成功也可能为失败，因此流转操作的具体过程交由状态实现类去具体实现
AbstractState
public abstract class AbstractState {
@Resource
protected IActivityRepository activityRepository;
/**
* 活动提审
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 审核通过
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 审核拒绝
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 撤审撤销
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 活动关闭
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result close(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 活动开启
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result open(Long activityId, Enum<Constants.ActivityState> currentState);
/**
* 活动执行
*
* @param activityId 活动ID
* @param currentState 当前状态
* @return 执行结果
*/
public abstract Result doing(Long activityId, Enum<Constants.ActivityState> currentState);
}
Openstate
/**
* @author Lobox
* @description: 活动开启状态
* @date 2023/8/3 15:49
*/
@Component
public class OpenState extends AbstractState {
@Override
public Result arraignment(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动开启不可提审");
}
@Override
public Result checkPass(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动开启不可审核通过");
}
@Override
public Result checkRefuse(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动开启不可审核拒绝");
}
@Override
public Result checkRevoke(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动开启不可撤销审核");
}
@Override
public Result close(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.CLOSE);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动关闭完成") : Result.buildErrorResult("活动状态变更失败");
}
@Override
public Result open(Long activityId, Enum<Constants.ActivityState> currentState) {
return Result.buildResult(Constants.ResponseCode.UN_ERROR, "活动不可重复开启");
}
@Override
public Result doing(Long activityId, Enum<Constants.ActivityState> currentState) {
boolean isSuccess = activityRepository.alterStatus(activityId, currentState, Constants.ActivityState.DOING);
return isSuccess ? Result.buildResult(Constants.ResponseCode.SUCCESS, "活动变更活动中完成") : Result.buildErrorResult("活动状态变更失败");
}
}
雪花算法
解决分布式、微服务、分库分表的数据库字段id问题，雪花算法可生成系统内的唯一id
组成
共有64位
雪花算法就是使用64位long类型的数据存储id，最高位一位存储0或者1,0代表整数，1代表负数，一般都是0，所以最高位不变，41位存储毫秒级时间戳，10位存储机器码（包括5位datacenterId和5位workerId），12存储序列号（同一时间戳内同一机器所生成的id序列号将递增）。这样最大2的10次方的机器，也就是1024台机器，最多每毫秒每台机器产生2的12次方也就是4096个id。
组合模式实现决策树
组合模式是一种结构型设计模式， 可以使用它将对象组合成树状结构， 并且能像使用独立对象一样使用它们。
在本项目中使用组合模式实现决策树，将不同类型的用户分流到不同的活动中去，以性别和年龄作为决策因子
代码实现与流程
结构
logic包即用于存放不同类型的决策节点，所有决策节点均实现自BaseLogic
BaseLogic中主要实现了节点的决策过程,进行决策，并给出决策树中的下一个决策节点
BaseLogic
public abstract class BaseLogic implements LogicFilter{
/**
* 遍历判定，当前传入的决策值是否满足某条茎的条件
* @param matterValue 决策值
* @param treeNodeLineInfoList 决策节点
* @return 满足条件的茎的to指向
*/
@Override
public Long filter(String matterValue, List<TreeNodeLineVO> treeNodeLineInfoList) {
for (TreeNodeLineVO nodeLine : treeNodeLineInfoList) {
if (decisionLogic(matterValue,nodeLine)) {
return nodeLine.getNodeIdTo();
}
}
return Constants.Global.TREE_NULL_NODE;
}
@Override
public abstract String matterValue(DecisionMatterReq decisionMatter);
private boolean decisionLogic(String matterValue,TreeNodeLineVO nodeLine) {
switch (nodeLine.getRuleLimitType()) {
case Constants.RuleLimitType.EQUAL:
return matterValue.equals(nodeLine.getRuleLimitValue());
case Constants.RuleLimitType.GT:
return Double.parseDouble(matterValue) > Double.parseDouble(nodeLine.getRuleLimitValue());
case Constants.RuleLimitType.LT:
return Double.parseDouble(matterValue) < Double.parseDouble(nodeLine.getRuleLimitValue());
case Constants.RuleLimitType.GE:
return Double.parseDouble(matterValue) >= Double.parseDouble(nodeLine.getRuleLimitValue());
case Constants.RuleLimitType.LE:
return Double.parseDouble(matterValue) <= Double.parseDouble(nodeLine.getRuleLimitValue());
default:
return false;
}
}
}
RuleEngineHandle用于抽取数据库中存储的决策树，根据决策树中节点的关联信息(NodeLine指向)进行逐个调用对应的决策逻辑进行决策，大概流程：由树根节点开始，获取树根节点的对应决策器，调用决策期的filter方法进行决策，取得NodeLine指向的下一个决策器，反复进行，直到结果为果实节点，即获得了最终的决策结果
EngineBase
public class EngineBase extends EngineConfig implements EngineFilter{
private Logger logger = LoggerFactory.getLogger(EngineBase.class);
@Override
public EngineResult process(DecisionMatterReq matter) {
throw new RuntimeException("未实现规则引擎服务");
}
/**
* 返回决策树决策后的最终果实节点
* @param treeRuleRich 决策树信息
* @param matter 决策请求，包含用于决策的决策值
* @return 决策树决策后的最终果实节点
*/
protected TreeNodeVO engineDecisionMaker(TreeRuleRich treeRuleRich, DecisionMatterReq matter) {
TreeRootVO treeRoot = treeRuleRich.getTreeRoot();
// 获取该决策树下的所有节点，节点内部并没有直接存储与其它节点的父子关系，而是通过茎NodeLine存储父子信息
Map<Long, TreeNodeVO> treeNodeMap = treeRuleRich.getTreeNodeMap();
// 规则树根ID
Long rootNodeId = treeRoot.getTreeRootNodeId();
TreeNodeVO treeNodeInfo = treeNodeMap.get(rootNodeId);
// 节点类型[NoneType]; 1子叶 2果实
while (Constants.NodeType.STEM.equals(treeNodeInfo.getNodeType())) {
// 根据节点的决策类型获取对应的决策器
String ruleKey = treeNodeInfo.getRuleKey();
LogicFilter logicFilter = logicFilterMap.get(ruleKey);
// 根据决策器类型从决策请求中取出对应的决策值
String matterValue = logicFilter.matterValue(matter);
// 获取下一个决策节点
Long nextNode = logicFilter.filter(matterValue, treeNodeInfo.getTreeNodeLineInfoList());
treeNodeInfo = treeNodeMap.get(nextNode);
logger.info("决策树引擎=>{} userId：{} treeId：{} treeNode：{} ruleKey：{} matterValue：{}", treeRoot.getTreeName(), matter.getUserId(), matter.getTreeId(), treeNodeInfo.getTreeNodeId(), ruleKey, matterValue);
}
return treeNodeInfo;
}
}
RuleEngineHandle
@Service("ruleEngineHandle")
public class RuleEngineHandle extends EngineBase {
@Resource
private IRuleRepository ruleRepository;
@Override
public EngineResult process(DecisionMatterReq matter) {
// 获取决策规则树
TreeRuleRich treeRuleRich = ruleRepository.queryTreeRuleRich(matter.getTreeId());
if (null == treeRuleRich) {
throw new RuntimeException("Tree Rule is null!");
}
// 获取最终果实节点
TreeNodeVO treeNodeInfo = engineDecisionMaker(treeRuleRich, matter);
// 决策结果
return new EngineResult(matter.getUserId(), treeNodeInfo.getTreeId(), treeNodeInfo.getTreeNodeId(), treeNodeInfo.getNodeValue());
}
}
redis滑动库存分布式锁
使用redis的setNX可以实现分布式锁，当setNX传入一个数据库中不存在的key时，将返回操作成功，否则失败
因此分布式服务可以通过争抢key的方式来实现资源争抢，最先成功setNX的线程视为争抢成功
同时本项目通过活动号+库存占用的方式实现粒度更细的锁，若只使用活动号进行加锁，将导致并发失效，即便库存有剩余也无法让后续的用户参与
活动领取流程
活动秒杀流程
库存记录使用递增的方式，即初始状态下库存占用为0，每有一个用户参与，则将库存占用增加1，直到到达库存上限
此后拼接活动号+自增后的库存占用，进行setNX,若后续线程获取到了相同的库存占用值，则争抢失败，提示活动火爆，可重新进行库存占用争抢
活动秒杀成功后将在数据库中插入对应的活动领取信息，并释放对应的锁
库存扣减、占用
@Override
public StockResult subtractionActivityStockByRedis(String uId, Long activityId, Integer stockCount) {
// 1. 获取抽奖活动库存 Key
String stockKey = Constants.RedisKey.KEY_LOTTERY_ACTIVITY_STOCK_COUNT(activityId);
// 2. 扣减库存，目前占用库存数
Integer stockUsedCount = (int) redisUtil.incr(stockKey, 1);
// 3. 超出库存判断，进行恢复原始库存
if (stockUsedCount > stockCount) {
redisUtil.decr(stockKey, 1);
return new StockResult(Constants.ResponseCode.OUT_OF_STOCK.getCode(), Constants.ResponseCode.OUT_OF_STOCK.getInfo());
}
// 4. 以活动库存占用编号，生成对应加锁Key，细化锁的颗粒度
String stockTokenKey = Constants.RedisKey.KEY_LOTTERY_ACTIVITY_STOCK_COUNT_TOKEN(activityId, stockUsedCount);
// 5. 使用 Redis.setNx 加一个分布式锁
boolean lockToken = redisUtil.setNx(stockTokenKey, 350L);
if (!lockToken) {
logger.info("抽奖活动{}用户秒杀{}扣减库存，分布式锁失败：{}", activityId, uId, stockTokenKey);
return new StockResult(Constants.ResponseCode.ERR_TOKEN.getCode(), Constants.ResponseCode.ERR_TOKEN.getInfo());
}
return new StockResult(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo(), stockTokenKey, stockCount - stockUsedCount);
}
具体活动参与流程
@Override
public PartakeResult doPartake(PartakeReq req) {
// 1. 查询是否存在未执行抽奖领取活动单【user_take_activity 存在 state = 0，领取了但抽奖过程失败的，可以直接返回领取结果继续抽奖】
UserTakeActivityVO userTakeActivityVO = this.queryNoConsumedTakeActivityOrder(req.getActivityId(), req.getUId());
if (null != userTakeActivityVO) {
return buildPartakeResult(userTakeActivityVO.getStrategyId(), userTakeActivityVO.getTakeId(), Constants.ResponseCode.NOT_CONSUMED_TAKE);
}
// 2. 查询活动账单
ActivityBillVO activityBillVO = super.queryActivityBill(req);
// 3. 活动信息校验处理【活动库存、状态、日期、个人参与次数】
Result checkResult = this.checkActivityBill(req, activityBillVO);
if (!Constants.ResponseCode.SUCCESS.getCode().equals(checkResult.getCode())) {
return new PartakeResult(checkResult.getCode(), checkResult.getInfo());
}
// 4. 扣减活动库存，通过Redis【活动库存扣减编号，作为锁的Key，缩小颗粒度】 Begin
StockResult subtractionActivityResult = this.subtractionActivityStockByRedis(req.getUId(), req.getActivityId(), activityBillVO.getStockCount());
if (!Constants.ResponseCode.SUCCESS.getCode().equals(subtractionActivityResult.getCode())) {
this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), subtractionActivityResult.getCode());
return new PartakeResult(subtractionActivityResult.getCode(), subtractionActivityResult.getInfo());
}
// 5. 插入领取活动信息【个人用户把活动信息写入到用户表】
Long takeId = idGeneratorMap.get(Constants.Ids.SnowFlake).nextId();
Result grabResult = this.grabActivity(req, activityBillVO, takeId);
if (!Constants.ResponseCode.SUCCESS.getCode().equals(grabResult.getCode())) {
// 插入失败，释放锁
// TODO 恢复库存
this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), subtractionActivityResult.getCode());
return new PartakeResult(grabResult.getCode(), grabResult.getInfo());
}
// 6. 释放锁 End
this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), Constants.ResponseCode.SUCCESS.getCode());
return buildPartakeResult(activityBillVO.getStrategyId(), takeId, activityBillVO.getStockCount(), subtractionActivityResult.getStockSurplusCount(), Constants.ResponseCode.SUCCESS);
}
各层间调用关系
domain领域层细化各个领域功能的实现，infrastructure提供持久层数据支持，例如数据库/redis等，application编排domain层提供的各个service，实现完整的流程编排，interface层负责请求参数的包装，并将请求交付到application，获取执行结果，再将结果转换为VO交付
评论区