本节从功能入手重点介绍Spring Cloud秒杀实战业务处理的3层实现：dao层、service层、controller层。

秒杀的功能模块和接口设计

秒杀系统的实现有多种多样的版本，本节从方便演示的角度出发设计一个相当简单的秒杀练习版本，具体分为3个主要的模块：

（1）seckill-web模块：此模块是一个独立的Spring Boot程序，作为一个静态的Web服务器独立运行，主要运行秒杀的前端页面、脚本。在生产场景中，为了提高性能，可以将这个模块的所有静态资源全部迁移到Nginx高性能Web服务器。

（2）seckill-provider模块：秒杀的后端Spring Cloud微服务提供者主要运行获取秒杀令牌、秒杀订单等后端相关接口。

（3）uaa-provider模块：用户账号与认证（UAA）的后端SpringCloud微服务提供者主要运行用户认证、用户信息相关的后端接口。

以上3个模块的关系为：seckill-web模块作为静态资源程序会将秒杀的操作页面呈现给用户，seckill-web的页面会根据用户的操作将相应的URL接口，通过Nginx外部网关跳过内部网关Zuul直接发送给后端的uaa-provider和seckill-provider微服务提供者。为什么要跳过Zuul内部网关呢？内部网关需要对请求的URL进行用户权限验证，如果请求没有带token或者没有通过验证，请求就会被拦截并返回未授权的错误。

为了在练习时调试方便，建议直接跳过Zuul内部网关的权限验证功能，通过Nginx的反向代理将请求直接代理到后端的微服务提供者。

在秒杀练习系统中，三个模块的关系如图10-7所示。

图10-7 秒杀练习系统中三个模块的关系

本秒杀练习系统中的秒杀操作流程大致有以下4步：

（1）前端设置秒杀用户。

在用户点击后，seckill-web的前端页面将通过请求uaa-provider服务的/api/user/detail/v1接口获取用户信息。在实际的秒杀场景中这一步是不需要的，因为这一步所获取的用户信息就是当前登录用户本人的信息。

（2）前端设置秒杀商品。

seckill-web的前端页面通过请求seckill-provider服务的
/api/seckill/good/detail/v1接口获取所需要的秒杀商品。而在seckill-provider服务后端会将商品的库存信息缓存到Redis，方便下一步的秒杀令牌的获取。

（3）前端获取秒杀令牌。

seckill-web的前端页面通过请求seckill-provider服务的
/api/seckill/redis/token/v1接口获取商品的秒杀令牌，执行秒杀操作，减少商品的Redis库存。后端接口首先减Redis库存量，如果减库存成功，就生成秒杀专用的令牌存入Redis，在下一步用户下单时拿来进行验证。如果扣减Redis库存失败，就返回对应的错误提示。这一步操作没有涉及数据库，对库存的减少操作直接在Redis中完成，所扣减的并不是真正的商品库存。

（4）前端用户下单。

seckill-web的前端页面通过请求seckill-provider服务的/api/seckill/redis/do/v1接口执行真正的下单操作。后端接口会判断秒杀专用的token令牌是否有效，如果有效，就执行真正的下单操作，在数据库中扣减库存和生成秒杀订单，然后返回给前端。

秒杀练习系统的秒杀业务流程如图10-8所示。

图10-8 秒杀练习系统中的秒杀业务流程

在开发过程中，为了使得来自seckill-web前端页面的请求能够顺利地跳过内部网关Zuul而直接发送给后端的微服务提供者uaa-provider和seckill-provider，这里特意配置了一份专门的Nginx配置文件nginx-seckill.conf，对秒杀练习的三大模块进行定制化的反向代理配置，在启动Nginx的脚本openresty-start.sh文件中使用这份配置文件即可。

配置文件nginx-seckill.conf的核心配置如下：

server {
 listen 80 default;
 server_name nginx.server *.nginx.server;
 default_type 'text/html';
 charset utf-8; #默认的代理
 location / {
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forward-For $proxy_add_x_forwarded_for;
 proxy_set_header Host $http_host;
 proxy_set_header X-Nginx-Proxy true; #代理到配置的上游，zuul网关
 proxy_pass http://zuul;
 } #用户服务：开发调试的反向代理配置
 location ^~ /uaa-provider/ { #代理到Windows开发环境 #proxy_pass http://192.168.233.1:7702/; #代理到自验证CentOS环境
 proxy_pass http://192.168.233.128:7702/uaa-provider/ ;
 } #秒杀服务：开发调试的反向代理配置
 location ^~ /seckill-provider/ { #代理到Windows开发环境
 proxy_pass http://192.168.233.1:7701/seckill-provider/ ;
 } #秒杀Web页面：开发调试的反向代理配置
 location ^~ /seckill-web/ { #代理到Windows开发环境
 proxy_pass http://192.168.233.1:6601/seckill-web/ ;
 }
 ...}

