一个极简高效的秒杀系统(战术实践篇)

在上一篇《一个极简、高效的秒杀系统（战略设计篇）》中，楼主重点讲解了基于Redis + Lua脚本的秒杀系统设计方案，如果没看过的同学，请花十分钟复习下。在这一篇中，楼主会结合代码，来探讨如何将设计方案落地。

提前剧透，工程源代码地址见楼主GitHub：https://github.com/Heroicai0101/seckill ，可下载到本地对照本篇看。

工程骨架

DDD概述

在看具体代码前，先窥一幅DDD工程骨架图，该图是楼主根据《领域驱动设计：软件核心复杂性应对之道》这本书的示例工程代码（Github地址戳这里[1]）进行绘制的，图中每个框，代表一个包，整个工程代码组织结构就是该图的层次结构。如果对DDD感兴趣，也建议把代码下载下来，后续对照着书本进行阅读。对于新手，推荐先粗略看一遍《领域驱动设计：软件核心复杂性应对之道》了解DDD相关专业术语和概念，再精读几遍《实现领域驱动设计》。

DDD楼主认识有限，这里也不细说，简单概述下DDD的四个层次，从上到下依次是用户界面层（User Interface）、应用层（Application）、领域层（Domain）、基础设施层（Infrastructure）。

• 用户界面层：负责向用户展示信息和解释用户命令。这里的用户是广义概念，既可以是用户界面的使用者，还可以是与当前系统交互的其他应用。
• 应用层：定义系统需要对外提供的能力，应用层通常不包含业务规则，主要是通过编排领域服务来完成能力建设。
• 领域层：提炼并抽象业务概念、业务规则，实现细节在基础设施层。DDD核心思想就是围绕领域对象来建模，故领域层是业务系统的核心。
• 基础设施层：向其他层提供底层技术能力，如消息发送、数据库持久化等。基础设施层也不包含业务规则，可简单理解为对数据进行存/取的资源库。

这四个层次调用关系如下图（红色箭头代表调用方向）：可以看出用户界面层权力比较大，可以直接调用应用层、领域层、基础设施层；应用层可以调用领域层和基础设施层。

工程结构

有了上面各层整体认识后，再对照看下我们这个秒杀工程结构就容易理解了，结构基本是一样的！急不可耐的同学，如果想快速run起来的话，强烈建议参照楼主GitHub项目的README文档来起飞！

源码解读

在《一个极简高效的秒杀系统（战略设计篇）》这篇E-R图中提到了几个重要的领域模型：活动、活动准入规则、活动商品。既然DDD是围绕领域对象来建模的，所以在系统实现上，首要任务就是建立领域对象，并围绕领域对象来建模。So，我们先从领域层开始吧！

领域层

领域模型

1、活动

活动对象的设计比较简单：

• 活动对象的属性包含：活动id、活动名称、活动开始/结束时间、活动是否启用状态，以及一个活动规则列表；
• 活动对象的方法有三个：判断活动是否进行中onSale()、启用/禁用活动enableActivity() 以及判断当前请求是否符合活动准入条件canPass()；这三个方法，其实就是活动这个领域对象应该具备的业务知识，只有活动对象才拥有完备的知识知道如何判断活动是否进行中、怎么启用/禁用活动、以及请求是否符合活动准入条件。假如这些业务逻辑按我们通常写法，把方法丢到某些Service对象中，就会出现本该由领域对象管理的业务逻辑散落到系统各处，造成只有属性没有方法的贫血模型。

1. /**
2. * 活动信息
3. */
4. @Data
5. public class Activity {
6. 
   
7. /** 活动id */
8. private ActivityId activityId;
9. 
   
10. /** 活动名称 */
11. private String activityName;
12. 
    
13. /** 活动开始时间 */
14. private Long startTime;
15. 
    
16. /** 活动结束时间 */
17. private Long endTime;
18. 
    
19. /** 活动是否启用 */
20. private boolean enabled;
21. 
    
22. /** 活动准入规则 */
23. private List<ActivityRule> activityRules;
24. 
    
25. /**
26. * 活动进行中
27. */
28. public boolean onSale(Long orderTime) {
29. return enabled && (orderTime >= startTime && orderTime < endTime);
30. }
31. 
    
32. /**
33. * 启用/禁用活动
34. */
35. public void enableActivity(boolean enabled) {
36. this.enabled = enabled;
37. }
38. 
    
39. /**
40. * 活动准入规则校验
41. * 1、活动未配置规则，则无需校验
42. * 2、活动若配置了规则，则逐一进行校验
43. */
44. public ActivityRuleCheckResult canPass(ActivityAccessContext context) {
45. if (CollectionUtils.isEmpty(activityRules)) {
46. return ActivityRuleCheckResult.ok();
47. }
48. 
    
49. Assert.notNull(context, "活动准入条件为空");
50. for (ActivityRule activityRule : activityRules) {
51. ActivityRuleCheckResult result = activityRule.satisfy(context);
52. if (!result.isPass()) {
53. return result;
54. }
55. }
56. return ActivityRuleCheckResult.ok();
57. }
58. 
    
59. }

2、活动商品

