学习地址
https://blog.csdn.net/unique_perfect/article/details/109439039
https://www.bilibili.com/video/BV13a4y1t7Wh?t=10&p=3
下面是记录了学习的步骤、流程。
针对单系统情况下的一个Demo。
秒杀系统的核心：
- 严格防止超卖：库存 100 件结果卖了 120 件，这应该是最优先保证的
- 防止黑产：原本应该卖给 100 个人，结果全被一个人买走了
- 保证用户体验：高并发下，网页打不开，支付不成功，购物车进不去，地址改不了，涉及到很多技术，这个问题应该是在第一个问题解决了的前提下再考虑
保护措施：
- 乐观锁防止超卖 --- 核心基础
- 令牌桶限流 ---
- Redis 缓存
- 消息队列异步处理订单
- ……
用户体验不好最多是让用户没有参与到活动，但要是卖多了问题就严重了起来，所以首先应该解决的问题是防止超卖。
-- ----------------------------
-- Table structure for stock
-- ----------------------------
DROP TABLE IF EXISTS `stock`;
CREATE TABLE `stock` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(50) NOT NULL DEFAULT '' COMMENT '名称',
`count` int(11) NOT NULL COMMENT '库存',
`sale` int(11) NOT NULL COMMENT '已售',
`version` int(11) NOT NULL COMMENT '乐观锁，版本号',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for stock_order
-- ----------------------------
DROP TABLE IF EXISTS `stock_order`;
CREATE TABLE `stock_order` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`sid` int(11) NOT NULL COMMENT '库存ID',
`name` varchar(30) NOT NULL DEFAULT '' COMMENT '商品名称',
`create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;1 依赖
在创建项目时选择添加
- Lombok
- Spring Web
- Mybatis Framework
- MySql Driver
修改 MySql 驱动依赖版本号为系统数据库版本号；指定 lombok 版本号，
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.20</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
<optional>true</optional>
</dependency>mybatis 和数据库整合是还需要一个数据源，添加数据源依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.19</version>
</dependency>于是完整的依赖文件 pom.xml 为
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.3.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>top.zbsong</groupId>
<artifactId>miaosha</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>miaosha</name>
<description>miaosha Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.19</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.20</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>2 配置文件
application.properties
# 端口
server.port=80
# 应用的上下文路径，也可以称为项目路径，是构成url地址的一部分
server.servlet.context-path=/ms
# 配置数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ms
spring.datasource.username=root
spring.datasource.password=123456
# 配置mybatis
mybatis.mapper-locations=classpath:top/zbsong/mapper/*.xml
mybatis.type-aliases-package=top.zbsong.entity
# 日志
logging.level.root=info
logging.level.top.zbsong.dao=debug
DAO代码
public interface StockDAO {
// 根据商品id查询库存信息的方法
Stock chechStock(Integer id);
// 根据商品id扣除库存
void updateSale(Stock stock);
}
public interface OrderDAO {
// 创建订单方法
void createOrder(Order order);
}Service 代码
@Service
@Transactional
public class OrderServiceImpl implements OrderService {
@Autowired
private StockDAO stockDAO;
@Autowired
private OrderDAO orderDAO;
@Override
public int kill(Integer id) {
// 根据商品id去校验库存，检验的都是已售和库存的关系
Stock stock = stockDAO.chechStock(id);
// 初始的库存等于已售库存，说明没有了
if (stock.getSale().equals(stock.getCount())) {
throw new RuntimeException("库存不足");
} else {
// 扣除库存
stock.setSale(stock.getSale() + 1);
stockDAO.updateSale(stock);
// 创建订单
Order order = new Order();
order.setSid(stock.getId()).setName(stock.getName()).setCreateDate(new Date());
orderDAO.createOrder(order);
return order.getId();
}
}
}Controller代码
@RestController
@RequestMapping("stock")
public class StockController {
@Autowired
private OrderService orderService;
// 根据秒杀商品id去调用秒杀业务
@GetMapping("kill")
public String kill(Integer id) {
System.out.println("秒杀商品的id=" + id);
try {
int orderId = orderService.kill(id);
return "秒杀成功，订单id为" + String.valueOf(orderId);
} catch (Exception e) {
e.printStackTrace();
return e.getMessage();
}
}
}在正常测试下不会出现超卖问题。
介绍
Apache JMeter 是 Apache 组织开发的基于 Java 的压力测试工具。用于对软件做压力测试，它最初被设计用于 Web 应用测试，但后来扩展到其他测试领域。 它可以用于测试静态和动态资源，例如静态文件、Java 小服务程序、CGI 脚本、Java 对象、数据库、FTP 服务器， 等等。JMeter 可以用于对服务器、网络或对象模拟巨大的负载，来自不同压力类别下测试它们的强度和分析整体性能。另外，JMeter 能够对应用程序做功能/回归测试，通过创建带有断言的脚本来验证你的程序返回了你期望的结果
安装Jmeter
官网：https://jmeter.apache.org/
# 1.下载jmeter
https://jmeter.apache.org/download_jmeter.cgi
下载地址:https://mirror.bit.edu.cn/apache//jmeter/binaries/apache-jmeter-5.2.1.tgz
# 2.解压缩
backups ---用来对压力测试进行备份目录
bin ---Jmeter核心执行脚本文件
docs ---官方文档和案例
extras ---额外的扩展
lib ---第三方依赖库
licenses ---说明
printable_docs ---格式化文档
# 3.安装Jmeter
0.要求: 必须事先安装jdk环境
1.配置jmeter环境变量
新建环境变量：JMETER_HOME=G:\apache-jmeter-5.4.1
在Path中添加环境变量：Path=G:\apache-jmeter-5.4.1\bin
2.是配置生效(Linux或者Mac需要)
source ~/.bash_profile
3.测试jemeter
在 cmd 中输入 jmeter -v
压力测试
jmeter -n -t [jmx file] -l [results file] -e -o [Path to web report folder]
- jmx file：jmx压力测试文件
- results file：结果输出的文件
- Path to web report folder：生成html版压力测试报告文件
线程数 2000，库存设置 100，输入以下命令：
jmeter -n -t ./秒杀测试.jmx -l ./miaosha.txt -e -o ./html
测试结果
100 件商品都被秒杀完毕，但是订单却有 775 个，出现了超卖问题，后台也报错。
有人肯定想到了加 synchronized 关键字到 OrderServiceImpl 的 kill 方法上来解决超卖问题。但是业务方法不能加 synchronized，需要加在调用处，保证线程执行比事务范围大，否则还是不能解决超卖问题。
// 调用处添加同步代码块
synchronized {
int orderId = orderService.kill(id);
return "秒杀成功，订单id为" + String.valueOf(orderId);
}synchronized 线程如果比事务范围小, 释放锁后 ，事务没有结束，数据没有提交到数据库，库存没有改，第二个线程如果执行比较快，跑过了第一个，将数据提交后，第一个才提交事务，这样就可能出现了超卖。所以同步代码块应该加到调用处。
并且悲观锁会让线程排队，效率特别低。
Synchronized锁在Spring事务管理下，为啥还线程不安全？
说明: 使用乐观锁解决商品的超卖问题,实际上是把主要防止超卖问题交给数据库解决,利用数据库中定义的 version字段 以及数据库中的 事务 实现在并发情况下商品的超卖问题。(CAS)
1 修改代码
校验库存的方法(不变)
private Stock checkStock(Integer id) {
Stock stock = stockDAO.checkStock(id);
if (stock.getSale().equals(stock.getCount())) {
throw new RuntimeException("库存不足");
}
return stock;
}<!--根据秒杀商品的id去查询库存-->
<select id="chechStock" parameterType="int" resultType="Stock">
select id,name,count,sale,version from stock
where id=#{id}
</select>更新库存方法改造
private void updateSale(Stock stock) {
// 在sql层面完成销量 sale+1 和版本号 version+1，并且根据商品id和版本号同时更新的商品。
int updateRows = stockDAO.updateSale(stock);
if (updateRows == 0) {
throw new RuntimeException("抢购失败，请重试!!!");
}
}<!--根据商品id去扣除库存-->
<update id="updateSale" parameterType="Stock">
update stock set
sale=sale+1,
version=version+1
where id=#{id} and version=#{version}
</update>创建订单（不变）
// 创建订单
private Integer createOrder(Stock stock) {
Order order = new Order();
order.setSid(stock.getId()).setName(stock.getName()).setCreateDate(new Date());
orderDAO.createOrder(order);
return order.getId();
}<!--创建订单-->
<!--
useGeneratedKeys="true" 根据数据库主键生成策略来帮我们生成id
keyProperty="id" 把生成的id放到传到对象的id属性中
-->
<insert id="createOrder" parameterType="Order" useGeneratedKeys="true" keyProperty="id">
insert into stock_order values(#{id},#{sid},#{name},#{createDate})
</insert>2 完整的业务方法与Mapper.xml
Service方法
@Override
public int kill(Integer id) {
// 校验库存
Stock stock = checkStock(id);
// 扣除库存
updateSale(stock);
// 创建订单
return createOrder(stock);
}
// 校验库存
private Stock checkStock(Integer id) {
Stock stock = stockDAO.checkStock(id);
if (stock.getSale().equals(stock.getCount())) {
throw new RuntimeException("库存不足");
}
return stock;
}
// 扣除库存
private void updateSale(Stock stock) {
// 在sql层面完成销量 sale+1 和版本号 version+1，并且根据商品id和版本号同时更新的商品。
int updateRows = stockDAO.updateSale(stock);
if (updateRows == 0) {
throw new RuntimeException("抢购失败，请重试!!!");
}
}
// 创建订单
private Integer createOrder(Stock stock) {
Order order = new Order();
order.setSid(stock.getId()).setName(stock.getName()).setCreateDate(new Date());
orderDAO.createOrder(order);
return order.getId();
}StockDAOMapper.xml
<!--根据秒杀商品的id去查询库存-->
<select id="chechStock" parameterType="int" resultType="Stock">
select id,name,count,sale,version from stock
where id=#{id}
</select>
<!--根据商品id去扣除库存-->
<update id="updateSale" parameterType="Stock">
update stock set
sale=sale+1,
version=version+1
where id=#{id} and version=#{version}
</update>OrderDAOMapper.xml
<!--创建订单-->
<!--
useGeneratedKeys="true" 根据数据库主键生成策略来帮我们生成id
keyProperty="id" 把生成的id放到传到对象的id属性中
-->
<insert id="createOrder" parameterType="Order" useGeneratedKeys="true" keyProperty="id">
insert into stock_order values(#{id},#{sid},#{name},#{createDate})
</insert>3 测试
同样设置库存为 100，并发的线程数量为 2000。
运行 Jmeter 压力测试工具：jmeter -n -t ./秒杀测试.jmx
可以在图中看到，stock 表中 sale 和 version 字段都增加到了 100，stock_order 表也只出现了 100 条订单信息。说明乐观锁成功解决了商品的超卖问题。
但是在大型的互联网项目中，可能同一时间有成千上万的请求同时过来，我们的服务器肯定是承受不住的，所以需要对请求进行一定的限流处理。
限流：是对某一时间窗口内的请求数进行限制，保持系统的可用性和稳定性，防止因流量暴增而导致的系统运行缓慢或宕机。
在面临高并发的抢购请求时，我们如果不对接口进行限流，可能会对后台系统造成极大的压力。大量的请求抢购成功时需要调用下单的接口，过多的请求打到数据库会对系统的稳定性造成影响。
常用的限流算法有 令牌桶 和 漏桶(漏斗算法)，而 Google 开源项目 Guava 中的 RateLimiter 使用的就是令牌桶控制算法。在开发高并发系统时有三把利器用来保护系统：缓存、降级 和 限流。
- 缓存：缓存的目的是提升系统访问速度和增大系统处理容量
- 降级：降级是当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行
- 限流：限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理。
- 漏斗算法:漏桶算法思路很简单，水（请求）先进入到漏桶里，漏桶以一定的速度出水，当水流入速度过大会直接溢出，可以看出漏桶算法能强行限制数据的传输速率。
- 令牌桶算法:最初来源于计算机网络。在网络传输数据时，为了防止网络拥塞，需限制流出网络的流量，使流量以比较均匀的速度向外发送。令牌桶算法就实现了这个功能，可控制发送到网络上数据的数目，并允许突发数据的发送。大小固定的令牌桶可自行以恒定的速率源源不断地产生令牌。如果令牌不被消耗，或者被消耗的速度小于产生的速度，令牌就会不断地增多，直到把桶填满。后面再产生的令牌就会从桶中溢出。最后桶中可以保存的最大令牌数永远不会超过桶的大小。这意味，面对瞬时大流量，该算法可以在短时间内请求拿到大量令牌，而且拿令牌的过程并不是消耗很大的事情。
一般是放在控制层去限制请求。
1 项目中引入依赖
<!--google开源工具类RateLimiter令牌桶实现-->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>28.2-jre</version>
</dependency>2 令牌桶算法的基本使用
// 令牌桶实例
private RateLimiter rateLimiter = RateLimiter.create(10);
@GetMapping("sale")
public String sale(Integer id) {
// 1.没有获取到token请求一直阻塞，直到获得token令牌
// log.info("等待的时间：" + rateLimiter.acquire());
// 2.设置一个等待时间，在等待时间内没有获取到响应token则抛弃
if (rateLimiter.tryAcquire(5, TimeUnit.SECONDS)) {
System.out.println("当前请求被限流，直接抛弃，无法调用后续秒杀逻辑");
return "抢购失败!";
}
System.out.println("处理业务.................");
return "测试令牌桶";
}使用令牌桶改造 controller 实现乐观锁 + 限流
private RateLimiter rateLimiter = RateLimiter.create(20);
// 根据秒杀商品id去调用秒杀业务 使用乐观锁防止超卖 + 令牌桶算法限流
@GetMapping("killtoken")
public String killtoken(Integer id) {
System.out.println("秒杀商品的id=" + id);
// 加入令牌桶限流措施
// 设置一个等待时间，在等待时间内没有获取到响应token则抛弃
if (!rateLimiter.tryAcquire(1, TimeUnit.SECONDS)) {
log.info("抛弃请求：抢购失败，当前秒杀活动过于火爆，请重试!");
return "抢购失败，当前秒杀活动过于火爆，请重试!";
}
try {
int orderId = orderService.kill(id);
return "秒杀成功，订单id为" + String.valueOf(orderId);
} catch (Exception e) {
e.printStackTrace();
return e.getMessage();
}
}库存为100，令牌桶大小为 10，访问线程数为 2000。
运行 Jmeter 压力测试工具：jmeter -n -t ./"秒杀+令牌桶.jmx"。
我们完成了防止超卖商品和抢购接口的限流，已经能够防止大流量把我们的服务器直接搞炸。
但存在的问题是：可能会导致少卖，我们计划一共卖出 100 件，但是实际上因为进行了接口限流，只卖出去了一部分。可以通过修改令牌桶的大小或者是修改丢弃的时间（修改策略）来让这 100 件商品都没卖出去。
我们完成了防止超卖商品和抢购接口的限流，已经能够防止大流量把我们的服务器直接搞炸。接下来我们要开始关心一些细节问题：
- 我们应该在一定的时间内执行秒杀处理，不能再任意时间都接受秒杀请求。如何加入时间验证？
- 对于稍微懂点电脑的，又会动歪脑筋的人来说开始通过抓包方式获取我们的接口地址。然后通过脚本进行抢购怎么办？
- 秒杀开始之后如何限制单个用户的请求频率，即单位时间内限制访问次数？
关于抢购（下单）接口相关的单用户防刷措施：
- 限时抢购
- 抢购接口隐藏
- 单用户限制频率（单位时间内限制访问次数）
使用 Redis 来记录秒杀商品的时间，对秒杀过期的请求进行拒绝处理!!
1 启动Redis
windows 系统下运行 redis-server.exe，启动 Redis 服务器。然后运行 redis-cli.exe 启动客户端。
输入命令 keys * 查看当前缓存是否为空，如果不为空则输入命令 FLUSHALL 清除缓存。
2 将秒杀商品放入Redis并设置超时
使用 String 类型，以 kill + 商品id 作为 key，以 商品id 作为 value，设置 180 秒超时（可随意设置时间）。
127.0.0.1:6379> set kill1 1 EX 180
OK
3 抢购中加入时间控制
整合当前项目操作 redis 服务，这里使用 spring-boot-starter-data-redis 操作 redis
1 引入依赖
<!--springboot整合redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>2 修改配置连接redis
# 配置redis
spring.redis.database=0
spring.redis.port=6379
spring.redis.host=localhostRedis 和 Spring 结合起来的时候，使用到的工具类有 RedisTemplate 和StringRedisTemplate，前者主要是操作对象，后者主要是操作字符串。
3 通过redis控制抢购超时的请求
@Service
@Transactional
public class OrderServiceImpl implements OrderService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public int kill(Integer id) {
// 校验Redis中的秒杀商品是否超时
if (!stringRedisTemplate.hasKey("kill" + id)) {
throw new RuntimeException("当前商品的抢购活动已经结束啦~");
}
// 校验库存
Stock stock = checkStock(id);
// 扣除库存
updateSale(stock);
// 创建订单
return createOrder(stock);
}
}测试
Redis-cli 中输入 set kill1 1 EX 10 设置时间，切换到 Jmeter 中运行测试。
对于稍微懂点电脑的，又会动歪脑筋的人来说，点击 F12 打开浏览器的控制台，就能在点击抢购按钮后，获取我们抢购接口的链接。（手机 APP 等其他客户端可以抓包来拿到）一旦坏蛋拿到了抢购的链接，只要稍微写点爬虫代码，模拟一个抢购请求，就可以不通过点击下单按钮，直接在代码中请求我们的接口，完成下单。所以就有了成千上万的薅羊毛军团，写一些脚本抢购各种秒杀商品。
他们只需要在抢购时刻的 000 毫秒，开始不间断发起大量请求，觉得比大家在 APP 上点抢购按钮要快，毕竟人的速度有极限，更别说 APP 说不定还要经过几层前端验证才会真正发出请求。 所以我们需要将抢购接口进行隐藏，抢购接口隐藏（接口加盐）的具体做法：
- 每次点击秒杀按钮，先从服务器获取一个秒杀验证值（接口内判断是否到秒杀时间）。
- Redis 以缓存用户 ID 和商品 ID 为 Key，秒杀地址为 Value 缓存验证值
- 用户请求秒杀商品的时候，要带上秒杀验证值进行校验。
**1 **新增用户表
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`name` varchar(80) DEFAULT NULL COMMENT '用户名',
`password` varchar(40) DEFAULT NULL COMMENT '用户密码',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
SET FOREIGN_KEY_CHECKS = 1;2 Controller代码
// 根据商品id和用户id获取md5值
public String getMd5(Integer id, Integer userid) {
String md5;
try {
md5 = orderService.getMd5(id, userid);
} catch (Exception e) {
e.printStackTrace();
return "获取md5失败：" + e.getMessage();
}
return "获取md5信息为：" + md5;
}
// 秒杀方法 乐观锁防止超卖+令牌桶算法限流+md5接口隐藏
@RequestMapping("killtokenmd5")
public String killtoken(Integer id, Integer userid, String md5) {
System.out.println("秒杀商品的id=" + id);
// 加入令牌桶限流措施
// 设置一个等待时间，在等待时间内没有获取到响应token则抛弃
if (!rateLimiter.tryAcquire(1, TimeUnit.SECONDS)) {
log.info("抛弃请求：抢购失败，当前秒杀活动过于火爆，请重试!");
return "抢购失败，当前秒杀活动过于火爆，请重试!";
}
try {
int orderId = orderService.kill(id, userid, md5);
return "秒杀成功，订单id为" + String.valueOf(orderId);
} catch (Exception e) {
e.printStackTrace();
return e.getMessage();
}
}3 Service代码
// 根据商品id和用户id生成md5值
@Override
public String getMd5(Integer id, Integer userid) {
// 检验用户的合法性 userid存在用户信息
User user = userDAO.findById(userid);
if (user == null) {
throw new RuntimeException("用户信息不存在!");
}
log.info("用户信息：[{}]", user.toString());
// 检验商品的合法性 id存在商品信息
Stock stock = stockDAO.checkStock(id);
if (stock == null) {
throw new RuntimeException("商品信息不合法!");
}
log.info("商品信息：[{}]", stock.toString());
// 生成hashkey
String hashkey = "KEY_" + userid + "_" + id;
// 生成md5，这里的 "!QJS#" 是一个盐，随机生成
String key = DigestUtils.md5DigestAsHex((userid + id + "!Q*JS#").getBytes());
stringRedisTemplate.opsForValue().set(hashkey, key, 3600, TimeUnit.SECONDS);
log.info("Redis写入：[{}] [{}]", hashkey, key);
return key;
}
@Override
public int kill(Integer id, Integer userid, String md5) {
// 校验Redis中的秒杀商品是否超时
if (!stringRedisTemplate.hasKey("kill" + id)) {
throw new RuntimeException("当前商品的抢购活动已经结束啦~");
}
// 验证签名
String hashKey = "KEY_" + userid + "_" + id;
String s = stringRedisTemplate.opsForValue().get(hashKey);
if (s == null) {
throw new RuntimeException("没有携带验证签名，请求不合法!");
}
if (!s.equals(md5)) {
throw new RuntimeException("当前请求数据不合法，清稍后再试!");
}
// 校验库存
Stock stock = checkStock(id);
// 扣除库存
updateSale(stock);
// 创建订单
return createOrder(stock);
}4 DAO代码和Entity
@Data
public class User {
private Integer id;
private String name;
private String password;
}public interface UserDAO {
// 根据用户id查询用户
User findById(Integer userid);
}<select id="findById" parameterType="Integer" resultType="User">
select id,name,password from user where id=#{userid};
</select>5 数据库添加用户记录
1 xiaosong 123456
6 测试
开启秒杀
set kill1 1 EX 180
获取md5
访问接口http://localhost/ms/stock/md5
秒杀请求
不合法请求（md5值不合法）
合法请求（携带正确的商品id、用户id以及生成的md5值）
假设我们做好了接口隐藏，但是像上面说的，总有无聊的人会写一个复杂的脚本，先请求 hash(md5) 值，再立刻请求购买，如果你的 app 下单按钮做的很差，大家都要开抢后 0.5 秒才能请求成功，那可能会让脚本依然能够在大家前面抢购成功。
我们需要在做一个额外的措施，来限制单个用户的抢购频率。其实很简单的就能想到用 redis 给每个用户做访问统计，甚至是带上商品 id ，对单个商品做访问统计，这都是可行的。
我们先实现一个对用户的访问频率限制，我们在用户申请下单时，检查用户的访问次数，超过访问次数，则不让他下单！
1 Controller代码
@Autowired
private UserService userService;
// 秒杀方法 乐观锁防止超卖+令牌桶算法限流+md5接口隐藏+单用户访问频率限制
@RequestMapping("killtokenmd5limit")
public String killtokenmd5limit(Integer id, Integer userid, String md5) {
System.out.println("秒杀商品的id=" + id);
// 加入令牌桶限流措施
// 设置一个等待时间，在等待时间内没有获取到响应token则抛弃
if (!rateLimiter.tryAcquire(1, TimeUnit.SECONDS)) {
log.info("抛弃请求：抢购失败，当前秒杀活动过于火爆，请重试!");
return "抢购失败，当前秒杀活动过于火爆，请重试!";
}
try {
// 单用户调用接口的频率限制
int count = userService.saveUserCount(userid);
log.info("用户截止该次的访问次数为：[{}]", count);
// 进行调用次数的判断
boolean isBanned = userService.getUserCount(userid);
if (isBanned) {
log.info("购买失败，超过频率限制!");
return "购买失败，超过频率限制!";
}
// 根据秒杀商品id去调用秒杀业务
int orderId = orderService.kill(id, userid, md5);
return "秒杀成功，订单id为" + String.valueOf(orderId);
} catch (Exception e) {
e.printStackTrace();
return e.getMessage();
}
}2 Service代码
public interface UserService {
// 向redis中写入用户访问次数
int saveUserCount(Integer userId);
// 判断单位时间调用次数
boolean getUserCount(Integer userId);
}@Service
@Transactional
@Slf4j
public class UserServiceImpl implements UserService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public int saveUserCount(Integer userId) {
// 根据不同用户id生成调用次数的key
String limitKey = "LIMIT" + "_" + userId;
// 获取redis中指定key的调用次数
String limitNum = stringRedisTemplate.opsForValue().get(limitKey);
int limit = -1;
if (limitNum == null) {
// 第一次调用放入redis中设置为0
stringRedisTemplate.opsForValue().set(limitKey, "0", 3600, TimeUnit.SECONDS);
} else {
// 不是第一次调用每次+1
limit = Integer.parseInt(limitNum) + 1;
stringRedisTemplate.opsForValue().set(limitKey, String.valueOf(limit), 3600, TimeUnit.SECONDS);
}
// 返回调用次数
return limit;
}
@Override
public boolean getUserCount(Integer userId) {
String limitKey = "LIMIT" + "_" + userId;
// 跟库用户调用次数的key获取redis中调用次数
String limitNum = stringRedisTemplate.opsForValue().get(limitKey);
if (limitNum == null) {
// 为空直接抛弃说明key出现异常
log.error("该用户没有访问申请验证值记录，疑似异常");
return true;
}
// false代表没有超过 true代表超过
return Integer.parseInt(limitNum) > 10;
}
}3 测试
开启秒杀活动
set kill1 1 EX 180
获取md5
Jmeter访问30次
可以看到第 11 次开始就被限制访问了
