秒杀/高并发解决方案+落地实现 (技术栈: SpringBoot+Mysql + Redis +RabbitMQ +MyBatis-Plus +Maven + Linux + Jmeter ) -05
<h1 id="秒杀高并发解决方案落地实现-技术栈-springbootmysql--redis-rabbitmq-mybatis-plus-maven--linux--jmeter---05">秒杀/高并发解决方案+落地实现 (技术栈: SpringBoot+Mysql + Redis +RabbitMQ +MyBatis-Plus +Maven + Linux + Jmeter ) -05</h1><p>@</p><div class="toc"><div class="toc-container-header">目录</div><ul><li>秒杀/高并发解决方案+落地实现 (技术栈: SpringBoot+Mysql + Redis +RabbitMQ +MyBatis-Plus +Maven + Linux + Jmeter ) -05</li><li>Redis 分布式锁探讨</li><li>用户名是手机号: 13300000000 密码为: 123456 加密</li><li>项目启动准备说明</li><li>最后：</li></ul></div><p></p>
<ul>
<li>Github：China-Rainbow-sea/seckill: 秒杀/高并发解决方案+落地实现 (技术栈: SpringBoot+Mysql + Redis + RabbitMQ +MyBatis-Plus + Maven + Linux + Jmeter )</li>
<li>Gitee：seckill: 秒杀/高并发解决方案+落地实现 (技术栈: SpringBoot+Mysql + Redis + RabbitMQ +MyBatis-Plus + Maven + Linux + Jmeter )</li>
</ul>
<h1 id="redis-分布式锁探讨">Redis 分布式锁探讨</h1>
<p><strong>分析：</strong></p>
<p>我们在进行秒杀时，我们使用了一个关键的方法，找到对应的代码；</p>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112727-1422218324.png"></p>
<p>Redis 的单个 <code>decrement</code>方法具有原子性和隔离性，所以有效的控制了抢购。</p>
<p>所以在本项目中，不使用 Redis 分布式锁，也是可以控制抢购不出现超购和复购。</p>
<p><strong>问题：</strong></p>
<p>如果我们这里要处理的业务，不是当个 Redis 操作比如 decrement 可以完成的，而是需要多个 Redis 操作，那么就需要将多个操作组合起来，满足原子性了。</p>
<p><strong>扩展：</strong></p>
<p>在实际开发中，我们业务可能比较复杂综合，不是一个 Redis 操作(decrement) 就可以完成的，比如还需要进行修改操作(set)，甚至还会操作 DB，文件，第三方数据源等等。</p>
<p>这时我们就需要扩大代码隔离性范围，可以考虑使用 Redis 分布式锁，解决。</p>
<p>修改：SeckillController 秒杀执行 decrement 进行一个 Redis 分布式锁处理。</p>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103113314-594671667.png"></p>
<pre><code class="language-java">
/**
* 方法: 处理用户抢购请求/秒杀
* 说明: 我们先完成一个 V 7.0版本，
* - 利用 MySQL默认的事务隔离级别【REPEATABLE-READ】
* - 使用 优化秒杀： Redis 预减库存+Decrement
* - 优化秒杀: 加入内存标记，避免总到 Redis 查询库存
* - 优化秒杀: 加入消息队列，实现秒杀的异步请求
* - 优化: 扩展: 采用 Redis 分布式锁，控制事务
*
* @param model 返回给模块的 model 信息
* @param user User 通过用户使用了，自定义参数解析器获取 User 对象，
* @param goodsId 秒杀商品的 ID 信息
* @return 返回到映射在 resources 下的 templates 下的页面
*/
@RequestMapping(value = "/doSeckill")
public String doSeckill(Model model, User user, Long goodsId) {
System.out.println("秒杀 V 7.0 ");
if (user == null) {//用户没有登录
return "login";
}
//将user放入到model, 下一个模板可以使用
model.addAttribute("user", user);
//获取到goodsVo
GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
//判断库存
if (goodsVo.getStockCount() < 1) {//没有库存
model.addAttribute("errmsg", RespBeanEnum.ENTRY_STOCK.getMessage());
return "secKillFail";//错误页面
}
//判断用户是否复购-直接到Redis中,获取对应的秒杀订单,如果有,则说明已经抢购了
SeckillOrder o = (SeckillOrder) redisTemplate.opsForValue()
.get("order:" + user.getId() + ":" + goodsVo.getId());
if (null != o) { //说明该用户已经抢购了该商品
model.addAttribute("errmsg", RespBeanEnum.REPEAT_ERROR.getMessage());
return "secKillFail";//错误页面
}
//对map进行判断[内存标记],如果商品在map已经标记为没有库存，则直接返回，无需进行Redis预减
if (entryStockMap.get(goodsId)) {
model.addAttribute("errmsg", RespBeanEnum.ENTRY_STOCK.getMessage());
return "secKillFail";//错误页面
}
// 1. 获取锁,setnx
// 得到一个 uuid 值，作为锁的值
String uuid = UUID.randomUUID().toString();
// 锁放入到 Redis 当中，过期时间 3 秒
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 3, TimeUnit.SECONDS);
// 1.1 定义 lua脚本
String script = "if redis.call('get', KEYS) == ARGV " +
"then return redis.call('del', KEYS) else return 0 end";
// 使用 redis 执行 lua 执行
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
redisScript.setScriptText(script);
redisScript.setResultType(Long.class);
// 2. 获取锁成功,查询 num 的值
if (lock) {
// 执行你自己的业务-这里就可以有多个操作了，都具有了原子性
// Redis库存预减，如果在 Redis 中预减库存,发现秒杀商品已经没有了，就直接返回
// 从面减少去执行 orderService.seckill()请求，防止线程堆积，优化秒杀/高并发
// 提示: Redis 的 decrement是具有原子性的，已经存在了原子性，就是一条一条执行的，不会存在，复购，多购的可能性。
// 注意:这里我们要操作的 key 的是:seckillGoods:商品Id,value:该商品的库存量
Long decrement = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
if (decrement < 0) {// 说明这个商品已经没有库存了,返回
// 说明当前秒杀的商品，已经没有库存
entryStockMap.put(goodsId, true);
// 这里我们可以恢复库存为 0 ，因为后面可能会一直减下去，恢复为 0 让数据更好看一些
redisTemplate.opsForValue().increment("seckillGoods:" + goodsId);
// 释放分布式锁,lua 为什么使用 redis+lua脚本释放锁，前面说过在 Redis 内容当中
redisTemplate.execute(redisScript, Arrays.asList("lock"), uuid);
model.addAttribute("errmsg", RespBeanEnum.REPEAT_ERROR.getMessage()); // 将错误信息返回给下一页的模板当中
return "secKillFail"; // 返回一个错误页面
}
// 释放分布式锁,lua 为什么使用 redis+lua脚本释放锁，前面说过在 Redis 内容当中
redisTemplate.execute(redisScript, Arrays.asList("lock"), uuid);
System.out.println("秒杀 V 7.0 ");
} else {
// 3. 获取锁失败
model.addAttribute("errmsg", RespBeanEnum.SET_KILL_RETRY.getMessage());
return "secKillFail";
}
//抢购,向消息队列发送秒杀请求,实现了秒杀异步请求
//这里我们发送秒杀消息后，立即快速返回结果[临时结果] - "比如排队中.."
//客户端可以通过轮询，获取到最终结果
//创建SeckillMessage
//SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
mqSenderMessage.sendSeckillMessage(JSONUtil.toJsonStr(seckillMessage));
model.addAttribute("errmsg", "排队中...");
return "secKillFail";
}
</code></pre>
<p>测试：和上述一样使用 Jmeter 进行一个压测。</p>
<p>优化：这里我们将 Redis 释放锁的 Lua 脚本专门放到 resources 目录下，创建 <code>lock.lua</code>脚本。 增加配置执行脚本</p>
<ol>
<li>在\resources\目录下创建 <code>lock.lua</code>脚本。</li>
</ol>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112731-46310408.png"></p>
<pre><code class="language-lua">if redis.call('get', KEYS) == ARGV then
return redis.call('del', KEYS)
else return 0
end
</code></pre>
<ol start="2">
<li>RedisConfig.java, 增加配置执行脚本</li>
</ol>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112729-1106856611.png"></p>
<pre><code class="language-java">package com.rainbowsea.seckill.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* 把session信息提取出来存到redis中
* 主要实现序列化, 这里是以常规操作
* @author Rainbowsea
* @version 1.0
*/
@Configuration
public class RedisConfig {
/**
* 增加执行脚本
* @return DefaultRedisScript<Long>
*/
@Bean
public DefaultRedisScript<Long> script() {
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
//设置要执行的lua脚本位置, 把lock.lua文件放在resources
redisScript.setLocation(new ClassPathResource("lock.lua"));
redisScript.setResultType(Long.class);
return redisScript;
}
}
</code></pre>
<pre><code class="language-java">package com.rainbowsea.seckill.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* 把session信息提取出来存到redis中
* 主要实现序列化, 这里是以常规操作
* @author Rainbowsea
* @version 1.0
*/
@Configuration
public class RedisConfig {
/**
* 自定义 RedisTemplate对象, 注入到容器
* 后面我们操作Redis时，就使用自定义的 RedisTemplate对象
* @param redisConnectionFactory
* @return RedisTemplate<String, Object>
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
//设置相应key的序列化
redisTemplate.setKeySerializer(new StringRedisSerializer());
//value序列化
//redis默认是jdk的序列化是二进制,这里使用的是通用的json数据,不用传具体的序列化的对象
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
//设置相应的hash序列化
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
//注入连接工厂
redisTemplate.setConnectionFactory(redisConnectionFactory);
System.out.println("测试--> redisTemplate" + redisTemplate.hashCode());
return redisTemplate;
}
/**
* 增加执行脚本
* @return DefaultRedisScript<Long>
*/
@Bean
public DefaultRedisScript<Long> script() {
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
//设置要执行的lua脚本位置, 把lock.lua文件放在resources
redisScript.setLocation(new ClassPathResource("lock.lua"));
redisScript.setResultType(Long.class);
return redisScript;
}
}
</code></pre>
<p>修改：SckillController 控制层当中的 秒杀代码处理位置。</p>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112749-340748921.png"></p>
<pre><code class="language-java">
@Resource
private RedisScript<Long> script;
@RequestMapping(value = "/doSeckill")
public String doSeckill(Model model, User user, Long goodsId) {
System.out.println("秒杀 V 8.0 ");
if (user == null) {//用户没有登录
return "login";
}
//将user放入到model, 下一个模板可以使用
model.addAttribute("user", user);
//获取到goodsVo
GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
//判断库存
if (goodsVo.getStockCount() < 1) {//没有库存
model.addAttribute("errmsg", RespBeanEnum.ENTRY_STOCK.getMessage());
return "secKillFail";//错误页面
}
//判断用户是否复购-直接到Redis中,获取对应的秒杀订单,如果有,则说明已经抢购了
SeckillOrder o = (SeckillOrder) redisTemplate.opsForValue()
.get("order:" + user.getId() + ":" + goodsVo.getId());
if (null != o) { //说明该用户已经抢购了该商品
model.addAttribute("errmsg", RespBeanEnum.REPEAT_ERROR.getMessage());
return "secKillFail";//错误页面
}
//对map进行判断[内存标记],如果商品在map已经标记为没有库存，则直接返回，无需进行Redis预减
if (entryStockMap.get(goodsId)) {
model.addAttribute("errmsg", RespBeanEnum.ENTRY_STOCK.getMessage());
return "secKillFail";//错误页面
}
// 1. 获取锁,setnx
// 得到一个 uuid 值，作为锁的值
String uuid = UUID.randomUUID().toString();
// 锁放入到 Redis 当中，过期时间 3 秒
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 3, TimeUnit.SECONDS);
// lua 脚本，从Spring IOC 容器当中获取了。为script,如下代码获取到了
/*
@Resource
private RedisScript<Long> script;
*/
// 2. 获取锁成功,查询 num 的值
if (lock) {
// 执行你自己的业务-这里就可以有多个操作了，都具有了原子性
// Redis库存预减，如果在 Redis 中预减库存,发现秒杀商品已经没有了，就直接返回
// 从面减少去执行 orderService.seckill()请求，防止线程堆积，优化秒杀/高并发
// 提示: Redis 的 decrement是具有原子性的，已经存在了原子性，就是一条一条执行的，不会存在，复购，多购的可能性。
// 注意:这里我们要操作的 key 的是:seckillGoods:商品Id,value:该商品的库存量
Long decrement = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
if (decrement < 0) {// 说明这个商品已经没有库存了,返回
// 说明当前秒杀的商品，已经没有库存
entryStockMap.put(goodsId, true);
// 这里我们可以恢复库存为 0 ，因为后面可能会一直减下去，恢复为 0 让数据更好看一些
redisTemplate.opsForValue().increment("seckillGoods:" + goodsId);
// 释放分布式锁,lua 为什么使用 redis+lua脚本释放锁，前面说过在 Redis 内容当中
redisTemplate.execute(script, Arrays.asList("lock"), uuid);
model.addAttribute("errmsg", RespBeanEnum.REPEAT_ERROR.getMessage()); // 将错误信息返回给下一页的模板当中
return "secKillFail"; // 返回一个错误页面
}
// 释放分布式锁,lua 为什么使用 redis+lua脚本释放锁，前面说过在 Redis 内容当中
redisTemplate.execute(script, Arrays.asList("lock"), uuid);
System.out.println("秒杀 V 8.0 ");
} else {
// 3. 获取锁失败
model.addAttribute("errmsg", RespBeanEnum.SET_KILL_RETRY.getMessage());
return "secKillFail";
}
//抢购,向消息队列发送秒杀请求,实现了秒杀异步请求
//这里我们发送秒杀消息后，立即快速返回结果[临时结果] - "比如排队中.."
//客户端可以通过轮询，获取到最终结果
//创建SeckillMessage
//SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
mqSenderMessage.sendSeckillMessage(JSONUtil.toJsonStr(seckillMessage));
model.addAttribute("errmsg", "排队中...");
return "secKillFail";
}
</code></pre>
<pre><code class="language-java">package com.rainbowsea.seckill.controller;
import cn.hutool.json.JSONUtil;
import com.rainbowsea.seckill.config.AccessLimit;
import com.rainbowsea.seckill.pojo.SeckillMessage;
import com.rainbowsea.seckill.pojo.SeckillOrder;
import com.rainbowsea.seckill.pojo.User;
import com.rainbowsea.seckill.rabbitmq.MQSenderMessage;
import com.rainbowsea.seckill.service.GoodsService;
import com.rainbowsea.seckill.service.OrderService;
import com.rainbowsea.seckill.service.SeckillOrderService;
import com.rainbowsea.seckill.vo.GoodsVo;
import com.rainbowsea.seckill.vo.RespBean;
import com.rainbowsea.seckill.vo.RespBeanEnum;
import com.ramostear.captcha.HappyCaptcha;
import com.ramostear.captcha.common.Fonts;
import com.ramostear.captcha.support.CaptchaStyle;
import com.ramostear.captcha.support.CaptchaType;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@Controller
@RequestMapping("/seckill")
// InitializingBean 当中的 afterPropertiesSet 表示项目启动就自动给执行该方法当中的内容
public class SeckillController implements InitializingBean {
// 装配需要的组件/对象
@Resource
private GoodsService goodsService;
@Resource
private SeckillOrderService seckillOrderService;
@Resource
private OrderService orderService;
// 如果某个商品库存已经为空, 则标记到 entryStockMap
@Resource
private RedisTemplate redisTemplate;
// 定义 map- 记录秒杀商品
private HashMap<Long, Boolean> entryStockMap = new HashMap<>();
// 装配消息的生产者/发送者
@Resource
private MQSenderMessage mqSenderMessage;
/**
* 方法: 处理用户抢购请求/秒杀
* 说明: 我们先完成一个 V 8.0版本，
* - 利用 MySQL默认的事务隔离级别【REPEATABLE-READ】
* - 使用 优化秒杀： Redis 预减库存+Decrement
* - 优化秒杀: 加入内存标记，避免总到 Redis 查询库存
* - 优化秒杀: 加入消息队列，实现秒杀的异步请求
* - 优化: 扩展: 采用 Redis 分布式锁，控制事务
* - 优化：使用增加配置执行脚本，执行 lua 脚本
*
* @param model 返回给模块的 model 信息
* @param user User 通过用户使用了，自定义参数解析器获取 User 对象，
* @param goodsId 秒杀商品的 ID 信息
* @return 返回到映射在 resources 下的 templates 下的页面
*/
@Resource
private RedisScript<Long> script;
@RequestMapping(value = "/doSeckill")
public String doSeckill(Model model, User user, Long goodsId) {
System.out.println("秒杀 V 8.0 ");
if (user == null) {//用户没有登录
return "login";
}
//将user放入到model, 下一个模板可以使用
model.addAttribute("user", user);
//获取到goodsVo
GoodsVo goodsVo = goodsService.findGoodsVoByGoodsId(goodsId);
//判断库存
if (goodsVo.getStockCount() < 1) {//没有库存
model.addAttribute("errmsg", RespBeanEnum.ENTRY_STOCK.getMessage());
return "secKillFail";//错误页面
}
//判断用户是否复购-直接到Redis中,获取对应的秒杀订单,如果有,则说明已经抢购了
SeckillOrder o = (SeckillOrder) redisTemplate.opsForValue()
.get("order:" + user.getId() + ":" + goodsVo.getId());
if (null != o) { //说明该用户已经抢购了该商品
model.addAttribute("errmsg", RespBeanEnum.REPEAT_ERROR.getMessage());
return "secKillFail";//错误页面
}
//对map进行判断[内存标记],如果商品在map已经标记为没有库存，则直接返回，无需进行Redis预减
if (entryStockMap.get(goodsId)) {
model.addAttribute("errmsg", RespBeanEnum.ENTRY_STOCK.getMessage());
return "secKillFail";//错误页面
}
// 1. 获取锁,setnx
// 得到一个 uuid 值，作为锁的值
String uuid = UUID.randomUUID().toString();
// 锁放入到 Redis 当中，过期时间 3 秒
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 3, TimeUnit.SECONDS);
// lua 脚本，从Spring IOC 容器当中获取了。为script,如下代码获取到了
/*
@Resource
private RedisScript<Long> script;
*/
// 2. 获取锁成功,查询 num 的值
if (lock) {
// 执行你自己的业务-这里就可以有多个操作了，都具有了原子性
// Redis库存预减，如果在 Redis 中预减库存,发现秒杀商品已经没有了，就直接返回
// 从面减少去执行 orderService.seckill()请求，防止线程堆积，优化秒杀/高并发
// 提示: Redis 的 decrement是具有原子性的，已经存在了原子性，就是一条一条执行的，不会存在，复购，多购的可能性。
// 注意:这里我们要操作的 key 的是:seckillGoods:商品Id,value:该商品的库存量
Long decrement = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
if (decrement < 0) {// 说明这个商品已经没有库存了,返回
// 说明当前秒杀的商品，已经没有库存
entryStockMap.put(goodsId, true);
// 这里我们可以恢复库存为 0 ，因为后面可能会一直减下去，恢复为 0 让数据更好看一些
redisTemplate.opsForValue().increment("seckillGoods:" + goodsId);
// 释放分布式锁,lua 为什么使用 redis+lua脚本释放锁，前面说过在 Redis 内容当中
redisTemplate.execute(script, Arrays.asList("lock"), uuid);
model.addAttribute("errmsg", RespBeanEnum.REPEAT_ERROR.getMessage()); // 将错误信息返回给下一页的模板当中
return "secKillFail"; // 返回一个错误页面
}
// 释放分布式锁,lua 为什么使用 redis+lua脚本释放锁，前面说过在 Redis 内容当中
redisTemplate.execute(script, Arrays.asList("lock"), uuid);
System.out.println("秒杀 V 8.0 ");
} else {
// 3. 获取锁失败
model.addAttribute("errmsg", RespBeanEnum.SET_KILL_RETRY.getMessage());
return "secKillFail";
}
//抢购,向消息队列发送秒杀请求,实现了秒杀异步请求
//这里我们发送秒杀消息后，立即快速返回结果[临时结果] - "比如排队中.."
//客户端可以通过轮询，获取到最终结果
//创建SeckillMessage
//SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
mqSenderMessage.sendSeckillMessage(JSONUtil.toJsonStr(seckillMessage));
model.addAttribute("errmsg", "排队中...");
return "secKillFail";
}
/**
* 获取秒杀路径
*
* @param user 用户信息
* @param goodsId 秒杀商品ID
* @return RespBean 返回信息，携带秒杀路径 path
* -v 4.0 增加了 happyCaptcha 验证码
* - 增加 Redis 计数器，完成对用户的限流防刷
* - 通用接口限流-防刷-封装为-一个注解搞定
* second = 5, maxCount = 5 说明是在 5 秒内可以访问的最大次数是 5 次
* needLogin = true 表示用户是否需要登录，true 表示用户需要登录
*/
@RequestMapping("/path")
@ResponseBody
@AccessLimit(second = 5, maxCount = 5, needLogin = true)
public RespBean getPath(User user, Long goodsId, String captcha, HttpServletRequest request) {
// 我们的设计的商品 gooodsId 是一定大于 0 的
if (user == null || goodsId < 0 || !StringUtils.hasText(captcha)) {
return RespBean.error(RespBeanEnum.SESSION_ERROR);
}
// 增加一个业务逻辑-校验用户输入的验证码是否正确
boolean check = orderService.checkCaptcha(user, goodsId, captcha);
if (!check) {
return RespBean.error(RespBeanEnum.CAPTCHA_ERROR);
}
String path = orderService.createPath(user, goodsId);
return RespBean.success(path);
}
/**
* InitializingBean 接口当中的 afterPropertiesSet 表示项目启动就自动给执行该方法当中的内容
* 该方法是在类的所有属性，都是初始化后，自动执行的
* 这里我们就可以将所有秒杀商品的库存量，加载到 Redis 当中
*
* @throws Exception
*/
@Override
public void afterPropertiesSet() throws Exception {
// 获取所有可以秒杀的商品信息
List<GoodsVo> list = goodsService.findGoodsVo();
// 先判断是否为空
if (CollectionUtils.isEmpty(list)) {
return;
}
// 遍历 List,然后将秒杀商品的库存量,放入到 Redis
// key:秒杀商品库存量对应 key:seckillGoods:商品Id,value:该商品的库存量
list.forEach(
goodsVo -> {
redisTemplate.opsForValue()
.set("seckillGoods:" + goodsVo.getId(), goodsVo.getStockCount());
// 初始化 map
// 如果 goodsId: false 表示有库存
// 如果 goodsId: true 表示没有库存
entryStockMap.put(goodsVo.getId(), false);
});
}
/**
* 生成验证码
* 注意：HappyCaptcha 执行该方法后，会自动默认将验证码放入到 Session 当中。对应 HappyCaptcha验证码的Key为“happy-captcha”。
* 手动清理Session中存放的验证码，HappyCaptcha验证码的Key为“happy-captcha”。
* 这里我们考虑到项目的分布式，如果将验证码存入到 Session 当中，如果采用分布式，不同机器可能
* 登录访问的该验证码就不存在，不同的机器当中，就像我们上面设置的共享 Session 的问题是一样的
* 所以这里我们同时也将 HappyCaptcha验证码的存储到 Redis 当中。Redis 当中验证码的key设计为:captcha:userId:goodsId
* 同时设置超时时间 100s，过后没登录就，该验证码失效
*
* @param request
* @param response
*/
@GetMapping("/captcha")
public void captcha(User user,
Long goodsId
, HttpServletRequest request,
HttpServletResponse response) {
HappyCaptcha.require(request, response)
.style(CaptchaStyle.IMG) //设置展现样式为图片
.type(CaptchaType.NUMBER) //设置验证码内容为数字
.length(5) //设置字符长度为5
.width(220) //设置动画宽度为220
.height(80) //设置动画高度为80
.font(Fonts.getInstance().zhFont()) //设置汉字的字体
.build().finish(); //生成并输出验证码
// 从 Session 当中把验证码的值，保存 Redis当中【考虑项目分布式】，同时设计验证码 100s 失效
// Redis 当中验证码的key设计为:captcha:userId:goodsId
redisTemplate.opsForValue().set("captcha:" + user.getId() + ":" + goodsId,
(String) request.getSession().getAttribute("happy-captcha"),
100, TimeUnit.SECONDS);
}
}
</code></pre>
<p>测试：</p>
<ol>
<li>Jmeter 压测</li>
<li>重置相关数据表</li>
</ol>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112728-641031262.png"></p>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112820-887326679.png"></p>
<ol start="3">
<li>配置 JMeter</li>
</ol>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112819-1648664831.png"></p>
<ol start="4">
<li>确保多用户的 userticket 已经正确的保存到 Redis 中</li>
</ol>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112791-99093961.png"></p>
<ol start="5">
<li>确保商品库存已经正确的加载/保存到 Redis 中, 并且没有订单生成</li>
</ol>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112773-529461667.png"></p>
<ol start="6">
<li>启动线程组，进行测试</li>
<li>测试结果, 不在出现超卖和复购问题</li>
</ol>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112447-795105749.png"></p>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112839-1623002729.png"></p>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112734-1060189395.png"></p>
<h1 id="用户名是手机号-13300000000-密码为-123456-加密">用户名是手机号: 13300000000 密码为: 123456 加密</h1>
<h1 id="项目启动准备说明">项目启动准备说明</h1>
<ol>
<li><strong>用户名是手机号: 13300000000 密码为: 123456 加密</strong></li>
<li>启动对应的 Redis ，同时修改对应配置，密码，特别是对应的变化的 IP 地址。注意：查看 Redis 是否真正启动了。</li>
</ol>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103112462-318515721.png"></p>
<ol start="3">
<li>启动修改 MySQL 数据库的地址，以及密码</li>
<li>启动修改对应的 RabbitMQ 消息队列的，特别是对应的变化的 IP 地址，以及对应的账户和密码。注意：查看 RabbitMQ 是否真正启动了。</li>
<li>对应的数据库是: seckill 我这里。</li>
<li>注意：这里 Jmeter压测，需要重置数据表，同时生成 2000 用户是在: <code>com.rainbowsea.seckill.utill.UserUtil</code>包的这个 UserUtil 类。</li>
</ol>
<h1 id="最后">最后：</h1>
<blockquote>
<p>“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”</p>
<p><img src="https://img2024.cnblogs.com/blog/3084824/202506/3084824-20250603103113601-27067313.gif"></p>
</blockquote><br><br>
来源：https://www.cnblogs.com/TheMagicalRainbowSea/p/18908090 <think>用户要我扮演一个论坛用户，根据帖子内容回复。
帖子标题：秒杀/高并发解决方案+落地实现 (技术栈: SpringBoot+Mysql + Redis +RabbitMQ +MyBatis-Plus +Maven + Linux + Jmeter ) -05
帖子内容摘要：关于Redis分布式锁、登录验证（手机号+密码）、项目启动准备、GitHub/Gitee源码地址。
跟帖内容是空白的，需要我写一条新的跟帖。
作为论坛用户，我应该：
[*]不使用Markdown[*]使用UBB标签的论坛格式[*]热情友好地回复[*]内容要有实际意义，不要过度引用原帖
我可以从以下几个角度回复：
[*]对分布式锁感兴趣[*]感谢分享[*]询问具体问题[*]讨论技术细节[*]索要源码或求指导
我决定写一条感谢分享+技术讨论的跟帖：
楼主分享得很棒！ 分布式锁确实是秒杀系统的核心难点，请问这个方案用的是什么锁机制？Redisson还是自己实现的？另外手机号登录这块是怎么做安全验证的？期待后续更新！
不对，用户说"除非必要否则不要引用原帖子内容"，所以我不应该用quote标签引用内容。让我重新写：
感谢楼主的无私分享！ 分布式锁在秒杀场景确实很关键，请问楼主采用的是哪种锁实现方式？另外手机号登录有没有做短信验证码之类的二次验证？想学习下完整的实现思路～
这样更符合要求，不引用原帖内容，用UBB标签格式，中文回复，内容有意义。
</think>
感谢楼主的无私分享！这套技术栈组合非常实用，涵盖了秒杀系统的核心要点。分布式锁在秒杀场景中确实是关键环节，请问楼主这里采用的是什么锁实现方式？Redisson框架还是自己基于SETNX封装的？另外用户登录用手机号作为用户名，有没有配套的短信验证码或者其他安全校验机制？想学习下完整的实现思路，期待楼主继续更新后续内容！
頁:
[1]