商品本身依附于活动对象，没什么业务方法，持有商品id、商品标题、图片链接、原价、活动价、活动库存、限购数量等属性；值得注意的是，E-R图上我们看到活动跟商品有联系，但在Activity这个对象一点都没体现出来。在这里，我们看到是通过ActivityItem持有活动id来建立二者联系的。

1. /**
2. * 活动商品
3. */
4. @Data
5. public class ActivityItem {
6. 
   
7. /** 商品id */
8. private ItemId itemId;
9. 
   
10. /** 活动id */
11. private ActivityId activityId;
12. 
    
13. /** 商品标题 */
14. private String itemTitle;
15. 
    
16. /** 商品副标题 */
17. private String subTitle;
18. 
    
19. /** 商品图片链接 */
20. private String itemImage;
21. 
    
22. /** 商品原价 */
23. private Long itemPrice;
24. 
    
25. /** 商品活动价 */
26. private Long activityPrice;
27. 
    
28. /** 每人限购件数 */
29. private Integer quota;
30. 
    
31. /** 商品活动库存 */
32. private Integer stock;
33. 
    
34. }

3、库存扣减流水

库存扣减流水：记录在哪个活动（activityId）、哪个用户（buyerId）、在何时下了哪笔订单、拍下哪个商品多少个（orderInfo）；扣库存、回库存操作强依赖这一对象。

1. /**
2. * 库存扣减流水：记录在哪个活动（activityId）、哪个用户（buyerId）、在何时下了哪笔订单、拍下哪个商品多少个（orderInfo）
3. */
4. @Builder
5. @Data
6. @NoArgsConstructor
7. @AllArgsConstructor
8. public class StockReduceFlow {
9. 
   
10. /** 活动id */
11. private ActivityId activityId;
12. 
    
13. /** 买家id */
14. private BuyerId buyerId;
15. 
    
16. /** 订单信息 */
17. private OrderInfo orderInfo;
18. 
    
19. }

4、仓储

看到这里，可能会纳闷，上面这些领域对象都怎么构建出来的，它们存在哪里？这就不得不提到仓储（Repository）这个概念。在DDD理念里，仓储负责领域对象的存储，但仓储本身并没规定存储介质。也就是说仓储只负责定义领域对象的读/写协议，至于具体用内存、MySQL还是Oracle，它不关心。在《领域驱动设计：软件核心复杂性应对之道》中提到，一般只对聚合根建立仓储，但在我们秒杀系统中，活动对象Activity可算一个聚合根，至于活动商品、商品销量其实都不是聚合根，但楼主还是为这几个对象定义了仓储。实在是仓储这个概念的度拿捏不好，没办法严格照搬书上的做法。如果大家有独到的见解，欢迎和楼主交流！

活动仓储（ActivityRepository）：查活动、保存活动。

1. /**
2. * 活动
3. */
4. public interface ActivityRepository {
5. 
   
6. /**
7. * 查活动列表
8. */
9. List<Activity> listActivity();
10. 
    
11. /**
12. * 查单个活动
13. */
14. Activity findActivity(ActivityId activityId);
15. 
    
16. /**
17. * 保存活动
18. */
19. void saveActivity(Activity activity);
20. 
    
21. }

活动商品仓储（ActivityItemRepository）：查商品、保存商品。

1. /**
2. * 活动商品
3. */
4. public interface ActivityItemRepository {
5. 
   
6. /**
7. * 保存指定活动的商品配置
8. */
9. void saveActivityItem(ActivityId activityId, List<ActivityItem> activityItems);
10. 
    
11. /**
12. * 查指定活动的指定商品
13. */
14. Optional<ActivityItem> findActivityItem(ActivityId activityId, ItemId itemId);
15. 
    
16. /**
17. * 查活动商品(缺商品销量)
18. */
19. List<ActivityItem> queryActivityItems(ActivityId activityId);
20. 
    
21. }

库存扣减流水仓储（StockReduceFlowRepository）：查库存扣减流水。

1. /**
2. * 库存扣减流水
3. */
4. public interface StockReduceFlowRepository {
5. 
   
6. Optional<StockReduceFlow> queryStockReduceFlow(ActivityId activityId, OrderId orderId);
7. 
   
8. }

商品销量仓储（ItemSalesRepository）：查单个、全部商品销量。

1. /**
2. * 商品销量
3. */
4. public interface ItemSalesRepository {
5. 
   
6. /**
7. * 查活动全部商品销量
8. */
9. Map<Long, Integer> queryActivityItemSales(ActivityId activityId);
10. 
    
11. /**
12. * 查商品指定活动的销量
13. */
14. ItemSales queryItemSales(ActivityId activityId, ItemId itemId);
15. 
    
16. }

领域服务

1、活动配置

完整的活动配置操作，涉及活动及活动商品多个领域对象，并且还需要进行数据持久化。这些职责显然不能放在单个活动或者活动商品对象上，这时我们就需要提炼出一个领域服务。ActivityService这个领域服务就是用来完成活动、活动商品配置，以及活动启用/禁用能力的。

1. public interface ActivityService {
2. 
   
3. /**
4. * 配置活动及活动商品
5. */
6. void saveActivity(Activity activity, List<ActivityItem> activityItems);
7. 
   
8. /**
9. * 启用/禁用活动
10. */
11. void enableActivity(ActivityId activityId, boolean enabled);
12. 
    
13. }