由于笔者在开发过程中，seckill-web、seckill-provider两个进程在IDEA中（Windows开发环境）启动，而uaa-provider进程运行在自验证CentOS环境（虚拟机）中，因此进行了上面的反向代理配置。更多有关环境和运行的内容使用视频方式介绍起来更加直接，所以请查看疯狂创客圈社群的秒杀练习演示视频。

接下来，为大家介绍秒杀练习的秒杀操作流程的特点，有以下3点：

（1）增加了获取秒杀令牌的环节，将秒杀和下单操作分离。

这样做的好处有两方面：一方面，可以让秒杀操作和下单操作从执行上进行分离，使得秒杀操作可以独立于订单相关业务；另一方面，秒杀接口可以阻挡大部分并发流程，从而避免让低效率的下单操作耗费大量的计算资源。

（2）前端缺少了轮询环节。

在生产场景中，用户获取令牌后，前端应该会自动发起下单操作，然后通过前端Ajax脚本轮询是否下单成功。本练习实例为了清晰地展示秒杀操作过程，将自动下单操作修改成了手动下单操作，并且，由于后端下单没有经过消息队列进行异步处理，因此前端也不需要进行结果的轮询。

（3）后端缺少失效令牌的库存恢复操作。

在生产场景中，存在用户拿到令牌而不去完成下单的情况，导致令牌失效。所以，后端需要有定时任务对秒杀令牌进行有效性检查，如果令牌没有被使用或者生效，就需要恢复Redis中的秒杀库存，方便后面的请求去秒杀。无效令牌检查的定时任务可以设置为每分钟一次或者每两分钟一次，以保障被无效令牌消耗的库存能够及时得到恢复。

数据表和PO实体类设计

秒杀系统的表设计相对简单清晰，主要涉及两张核心表：秒杀商品表和订单表。

当然，实际秒杀场景肯定不止这两张表，还有付款信息相关的其他配套表等，出于学习的目的，这里我们只考虑秒杀系统的核心表，不考虑实际系统涉及的其他配套表。

与两个核心表相对应，系统中设计了两个PO实体类：秒杀商品PO类和秒杀订单PO类。本 文的命名规范：Java实体类统一使用PO作为后缀，Java传输类统一使用DTO作为后缀。

由于本案例使用JPA作为持久层框架，可以基于PO类逆向地生成数据库的表，因此这里不对数据表的结构进行展开说明，而是对PO类进行说明。

秒杀商品PO类SeckillGoodPO的代码如下：

package com.crazymaker.springcloud.seckill.dao.po;//省略import/**
 *秒杀商品PO