2、库存扣减

秒杀系统的核心就是正确执行库存扣减，这里定义了库存扣减服务的两大核心方法：扣库存reduce()、cancelReduce()。

扣库存：入参为库存扣减流水，通过流水信息知道扣哪个活动ActivityId哪个用户BuyerId抢购资格，以及订单上的信息(商品id、购买数量、订单id、下单时间)指导扣哪个商品的活动库存；

回库存：入参为库存扣减流水，通过流水信息知道具体怎么把商品活动库存、用户抢购资格给加回去；本质就是扣库存的逆向操作。

1. /**
2. * 库存扣减服务
3. */
4. public interface StockReduceService {
5. 
   
6. /**
7. * 扣库存(同步调用)
8. */
9. StockReduceResult reduce(StockReduceFlow flow);
10. 
    
11. /**
12. * 回库存
13. */
14. StockReduceResult cancelReduce(StockReduceFlow flow);
15. 
    
16. }

小结

这一章，我们完成了领域对象的定义，并赋予了领域对象部分方法用来封装相应的职责；定义了两个领域服务：1、通过ActivityService，可以做到配置活动、启用/禁用活动；2、通过StockReduceService，可以做到扣库存、回库存；至此，秒杀系统的两大核心业务流程: 「创建秒杀活动」(配活动、配商品)、「参与秒杀活动」(扣库存、回库存）的实现骨架已搭建起来！

应用层

活动应用服务

在DDD四层概念中，提到过应用层就是定义系统需要对外提供的能力。说白了，就是近似定义对外提供的接口集合。对照之前的设计方案，系统需要具备的接口有：配置活动、启用/禁用活动、查看活动列表、查看活动详情、查看活动商品详情。

按图索骥，毫不费力就推导出如下应用服务接口定义：其中配置活动、启用/禁用活动的业务逻辑，可直接借用活动领域服务ActivityService能力；剩下的几个纯粹查询（查看活动列表、查看活动详情、查看活动商品详情）属于「查看秒杀活动」业务流程，没啥业务规则，通过直接调用仓储的数据读取能力就能搞定。

接口定义：

1. public interface ActivityAppService {
2. 
   
3. /**
4. * 配置活动及商品列表
5. */
6. Long saveActivity(SaveActivityCommand command);
7. 
   
8. /**
9. * 启用/禁用活动
10. */
11. void changeActivityStatus(UpdateActivityStatusCommand command);
12. 
    
13. /**
14. * 活动列表
15. */
16. List<ActivityDTO> activityList();
17. 
    
18. /**
19. * 活动详情页(透出活动商品及商品销量)
20. */
21. ActivityDetailDTO activityDetail(Long activityId);
22. 
    
23. /**
24. * 活动商品详情
25. */
26. ActivityItemDetailDTO activityItemDetail(ActivityId activityId, ItemId itemId);
27. 
    
28. }

接口实现：

1. @Service
2. public class ActivityAppServiceImpl implements ActivityAppService {
3. 
   
4. @Resource
5. private ActivityRepository activityRepository;
6. 
   
7. @Resource
8. private ActivityItemRepository activityItemRepository;
9. 
   
10. @Resource
11. private ItemSalesRepository itemSalesRepository;
12. 
    
13. @Resource
14. private ActivityAssembler activityAssembler;
15. 
    
16. @Resource
17. private ActivityService activityService;
18. 
    
19. /**
20. * 配置活动及商品列表
21. */
22. @Override
23. public Long saveActivity(SaveActivityCommand command) {
24. // 活动
25. Activity activity = activityAssembler.assembleActivity(command);
26. 
    
27. // 活动商品
28. ActivityId activityId = activity.getActivityId();
29. List<ActivityItem> activityItems = activityAssembler.assembleActivityItem(activityId, command);
30. 
    
31. activityService.saveActivity(activity, activityItems);
32. return activityId.getId();
33. }
34. 
    
35. /**
36. * 启用/禁用活动
37. */
38. @Override
39. public void changeActivityStatus(UpdateActivityStatusCommand command) {
40. ActivityId activityId = new ActivityId(command.getActivityId());
41. activityService.enableActivity(activityId, command.isEnabled());
42. }
43. 
    
44. /**
45. * 活动列表
46. */
47. @Override
48. public List<ActivityDTO> activityList() {
49. List<Activity> activityList = activityRepository.listActivity();
50. return activityList.stream()
51. .map(act -> activityAssembler.asActivityDTO(act))
52. .collect(Collectors.toList());
53. }
54. 
    
55. /**
56. * 活动详情页(透出活动商品及商品销量)
57. */
58. @Override
59. public ActivityDetailDTO activityDetail(Long activityId) {
60. // 活动信息
61. ActivityId aid = new ActivityId(activityId);
62. Activity act = activityRepository.findActivity(aid);
63. Assert.notNull(act, "活动不存在:activityId=" + activityId);
64. 
    
65. // 活动商品
66. List<ActivityItem> activityItems = activityItemRepository.queryActivityItems(aid);
67. 
    
68. // 商品销量
69. Map<Long, Integer> itemId2Sales = itemSalesRepository.queryActivityItemSales(aid);
70. 
    
71. List<ActivityItemDTO> itemDTOList = activityItems.stream().map(item -> {
72. int itemSales = itemId2Sales.getOrDefault(item.getItemId().getId(), 0);
73. return activityAssembler.assembleActivityItemDTO(item, itemSales);
74. }).collect(Collectors.toList());
75. 
    
76. return ActivityDetailDTO.builder()
77. .activityId(aid.getId())
78. .activityName(act.getActivityName())
79. .startTime(act.getStartTime())
80. .endTime(act.getEndTime())
81. .enabled(act.isEnabled())
82. .items(itemDTOList)
83. .build();
84. }
85. 
    
86. /**
87. * 活动商品详情
88. */
89. @Override
90. public ActivityItemDetailDTO activityItemDetail(ActivityId activityId, ItemId itemId) {
91. // 活动商品
92. Optional<ActivityItem> optItem = activityItemRepository.findActivityItem(activityId, itemId);
93. Assert.isTrue(optItem.isPresent(), "商品不存在:itemId=" + itemId.getId());
94. ActivityItem item = optItem.get();
95. 
    
96. // 商品销量
97. ItemSales itemSales = itemSalesRepository.queryItemSales(activityId, itemId);
98. 
    
99. // 活动信息
100. Activity act = activityRepository.findActivity(activityId);
101. Assert.notNull(act, "活动不存在:activityId=" + activityId.getId());
102. 
     
103. ActivityDTO activityDTO = ActivityDTO.builder()
104. .activityId(act.getActivityId().getId())
105. .activityName(act.getActivityName())
106. .startTime(act.getStartTime())
107. .endTime(act.getEndTime())
108. .enabled(act.isEnabled())
109. .build();
110. 
     
111. return ActivityItemDetailDTO.builder()
112. .itemId(item.getItemId().getId())
113. .itemTitle(item.getItemTitle())
114. .subTitle(item.getSubTitle())
115. .itemImage(item.getItemImage())
116. .itemPrice(item.getItemPrice())
117. .activityPrice(item.getActivityPrice())
118. .quota(item.getQuota())
119. .stock(item.getStock())
120. .sold(itemSales.getSold())
121. .activity(activityDTO)
122. .build();
123. }
124. 
     
125. }

说明：

• 应用服务直接持有领域服务ActivityService和多个仓储对象（如: ActivityRepository、ActivityItemRepository、ItemSalesRepository）；
• 配置活动、启用/禁用活动：直接交给领域服务来完成；
• 查活动列表、活动详情、活动商品详情：直接利用仓储对象读取数据，并进行数据整合；不需要领域服务参与。

库存应用服务

参与秒杀活动对外暴露的能力就是扣库存、回库存，这个应该没什么疑问。

同上，应用层我们面向交易系统提供两个API，来定义库存扣减交互协议；其中库存扣减这一核心能力，前面我们在领域服务已进行了封装。故库存扣减这个应用服务的业务逻辑也应该非常薄！

接口定义：

1. /**
2. * 库存扣减应用服务
3. */
4. public interface StockAppService {
5. 
   
6. /**
7. * 扣库存
8. */
9. StockReduceResult reduce(ReduceCommand command);
10. 
    
11. /**
12. * 回库存
13. */
14. StockReduceResult cancelReduce(CancelReduceCommand command);
15. 
    
16. }

接口实现：

1. /**
2. * 库存扣减应用服务
3. */
4. @Service
5. public class StockAppServiceImpl implements StockAppService {
6. 
   
7. @Resource
8. private ActivityRepository activityRepository;
9. 
   
10. @Resource
11. private StockReduceFlowRepository stockReduceFlowRepository;
12. 
    
13. @Resource
14. private StockReduceFlowAssembler stockReduceFlowAssembler;
15. 
    
16. @Resource
17. private StockReduceService stockReduceService;
18. 
    
19. /**
20. * 扣库存
21. */
22. @Override
23. public StockReduceResult reduce(@NonNull ReduceCommand command) {
24. ActivityId activityId = new ActivityId(command.getActivityId());
25. StockReduceFlow reduceFlow = stockReduceFlowAssembler.assembleStockReduceFlow(command);
26. 
    
27. // 前置校验：活动是否存在
28. Activity activity = activityRepository.findActivity(activityId);
29. if (Objects.isNull(activity)) {
30. return StockReduceResult.error(BizStatusCode.ACTIVITY_NOT_EXISTS, activityId.getId());
31. }
32. 
    
33. // 前置校验：活动是否进行中
34. OrderInfo orderInfo = reduceFlow.getOrderInfo();
35. if (!activity.onSale(orderInfo.getOrderTime())) {
36. return StockReduceResult.error(BizStatusCode.ACTIVITY_OFFLINE, activityId.getId());
37. }
38. 
    
39. // 活动准入规则校验
40. ActivityAccessContext accessContext = stockReduceFlowAssembler.assembleActivityAccessContext(command);
41. ActivityRuleCheckResult activityRuleCheckResult = activity.canPass(accessContext);
42. if (!activityRuleCheckResult.isPass()) {
43. return StockReduceResult.error(activityRuleCheckResult.getErrmsg());
44. }
45. 
    
46. // 扣库存
47. return stockReduceService.reduce(reduceFlow);
48. }
49. 
    
50. /**
51. * 回库存
52. */
53. @Override
54. public StockReduceResult cancelReduce(@NonNull CancelReduceCommand command) {
55. ActivityId activityId = new ActivityId(command.getActivityId());
56. OrderId orderId = new OrderId(command.getOrderId());
57. 
    
58. Optional<StockReduceFlow> optFlow = stockReduceFlowRepository.queryStockReduceFlow(activityId, orderId);
59. if (optFlow.isPresent()) {
60. StockReduceFlow reduceFlow = optFlow.get();
61. return stockReduceService.cancelReduce(reduceFlow);
62. }
63. return StockReduceResult.ok();
64. }
65. 
    
66. }

说明：

• 扣库存：在调用库存扣减领域服务之前，还做了一些前置校验工作，比如校验活动是否存在、活动是否进行中、以及当前请求是否符合活动准入规则；
• 回库存：通过活动id和订单id，得到库存扣减流水，然后直接调用库存扣减领域服务进行回库存操作。

小结

这一章，我们完成了两个应用服务的定义：1、通过ActivityAppService，我们完成了面向用户（买家、运营）的查看秒杀活动、配置秒杀活动的接口定义；2、通过StockAppService，完成了面向用户（交易系统）的扣库存、回库存接口定义。至此，配置秒杀活动、查看秒杀活动、参与秒杀活动三大业务流程，所需的接口能力都已定义清楚。

用户界面层

用户界面层的职责就是向用户展示信息（读请求），以及将用户的命令（写请求）传递到应用层、领域层甚至基础设施层（比如直接写数据库）。这一层毫无业务逻辑可言。搞笑点说，就是面向视觉稿编程，用户需要什么就给什么。有了应用服务的接口定义，用户界面层也不费神，通常就是直接利用应用服务的能力！

活动接口：

1. @Api(value = "活动接口")
2. @RestController
3. @RequestMapping("/api/v1/activity")
4. public class ActivityController {
5. 
   
6. @Resource
7. private ActivityAppService activityAppService;
8. 
   
9. @ApiOperation(value = "配置活动")
10. @PostMapping("/save")
11. public Response<Long> saveActivity(@RequestBody SaveActivityCommand command) {
12. Long activityId = activityAppService.saveActivity(command);
13. return ResponseBuilder.ok(activityId);
14. }
15. 
    
16. @ApiOperation(value = "启用/禁用活动")
17. @PostMapping("/changeStatus")
18. public Response<Void> changeActivityStatus(@RequestBody UpdateActivityStatusCommand command) {
19. activityAppService.changeActivityStatus(command);
20. return ResponseBuilder.ok();
21. }
22. 
    
23. @ApiOperation(value = "活动列表")
24. @GetMapping("/list")
25. public Response<List<ActivityDTO>> activityList() {
26. List<ActivityDTO> dto = activityAppService.activityList();
27. return ResponseBuilder.ok(dto);
28. }
29. 
    
30. @ApiOperation(value = "活动详情（透出活动商品及商品销量）")
31. @GetMapping("/detail")
32. public Response<ActivityDetailDTO> activityDetail(
33. @ApiParam(value = "activityId", defaultValue = "1") @RequestParam("activityId") Long activityId) {
34. ActivityDetailDTO activityDetailDTO = activityAppService.activityDetail(activityId);
35. return ResponseBuilder.ok(activityDetailDTO);
36. }
37. 
    
38. @ApiOperation(value = "活动商品详情（透出商品销量）")
39. @GetMapping("/itemDetail")
40. public Response<ActivityItemDetailDTO> activityItemDetail(
41. @ApiParam(value = "activityId", defaultValue = "1") @RequestParam("activityId") Long activityId,
42. @ApiParam(value = "itemId", defaultValue = "53724") @RequestParam("itemId") Long itemId) {
43. ActivityId curActivityId = new ActivityId(activityId);
44. ItemId curItemId = new ItemId(itemId);
45. 
    
46. ActivityItemDetailDTO activityDetailDTO = activityAppService.activityItemDetail(curActivityId, curItemId);
47. return ResponseBuilder.ok(activityDetailDTO);
48. }
49. 
    
50. }

库存扣减接口：

1. @Api(value = "库存扣减接口")
2. @RestController
3. @RequestMapping("/api/v1/stock")
4. public class StockController {
5. 
   
6. @Resource
7. private StockAppService stockAppService;
8. 
   
9. @ApiOperation(value = "减库存")
10. @PostMapping("/reduce")
11. public Response<StockReduceResult> tryReduce(@RequestBody ReduceCommand command) {
12. StockReduceResult res = stockAppService.reduce(command);
13. return ResponseBuilder.ok(res);
14. }
15. 
    
16. @ApiOperation(value = "回库存")
17. @PostMapping("/cancelReduce")
18. public Response<StockReduceResult> cancelReduce(@RequestBody CancelReduceCommand command) {
19. StockReduceResult res = stockAppService.cancelReduce(command);
20. return ResponseBuilder.ok(res);
21. }
22. 
    
23. }

如果熟悉swagger-ui使用方式，启动工程访问http://localhost:8080/swagger-ui.html，就会看到如下界面：

基础设施层

前面噼里啪啦一大堆，看到的大多是接口定义，好奇宝宝们还是想知道到底怎样做库存扣减的，接下来我们就讲讲库存扣减的实现。在领域层我们定义了领域服务，但仅仅只是一个接口，领域服务的实现是在基础设施层。本文的基调就是Redis+Lua脚本实现秒杀，库存扣减服务的实现StockReduceServiceImpl就是完全依赖Lua脚本。

领域服务实现

库存扣减领域服务实现类StockReduceServiceImpl：

1. @Slf4j
2. @Service
3. public class StockReduceServiceImpl implements StockReduceService {
4. 
   
5. @Resource
6. private Gson gson;
7. 
   
8. @Resource
9. private RedissonClient redissonClient;
10. 
    
11. private String reduceLua;
12. 
    
13. private String cancelReduceLua;
14. 
    
15. @PostConstruct
16. public void scriptLoading() {
17. try {
18. reduceLua = LuaScriptHelper.readScript(LuaScriptConstant.Seckill.REDUCE_LUA);
19. cancelReduceLua = LuaScriptHelper.readScript(LuaScriptConstant.Seckill.CANCEL_REDUCE_LUA);
20. } catch (IOException ioe) {
21. throw new IllegalStateException("Script not found!", ioe);
22. }
23. }
24. 
    
25. /**
26. * 执行Lua脚本扣库存
27. */
28. @Override
29. public StockReduceResult reduce(StockReduceFlow flow) {
30. Long activityId = flow.getActivityId().getId();
31. Long itemId = flow.getOrderInfo().getItemId().getId();
32. 
    
33. /* KEYS[1] 库存扣减流水，KEYS[2] 活动商品，KEYS[3] 买家已购，KEYS[4] 商品销量 */
34. String stockReduceFlowHash = SeckillNamespace.stockReduceFlowHash(activityId);
35. String activityItemHash = SeckillNamespace.activityItemsHash(activityId);
36. String buyerHoldHash = SeckillNamespace.buyerHoldHash(activityId, itemId);
37. String itemSalesHash = SeckillNamespace.itemSalesHash(activityId);
38. List<Object> keys = Lists.newArrayList(stockReduceFlowHash, activityItemHash, buyerHoldHash, itemSalesHash);
39. 
    
40. /* ARGV[1] 订单id，ARGV[2] 买家id，ARGV[3] 商品id，ARGV[4] 抢购数量，ARGV[5] json化库存扣减流水 */
41. StockReduceFlowDO reduceFlowDO = StockReduceFlowConverter.toDO(flow);
42. String reduceFlowJson = gson.toJson(reduceFlowDO);
43. Object[] values = {
44. reduceFlowDO.getOrderId(),
45. reduceFlowDO.getBuyerId(),
46. reduceFlowDO.getItemId(),
47. reduceFlowDO.getQuantity(),
48. reduceFlowJson
49. };
50. 
    
51. // 执行减库存Lua脚本
52. String resultCode = LuaScriptHelper.create(redissonClient)
53. .evalLuaScript(keys, values, reduceLua);
54. 
    
55. if (!LuaResultDictionary.SUCCESS_RESULT.equals(resultCode)) {
56. Status status = LuaResultDictionary.mapping(resultCode);
57. String errmsg = status.getMsg(reduceFlowDO.getOrderId());
58. log.error("reduce_exception||reduceFlow={}||errmsg={}", reduceFlowJson, errmsg);
59. return StockReduceResult.error(errmsg);
60. }
61. 
    
62. log.info("reduce_success||reduceFlow={}", reduceFlowJson);
63. return StockReduceResult.ok();
64. }
65. 
    
66. /**
67. * 执行Lua脚本回库存
68. */
69. @Override
70. public StockReduceResult cancelReduce(StockReduceFlow stockReduceFlow) {
71. ActivityId activityId = stockReduceFlow.getActivityId();
72. OrderInfo orderInfo = stockReduceFlow.getOrderInfo();
73. OrderId orderId = orderInfo.getOrderId();
74. ItemId itemId = orderInfo.getItemId();
75. 
    
76. Long aid = activityId.getId();
77. String stockReduceFlowHash = SeckillNamespace.stockReduceFlowHash(aid);
78. String buyerHoldHash = SeckillNamespace.buyerHoldHash(aid, itemId.getId());
79. String itemSalesHash = SeckillNamespace.itemSalesHash(aid);
80. 
    
81. /* KEYS[1] 库存扣减流水，KEYS[2] 买家已购，KEYS[3] 商品销量 */
82. List<Object> keys = Lists.newArrayList(stockReduceFlowHash, buyerHoldHash, itemSalesHash);
83. 
    
84. /* ARGV[1] 订单id */
85. Object[] values = {orderId.getId()};
86. 
    
87. // 执行回库存Lua脚本
88. String resultCode = LuaScriptHelper.create(redissonClient)
89. .evalLuaScript(keys, values, cancelReduceLua);
90. 
    
91. if (!LuaResultDictionary.SUCCESS_RESULT.equals(resultCode)) {
92. Status status = LuaResultDictionary.mapping(resultCode);
93. String errmsg = status.getMsg(orderId.getId());
94. log.error("cancel_reduce_exception||activityId={}||orderId={}||itemId={}||errmsg={}",
95. aid, orderId.getId(), itemId.getId(), errmsg);
96. 
    
97. return StockReduceResult.error(errmsg);
98. }
99. 
    
100. log.info("cancel_reduce_success||activityId={}||orderId={}||itemId={}", aid, orderId.getId(), itemId.getId());
101. return StockReduceResult.ok();
102. }
103. 
     
104. }

StockReduceServiceImpl唯一有意义的事就是在启动时加载Lua脚本，剩下干的事就是传参给Lua脚本。所以，真相就在Lua脚本。看看Lua脚本都在干啥？

扣库存Lua脚本：

1、通过校验库存扣减流水是否已存在，来判断是否重复请求；

2、加载商品活动配置，得到商品每人限购数量及活动库存，进而判断用户抢购资格以及商品库存是否充足；

3、真正做扣库存该干的事：记录库存扣减流水、增买家已购计数、增商品销量计数。

1. --[[
2. KEYS[1] 库存扣减流水, KEYS[2] 活动商品, KEYS[3] 买家已购, KEYS[4] 商品销量
3. ARGV[1] 订单id, ARGV[2] 买家id, ARGV[3] 商品id, ARGV[4] 抢购数量, ARGV[5] json化库存扣减流水
4. --]]
5. local orderId = ARGV[1];
6. local buyerId = ARGV[2];
7. local itemId = ARGV[3];
8. 
   
9. -- 防重判断
10. local STOCK_REDUCE_FLOW_HASH = KEYS[1];
11. local flowExists = redis.call("HEXISTS", STOCK_REDUCE_FLOW_HASH, orderId);
12. if flowExists == 1 then
13. return "REPEATED_REQUEST";
14. end
15. 
    
16. -- 校验商品是否参加了活动
17. local ACTIVITY_ITEMS_HASH = KEYS[2];
18. local activityExists = redis.call("HEXISTS", ACTIVITY_ITEMS_HASH, itemId);
19. if activityExists == 0 then
20. return "ITEM_ACTIVITY_ABSENT";
21. end
22. 
    
23. -- 加载活动商品配置
24. local config = redis.call("HGET", ACTIVITY_ITEMS_HASH, itemId);
25. local payload = cjson.decode(config);
26. 
    
27. -- 用户已购数量
28. local BUYER_HOLD_HASH = KEYS[3];
29. local bookedCount = redis.call("HGET", BUYER_HOLD_HASH, buyerId);
30. if bookedCount == false then
31. bookedCount = 0;
32. end
33. if bookedCount + tonumber(ARGV[4]) > tonumber(payload["quota"]) then
34. return "QUOTA_NOT_ENOUGH";
35. end
36. 
    
37. -- 商品累计售出数量
38. local ITEM_SALES_HASH = KEYS[4];
39. local soldCount = redis.call("HGET", ITEM_SALES_HASH, itemId);
40. if soldCount == false then
41. soldCount = 0;
42. end
43. if soldCount + tonumber(ARGV[4]) > tonumber(payload["stock"]) then
44. return "STOCK_NOT_ENOUGH";
45. end
46. 
    
47. -- 记录库存扣减流水、增买家已购、增商品销量
48. redis.call("HSET", STOCK_REDUCE_FLOW_HASH, orderId, ARGV[5]);
49. redis.call("HINCRBY", BUYER_HOLD_HASH, buyerId, ARGV[4]);
50. redis.call("HINCRBY", ITEM_SALES_HASH, itemId, ARGV[4]);
51. return "OK";

回库存Lua脚本：

1、通过校验库存扣减流水是否已存在，来判断是否重复请求；

2、加载商品库存扣减流水，从流水得到用户需要回滚的已购数量以及商品销量需要回滚的数量；

3、真正做回库存该干的事: 减买家已购计数、减商品销量计数、删除库存扣减计数。

1. --[[
2. KEYS[1] 库存扣减流水, KEYS[2] 活动商品, KEYS[3] 买家已购, KEYS[4] 商品销量
3. ARGV[1] 订单id, ARGV[2] 买家id, ARGV[3] 商品id, ARGV[4] 抢购数量, ARGV[5] json化库存扣减流水
4. --]]
5. local orderId = ARGV[1];
6. local buyerId = ARGV[2];
7. local itemId = ARGV[3];
8. 
   
9. -- 防重判断
10. local STOCK_REDUCE_FLOW_HASH = KEYS[1];
11. local flowExists = redis.call("HEXISTS", STOCK_REDUCE_FLOW_HASH, orderId);
12. if flowExists == 1 then
13. return "REPEATED_REQUEST";
14. end
15. 
    
16. -- 校验商品是否参加了活动
17. local ACTIVITY_ITEMS_HASH = KEYS[2];
18. local activityExists = redis.call("HEXISTS", ACTIVITY_ITEMS_HASH, itemId);
19. if activityExists == 0 then
20. return "ITEM_ACTIVITY_ABSENT";
21. end
22. 
    
23. -- 加载活动商品配置
24. local config = redis.call("HGET", ACTIVITY_ITEMS_HASH, itemId);
25. local payload = cjson.decode(config);
26. 
    
27. -- 用户已购数量
28. local BUYER_HOLD_HASH = KEYS[3];
29. local bookedCount = redis.call("HGET", BUYER_HOLD_HASH, buyerId);
30. if bookedCount == false then
31. bookedCount = 0;
32. end
33. if bookedCount + tonumber(ARGV[4]) > tonumber(payload["quota"]) then
34. return "QUOTA_NOT_ENOUGH";
35. end
36. 
    
37. -- 商品累计售出数量
38. local ITEM_SALES_HASH = KEYS[4];
39. local soldCount = redis.call("HGET", ITEM_SALES_HASH, itemId);
40. if soldCount == false then
41. soldCount = 0;
42. end
43. if soldCount + tonumber(ARGV[4]) > tonumber(payload["stock"]) then
44. return "STOCK_NOT_ENOUGH";
45. end
46. 
    
47. -- 记录库存扣减流水、增买家已购、增商品销量
48. redis.call("HSET", STOCK_REDUCE_FLOW_HASH, orderId, ARGV[5]);
49. redis.call("HINCRBY", BUYER_HOLD_HASH, buyerId, ARGV[4]);
50. redis.call("HINCRBY", ITEM_SALES_HASH, itemId, ARGV[4]);
51. return "OK";

仓库实现

本文的存储介质百分百为Redis，故仓储的实现，完全就是利用Redis的数据结构来做纯CRUD，没有任何业务逻辑和技术含量，故仅以活动仓储ActivityRepositoryImpl来示例。

仓储实现类ActivityRepositoryImpl: 利用的是Redis的Hash结构，活动信息存储在activity_catalog这个Hash结构中：

1. @Repository
2. public class ActivityRepositoryImpl implements ActivityRepository {
3. 
   
4. @Resource
5. private Gson gson;
6. 
   
7. @Resource
8. private RedissonClient redissonClient;
9. 
   
10. /**
11. * 活动列表
12. */
13. @Override
14. public List<Activity> listActivity() {
15. String activityCatalogHash = SeckillNamespace.activityCatalogHash();
16. 
    
17. RMap<String, String> activityMap = redissonClient.getMap(activityCatalogHash);
18. List<ActivityDO> activityList = activityMap.values().stream()
19. .map(activity -> gson.fromJson(activity, ActivityDO.class))
20. .collect(Collectors.toList());
21. return activityList.stream()
22. .map(ActivityConverter::fromDO)
23. .collect(Collectors.toList());
24. }
25. 
    
26. /**
27. * 根据活动id查活动
28. */
29. @Override
30. public Activity findActivity(ActivityId activityId) {
31. String activityCatalogHash = SeckillNamespace.activityCatalogHash();
32. 
    
33. Map<String, String> activityMap = redissonClient.getMap(activityCatalogHash);
34. String activity = activityMap.get(String.valueOf(activityId.getId()));
35. Assert.hasText(activity, "活动不存在:activityId=" + activityId.getId());
36. 
    
37. ActivityDO activityDO = gson.fromJson(activity, ActivityDO.class);
38. return ActivityConverter.fromDO(activityDO);
39. }
40. 
    
41. /**
42. * 保存活动
43. */
44. @Override
45. public void saveActivity(Activity activity) {
46. ActivityId activityId = activity.getActivityId();
47. ActivityDO activityDO = ActivityConverter.toDO(activity);
48. 
    
49. String activityCatalogHash = SeckillNamespace.activityCatalogHash();
50. redissonClient.getMap(activityCatalogHash)
51. .put(String.valueOf(activityId.getId()), gson.toJson(activityDO));
52. }
53. 
    
54. }

总结

本文遵循DDD领域建模思想，从领域层、应用层、用户界面层逐层复原秒杀系统设计方案的落地全过程，并结合源码进行了分析阐述。其实，代码不重要，建模过程中的思想才是最有价值的，希望读者能领略到DDD建模的魅力，并在实际工作中进行运用实践！学习都是从模仿开始，感兴趣的读者可以将《领域驱动设计：软件核心复杂性应对之道》示例代码工程源码或楼主的工程代码码下载下来参考。

其它未讲到的点：

• 活动准入规则：活动规则的实现比较有技巧性，楼主未曾展开讲。挑战点就是如何将一段字符串转换为成Java类，核心代码见com.cgx.marketing.domain.model.activity.rule.ActivityRuleRegistrar 和 com.cgx.marketing.domain.model.activity.rule.BaseActivityRule，看了不后悔！
• 工程里面提供了一个单测模拟1000个用户并发10万次扣库存请求，耗时约32秒，即系统扣库存单机Qps达到3000+；读者可以从单测入手，通过调试逐渐加深对代码的理解。单测代码见com.cgx.marketing.application.activity.StockAppServiceTest；最后再次建议参照楼主Github项目的README文档把工程Run起来，上手更快！