*/@Entity@Table(name = "SECKILL_GOOD")
@Data@AllArgsConstructor@NoArgsConstructor@Builderpublic class SeckillGoodPO implements Serializable{ //商品ID
 @Id
 @GenericGenerator(
 name = "snowflakeIdGenerator",
 strategy = "com.crazymaker.springcloud.standard.hibernate
.CommonSnowflakeIdGenerator") @GeneratedValue(strategy = GenerationType.IDENTITY, generator = "snowflakeIdGenerator") @Column(name = "GOOD_ID", unique = true, nullable = false, length = 8)
 private Long id; //商品标题
 @Column(name = "GOOD_TITLE", length = 400)
 private String title; //商品标题
 @Column(name = "GOOD_IMAGE", length = 400)
 private String image;
商品原价格 //商品原价格
 @Column(name = "GOOD_PRICE")
 private BigDecimal price; //商品秒杀价格
 @Column(name = "COST_PRICE")
 private BigDecimal costPrice; //创建时间
 @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") @Column(name = "CREATE_TIME")
 private Date createTime; //秒杀开始时间
 @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") @Column(name = "START_TIME")
 private Date startTime; //秒杀结束时间
 @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") @Column(name = "END_TIME")
 private Date endTime; //剩余库存数量
 @Column(name = "STOCK_COUNT")
 private long stockCount; //原始库存数量
 @Column(name = "raw_stock")
 private long rawStockCount;
}
秒杀订单PO类SeckillOrderPO的代码如下：package com.crazymaker.springcloud.seckill.dao.po;//省略import/**
 *秒杀订单PO（对应于秒杀订单表）
 */@Entity@Table(name = "SECKILL_ORDER")
@Data@AllArgsConstructor@NoArgsConstructor@Builderpublic class SeckillOrderPO implements Serializable{ //订单ID
 @Id
 @GenericGenerator(
 name = "snowflakeIdGenerator",
 strategy = "com.crazymaker.springcloud.standard.hibernate.
CommonSnowflakeIdGenerator") @GeneratedValue(strategy = GenerationType.IDENTITY, generator = "snowflakeIdGenerator") @Column(name = "ORDER_ID", unique = true, nullable = false, length = 8)
 private Long id; //支付金额
 @Column(name = "PAY_MONEY")
 private BigDecimal money; //秒杀的用户ID
 @Column(name = "USER_ID")
 private Long userId; //创建时间
 @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") @Column(name = "CREATE_TIME")
 private Date createTime; //支付时间
 @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") @Column(name = "PAY_TIME")
 private Date payTime; //秒杀商品ID
 @Column(name = "GOOD_ID")
 private Long goodId; //订单状态，-1：无效，0：成功，1：已付款
 @Column(name = "STATUS")
 private Short status;
}

在秒杀系统中，SECKILL_GOOD商品表的GOOD_ID字段和SECKILL_ORDER订单表中的GOOD_ID字段在业务逻辑上存在一对多的关系，但是不建议在数据库层面使用表与表之间的外键关系。为什么呢？因为如果秒杀订单量巨大，就必须进行分库分表，这时SECKILL_ORDER表和SECKILL_GOOD表中GOOD_ID相同的数据可能分布在不同的数据库中，所以数据库表层面的关联关系可能会导致维护起来非常困难。

使用分布式ID生成器

在实际开发中，很多项目为了应付交付和追求速度，简单粗暴地使用Java的UUID作为数据的ID。实际上，由于UUID非常长，除了占用大量存储空间外，主要的问题在索引上，在建立索引和基于索引进行查询时都存在性能问题。

下面使用主流的ZooKeeper+Snowflake算法实现高性能的Long类型分布式ID生成器，并且封装成了一个通用的Hibernate的ID生成器类
CommonSnowflakeIdGenerator，具体的代码如下：

package com.crazymaker.springcloud.standard.hibernate;
.../**
 *通用的分布式Hibernate ID生成器
 *build by尼恩 @ 疯狂创客圈
 **/public class CommonSnowflakeIdGenerator extends IncrementGenerator
{ /**
 *生成器的map缓存
 *key为PO类名，value为分布式ID生成器
 */
 private Map<String, SnowflakeIdGenerator> generatorMap =new LinkedHashMap<>(); /**
 *从父类继承方法：生成分布式ID
 */
 @Override
 public Serializable generate(
 SharedSessionContractImplementor sessionImplementor, Object object)
 throws HibernateException
 { /**
 *获取PO的类名
*作为ID的类型
 */
 String type = object.getClass().getSimpleName();
 Serializable id = null; /**
 *从map中取得分布式ID生成器
 */
 IdGenerator idGenerator = getFromMap(type); /**
 *调用生成器的ZooKeeper+Snowflake算法生成ID
 */
 id = idGenerator.nextId(); if (null != id)
 { return id;
 } /**
 *如果生成失败，就通过父类生成
 */
 id = sessionImplementor.getEntityPersister(null, object)
 .getClassMetadata().getIdentifier(object, sessionImplementor); return id != null ? id : super.generate(sessionImplementor, object);
} /**
 *从map中获取缓存的分布式ID生成器，若没有则创建一个
 *
 *@param type生成器的绑定类型，为PO类名
 *@return分布式ID生成器
 */
 public synchronized IdGenerator getFromMap(String type)
 { if (generatorMap.containsKey(type))
 { return generatorMap.get(type);
 } /**
 *创建分布式ID生成器，并且存入map
 */
 SnowflakeIdGenerator idGenerator = new SnowflakeIdGenerator(type);
 generatorMap.put(type, idGenerator); return idGenerator;
 }
}

以上Hibernate ID生成器只是对ZooKeeper+Snowflake算法分布式ID生成器的简单封装。

秒杀的控制层设计

本小节首先介绍秒杀练习的REST接口设计，然后介绍它的控制层（controller）的大致实现逻辑。启动秒杀服务seckill-provider，然后通过Swagger UI界面访问它的REST接口清单，大致如图10-9所示。

图10-9 秒杀练习的REST接口示意图

秒杀服务seckill-provider的控制层的REST接口分为4部分：

（1）秒杀练习RedisLock版本。此秒杀版本含有两个接口：一个获取令牌的接口和一个执行秒杀的接口。此版本使用RedisLock分布式锁保护秒杀数据库操作。

（2）秒杀练习ZkLock版本。

此秒杀版本包含两个接口：一个获取令牌的接口和一个执行秒杀的接口。此版本使用ZkLock分布式锁保护秒杀数据库操作。此版本的意义是为大家学习和使用ZooKeeper分布式锁提供案例。

（3）秒杀练习商品管理。

此部分REST接口主要对秒杀的商品进行CRUD操作。

（4）秒杀练习订单管理。

此部分REST接口主要对秒杀的订单进行查询、清除操作。

由于各部分REST接口涉及的知识体系大致相同，因此本文只介绍秒杀练习RedisLock版本控制层的实现，其他的控制层接口可自行分析和研究。

秒杀练习RedisLock版本的控制层类的代码如下：

package com.crazymaker.springcloud.seckill.controller;//省略import@RestController@RequestMapping("/api/seckill/redis/")@Api(tags = "秒杀练习 RedisLock版本")public class SeckillByRedisLockController{ /**
 *秒杀服务实现Bean
 */
 @Resource
 RedisSeckillServiceImpl redisSeckillServiceImpl; /**
 *获取秒杀的令牌
 */
 @ApiOperation(value = "获取秒杀的令牌") @PostMapping("/token/v1")
 RestOut<String> getSeckillToken( @RequestBody SeckillDTO dto)
 {
 String result = redisSeckillServiceImpl.getSeckillToken(
 dto.getSeckillGoodId(),
 dto.getUserId()); return RestOut.success(result).setRespMsg("这是获取的结果");
 } /**
 *执行秒杀的操作
 *
 *@return
 */
 @ApiOperation(value = "秒杀")
 @PostMapping("/do/v1")
 RestOut<SeckillOrderDTO> executeSeckill(@RequestBody SeckillDTO dto)
 {
 SeckillOrderDTO orderDTO = redisSeckillServiceImpl
.executeSeckill(dto); return RestOut.success(orderDTO).setRespMsg("秒杀成功");
 }
}

以上
SeckillByRedisLockController仅仅做了REST服务的发布，真正的秒杀逻辑在服务层的RedisSeckillServiceImpl类中实现。

 service层逻辑：获取秒杀令牌

本文的秒杀案例特意删除了服务层的接口类，只剩下了服务层的实现类，表面上违背了“面向接口编程”的原则，实际上这样做能使代码更加干净和简洁，也减少了代码维护的工作量。之所以这样简化，主要的原因是：删除的那些接口类都是单实现类接口（一个接口只有一个实现类），那些接口在使用时不会存在多种实现对象赋值给同一个接口变量的多态情况。笔者从事开发这么多年，可谓经历项目无数，发现不知道有多少实际项目，出于“面向接口编程”的原则，写了无数个单实现类接口，将“面向接口编程”的编程原则僵化和教条化。

回到主题，下面给大家介绍RedisSeckillServiceImpl秒杀实现类，该类主要有两个功能：获取秒杀令牌和完成秒杀下单。

本小节介绍其中的第一个功能——获取秒杀令牌，该功能由getSeckillToken方法实现，具体的流程图如图10-10所示。

图10-10 获取秒杀令牌流程图

获取秒杀令牌的输入为用户的userId和秒杀商品的seckillGoodId，其输出为一个代表秒杀令牌的UUID字符串，获取秒杀令牌的重点是进行3个判断：

（1）判断秒杀的商品是否存在，如果不存在，就抛出对应异常。

（2）判断秒杀商品的库存是否足够，如果没有足够库存，就抛出对应异常。

（3）判断用户是否已经获取过商品的秒杀令牌，如果获取过，就抛出对应异常。

只有秒杀商品存在、库存足够而且之前没有被userId代表的用户秒杀过这3个条件都满足，才能允许用户获取商品的秒杀令牌。

获取秒杀令牌的代码节选如下：

package com.crazymaker.springcloud.seckill.service.impl;//省略import@Configuration@Slf4j@Servicepublic class RedisSeckillServiceImpl{ /**
 *秒杀商品的DAO数据操作类
 */
 @Resource
 SeckillGoodDao seckillGoodDao; /**
 *秒杀订单的DAO数据操作类
 */
 @Resource
 SeckillOrderDao seckillOrderDao; /**
 *Redis分布式锁实现类
 */
 @Autowired
 RedisLockService redisLockService; /**
 *缓存数据操作类
 */
 @Resource
 RedisRepository redisRepository; /**
 *秒杀令牌操作的脚本 */
 static String seckillLua = "script/seckill.lua";
 static RedisScript<Long> seckillScript = null;
 {
 String script = IOUtil.loadJarFile(RedisLockService.class.getClassLoader(), seckillLua);
 seckillScript = new DefaultRedisScript<>(script, Long.class);
 } /**
 *获取秒杀令牌
 *
 *@param seckillGoodId秒杀id
 *@param userId用户id
 *@return令牌信息
 */
 public String getSeckillToken(Long seckillGoodId, Long userId)
 {
 String token = UUID.randomUUID().toString(); Long res = redisRepository.executeScript(
 seckillScript, //lua脚本对象
 Collections.singletonList("setToken"), //执行lua脚本的key
 String.valueOf(seckillGoodId), //执行lua脚本的value1
 String.valueOf(userId), //执行lua脚本的value2
 token //执行lua脚本的value3
 ); if (res == 2)
 { throw BusinessException.builder()
.errMsg("秒杀商品没有找到").build();
 } if (res == 4)
 { throw BusinessException.builder()
.errMsg("库存不足,稍后再来").build();
 } if (res == 5)
 { throw BusinessException.builder().errMsg("已经排队过了").build();
 } if (res != 1)
 { throw BusinessException.builder()
.errMsg("排队失败,未知错误").build();
 } return token;
 } //省略下单部分代码}

通过上面的代码可以看出，getSeckillToken方法并没有获取令牌的核心逻辑，仅仅调用缓存在Redis内部的seckill.lua脚本的setToken方法判断和设置秒杀令牌，然后对seckill.lua脚本的返回值进行判断，并根据不同的返回值做出不同的反应。设置令牌的核心逻辑存在于seckill.lua脚本中。为什么要用Lua脚本呢？

（1）由于Redis脚本作为一个整体来执行，中间不会被其他命令插入，天然具备分布式锁的特点，因此不需要使用专门的分布式锁对设置令牌的逻辑进行并发控制。

（2）秒杀令牌在Redis中进行缓存，在设置新令牌之前需要查找旧令牌并且进行是否存在的判断，如果这些逻辑都编写在Java程序中，那么完成查找旧令牌和设置新令牌需要多次的Redis往返操作，也就是说需要进行多次网络传输。大家知道，网络的传输延迟是损耗性能的大户，所以使用Lua脚本能减少网络传输次数，从而提高性能。

在seckill.lua脚本中，除了有setToken令牌的设置方法外，还有其他的方法，如checkToken令牌检查方法，该脚本稍后再为大家统一介绍。

service层逻辑：执行秒杀下单

前面讲到RedisSeckillServiceImpl秒杀实现类主要有两个功能：

获取秒杀令牌和完成秒杀下单。下面来看秒杀下单的业务逻辑。

秒杀下单很简单、清晰，只有两点：减库存和存储用户秒杀订单明细。但是其中涉及两个问题：

（1）数据一致性问题：同一商品在秒杀商品表中的库存数和在订单表中的订单数需要保持一致。

（2）超卖问题：秒杀商品的剩余库存数不能为负数。

以上两个问题主要借助Redis分布式锁解决。另外，由于代码中存在减库存和存订单两次数据库操作，为了防止出现一次失败一次成功的情况，需要通过数据库事务对这两次操作进行数据一致性保护。

秒杀下单的执行流程如图10-11所示。

图10-11 秒杀下单的流程图

由于存在数据库事务，因此将秒杀下单的整体流程分成两个方法实现：

（1）executeSeckill（SeckillDTO）：负责下单前的分布式锁获取和库存的检查。

（2）doSeckill（SeckillDTO）：负责真正的下单操作（减库存和存储秒杀订单）。

秒杀下单流程的实现代码如下：

package com.crazymaker.springcloud.seckill.service.impl;//省略import@Configuration@Slf4j@Servicepublic class RedisSeckillServiceImpl
{ /**
 *秒杀商品的DAO数据操作类
 */
 @Resource
 SeckillGoodDao seckillGoodDao; /**
 *秒杀订单的DAO数据操作类
 */
 @Resource
 SeckillOrderDao seckillOrderDao; /**
 *Redis分布式锁实现类
 */
 @Autowired
 RedisLockService redisLockService; /**
 *执行秒杀下单
 *
 *@param inDto
 *@return
 */
 public SeckillOrderDTO executeSeckill(SeckillDTO inDto)
 {
 long goodId = inDto.getSeckillGoodId();
 Long userId = inDto.getUserId(); //判断令牌是否有效
 Long res = redisRepository.executeScript(
 seckillScript, Collections.singletonList("checkToken"), String.valueOf(inDto.getSeckillGoodId()), String.valueOf(inDto.getUserId()),
 inDto.getSeckillToken()
 ); if (res != 5)
 { throw BusinessException.builder().errMsg("请提前排队").build();
 } /**
 *创建订单对象
 */
 SeckillOrderPO order = SeckillOrderPO.builder()
 .goodId(goodId).userId(userId).build(); Date nowTime = new Date();
 order.setCreateTime(nowTime);
 order.setStatus(SeckillConstants.ORDER_VALID); String lockValue = UUID.randomUUID().toString();
 SeckillOrderDTO dto = null; /**
 *创建重复性检查的订单对象
 */
 SeckillOrderPO checkOrder = SeckillOrderPO.builder().goodId(
 order.getGoodId()).userId(order.getUserId()).build(); //记录秒杀订单信息
 long insertCount = seckillOrderDao.count(Example.of(checkOrder)); //唯一性判断：goodId,id保证一个用户只能秒杀一件商品
 if (insertCount >= 1)
 { //重复秒杀
 log.error("重复秒杀"); throw BusinessException.builder().errMsg("重复秒杀").build();
 } /**
 *获取分布式锁
 */
 String lockKey = "seckill:lock:" + String.valueOf(goodId); boolean locked = redisLockService.acquire(lockKey,
lockValue, 1, TimeUnit.SECONDS); /**
 *执行秒杀，秒杀前先抢到分布式锁
 */
 if (locked)
 {
 Optional<SeckillGoodPO> optional = seckillGoodDao.findById
(order.getGoodId()); if (!optional.isPresent())
 { //秒杀不存在
 throw BusinessException.builder()
.errMsg("秒杀不存在").build();
 } //查询库存
 SeckillGoodPO good = optional.get(); if (good.getStockCount() <= 0)
 { //重复秒杀
 throw BusinessException.builder()
.errMsg("秒杀商品被抢光").build();
 }
 order.setMoney(good.getCostPrice()); try
 { /**
 *进入秒杀事务
 *执行秒杀逻辑：1.减库存；2.存储秒杀订单
 */
 doSeckill(order);
 dto = new SeckillOrderDTO(); BeanUtils.copyProperties(order, dto);
 } finally
 { try
 { /**
 *释放分布式锁
 */
 redisLockService.release(lockKey, lockValue);
 } catch (Exception e)
 {
 e.printStackTrace();
 }
 }
 } else
 { throw BusinessException.builder()
.errMsg("获取分布式锁失败").build();
 } return dto;
 } /**
 *下单操作，加上了数据库事务
 *
 *@param order订单
 */
 @Transactional
 public void doSeckill(SeckillOrderPO order)
 { /**
 *插入秒杀订单
 */
 seckillOrderDao.save(order); //减库存
 seckillGoodDao.updateStockCountById(order.getGoodId());
 }
}

executeSeckill在执行秒杀前调用seckill.lua脚本中的checkToken方法判断令牌是否有效。如果Lua脚本的checkToken方法的返回值不是5（令牌有效标识），就抛出运行时异常。

 秒杀的Lua脚本设计

前面讲到，在seckill.lua脚本中完成设置令牌和令牌检查的工作有两大优势：一是在Redis内部执行Lua脚本天然具备分布式锁的特点；二是能减少网络传输次数，提高性能。

在seckill.lua脚本中定义了两个方法：setToken令牌设置方法和checkToken令牌检查方法。其中，setToken令牌设置方法的执行流程如下：

（1）检查token秒杀令牌是否存在，如果存在，就返回标志5，表明排队过了。

（2）检查以JSON格式缓存的秒杀商品的库存是否足够，如果库存不够，就返回标志4，表明库存不足。

（3）为秒杀商品减少一个库存，并编码成JSON格式，再一次缓存起来。

（4）使用hset命令将用户的秒杀令牌保存在Redis哈希表结构中，其hash key为用户的userId。

（5）最终返回标志1，表明排队成功。

checkToken令牌检查方法的执行流程如下：

（1）使用hget命令从保存秒杀令牌的Redis哈希表结构中，以用户的userId作为hash key，取出之前缓存的秒杀令牌。

（2）如果令牌获取成功，就返回标志5，表明排队成功。

（3）如果令牌不存在，就返回标志-1，表明没有排队。

seckill.lua脚本的源码如下：

-- 返回值说明-- 1 排队成功-- 2 排队商品没有找到-- 3 人数超过限制-- 4 库存不足-- 5 排队过了-- 6 秒杀过了-- -2 Lua方法不存在local function setToken(goodId, userId, token)
 --检查token秒杀令牌是否存在
 local oldToken = redis.call("hget", "seckill:queue:" .. goodId, userId); if oldToken then
 return 5; --返回 5 之前已经排队过了
 end
 --获取商品缓存次数
 local goodJson = redis.call("get", "seckill:goods:" .. goodId); if not goodJson then
 --redis.debug("秒杀商品没有找到")
 return 2; --返回2秒杀商品没有找到
 end
 --redis.log(redis.LOG_NOTICE, goodJson)
 local goodDto = cjson.decode(goodJson); --redis.log(redis.LOG_NOTICE, "good title=" .. goodDto.title)
 local stockCount = tonumber(goodDto.stockCount); --redis.log(redis.LOG_NOTICE, "stockCount=" .. stockCount)
 if stockCount <= 0 then
 return 4; --返回4库存不足
 end
 stockCount = stockCount - 1;
 goodDto.stockCount = stockCount;
 redis.call("set", "seckill:goods:" .. goodId, cjson.encode(goodDto));
 redis.call("hset", "seckill:queue:" .. goodId, userId, token); return 1; --返回1排队成功end-- 返回值说明-- 5 排队过了-- -1 没有排队local function checkToken(goodId, userId, token)
 --检查token是否存在
 local oldToken = redis.call("hget", "seckill:queue:" .. goodId, userId); if oldToken and (token == oldToken) then
 --return 1 ;
 return 5; --5 排队过了
 end
 return -1; ---1 没有排队endlocal method = KEYS[1] --执行lua脚本时传入的key1local goodId = ARGV[1] --执行lua脚本时传入的value1local userId = ARGV[2] --执行lua脚本时传入的value2local token = ARGV[3] --执行lua脚本时传入的value3if method == 'setToken' then return setToken(goodId, userId, token)elseif method == 'checkToken' then
 return checkToken(goodId, userId, token)else
 return -2; --Lua方法不存在end

以上seckill.lua脚本在Java中可以通过spring-data-redis包的以下方法来执行：

RedisTemplate.execute（RedisScript<T> script, List<K> keys, Object,..., args）在开发脚本的过程中往往需要进行脚本调试，可以通过Shell指令redis-cli--eval直接执行seckill.lua脚本，具体的调试执行过程可查看疯狂创客圈社群的秒杀练习演示视频。

 BusinessException定义

减库存操作和插入购买明细操作都会产生很多业务异常，比如库存不足、重复秒杀等，这些业务异常与crazy-springcloud脚手架中的其他业务异常一样，全部被封装成BusinessException通用业务异常实例抛出。

一般项目怎么划分自定义异常呢？大致有两种方式：

（1）按异常来源所处的controller、service、dao层划分业务异常，例如DaoException、ServiceException、ControllerException等。

（2）按异常来源所处的模块组件（如数据库、消息中间件、业务模块）划分业务异常，例如MysqlExceptioin、RedisException、ElasticSearchException、SeckillException等。

无论按照哪个维度划分都出于同一个目标：一旦出现异常，就可以很容易定位到是哪个层或组件出现了问题。

在实际开发过程中，定义太多异常类型之后，需要不厌其烦地将异常一层层抛出、一层层捕获，反而会加大代码的复杂度。所以，虽然crazyspringcloud脚手架和其他项目一样定义了一个自己的全局异常基类BusinessException，但是crazy-springcloud脚手没有定义太多业务异常子类。一般情况下，重新定义一个异常的子类其实没有太大必要，因为可以根据异常的编码和异常的消息进行区分。

crazy-springcloud脚手架的基础业务异常类BusinessException的代码如下：

package com.crazymaker.springcloud.common.exception;//省略import@Builder@Data@AllArgsConstructorpublic class BusinessException extends RuntimeException{ private static final long serialVersionUID = 1L; /**
 *默认的错误编码
 */ private static final int DEFAULT_CODE = -1; /**
 *默认的错误提示
 */
 private static final String DEFAULT_MSG = "业务异常"; /**
 *业务错误编码
 */
 @lombok.Builder.Default private int errCode = DEFAULT_CODE; /**
 *错误的提示信息
 */
 @lombok.Builder.Default private String errMsg = DEFAULT_MSG; public BusinessException()
 { super(DEFAULT_MSG);
 } /**
 *带格式设置异常消息
 *@param format 格式
 *@param objects 替换的对象
 */
 public BusinessException setDetail(String format, Object... objects) {
 format = StringUtils.replace(format, "{}", "%s"); this.errMsg = String.format(format, objects); return this;
 }
}

该类有errCode、errMsg两个属性，errCode属性用于存放异常的编码，errMsg属性用于存放一些错误附加信息。

特别注意，该类继承了RuntimeException运行时异常类，而不是Exception受检异常基类，表明BusinessException类其实是一个非受检的运行时异常类。

为什么要这样呢？有两个原因：

（1）默认情况下，Spring Boot事务只有检查到RuntimeException运行时异常才会回滚，如果检查到的是普通的受检异常，那么Spring Boot事务是不会回滚的，除非经过特殊配置。

（2）简化编程的代码，如果没有必要，就不需要在业务程序中对异常进行捕获，而是由项目中的全局异常解析器统一负责处理。

crazy-springcloud脚手架的全局异常解析器ExceptionResolver的代码如下：

package com.crazymaker.springcloud.standard.config;//省略import/**
 *ExceptionResolver
 */@Slf4j@RestControllerAdvicepublic class ExceptionResolver{ /**
 *其他异常
 */
 private static final String OTHER_EXCEPTION_MESSAGE = "其他异常"; /**
 *业务异常
 */
 private static final String BUSINESS_EXCEPTION_MESSAGE = "业务异常"; /**
 *业务异常处理
 *
 *@param request请求体
 *@param e 异常实例
 *@return RestOut
 */
 @Order(1)
 @ExceptionHandler(BusinessException.class)
 public RestOut<String> businessException(HttpServletRequest request, BusinessException e)
 {
 log.info(BUSINESS_EXCEPTION_MESSAGE + ":" + e.getErrMsg()); return RestOut.error(e.getErrMsg());
 } /**
 *业务异常之外的其他异常处理
 *
 *@param request请求体
 *@param e 异常实例
 *@return RestOut
 */
 @Order(2)
 @ExceptionHandler(Exception.class)
 public RestOut<String> finalException(HttpServletRequest request, Exception e)
 {
 e.printStackTrace();
 log.error(OTHER_EXCEPTION_MESSAGE + ":" + e.getMessage()); return RestOut.error(e.getMessage());
 }
}

上面的ExceptionResolver全局异常解析器使用了Spring Boot的@RestControllerAdvice注解，该注解首先会对系统的异常进行拦截，并且交给对应的异常处理方法进行处理，然后将异常处理结果返回给客户端。

ExceptionResolver的每个异常处理方法都使用@ExceptionHandler注解配置自己希望处理的异常类型，传入的参数为异常类型的class实例，如果要处理多个异常类型，那么其参数可以是一个异常类型class实例数组。需要注意的是，不能在两个异常处理方法的@ExceptionHandler注解中配置同一个异常类型，如果存在一种异常类型被处理多次，在初始化全局异常解析器时就会失败。

本文给大家讲解的内容是高并发核心编程，Spring Cloud+Nginx秒杀实战，秒杀业务的参考实现

1. 下篇文章给大家讲解的是高并发核心编程，Spring Cloud+Nginx秒杀实战，Zuul内部网关实现秒杀限流；

2. 觉得文章不错的朋友可以转发此文关注小编；

3. 感谢大家的支持！