（12）SprintBoot 2.X 使用RabbitMQ实现高并发秒杀接口优化
1. 高并发秒杀接口优化思路：减少数据库访问
1.1具体实现流程：
-
系统初始化，把商品库存数量加载到Redis
-
收到请求，Redis预减库存，库存不足，直接返回，否则3
-
请求入队，立即返回排队中
-
请求出队，生成订单，减少库存
-
客户端轮询，是否秒杀成功
1.2 技术实现细节：本地标记 + redis预处理 + RabbitMQ异步下单 + 客户端轮询
1.2.1 细节描述：
- 通过三级缓冲保护，1、本地标记 2、redis预处理 3、RabbitMQ异步下单，最后才会访问数据库，这样做是为了最大力度减少对数据库的访问。
- 实现：
- 系统初始化，把商品库存数量stock加载到Redis
- 服务器接收秒杀请求，在秒杀阶段使用本地标记localOverMap（goodsId，boolean）对秒杀商品做标记，若被标记为true，表明商品秒杀完毕，直接返回秒杀结束，未被标记为true才查询redis，通过本地标记来减少对redis的访问
- Redis预减库存，如果库存已经到达临界值的时候，直接返回失败，即后面的大量请求无需给系统带来压力，通过Redis预减少库存减少数据库访问
- 通过redis缓存判断这个秒杀订单形成没有，避免同一用户重复秒杀。如果是重复秒杀，则需要对Redis的预减库存进行回增，并重重置本地标记localOverMap为false。
- 为了保护系统不受高流量的冲击而导致系统崩溃的问题，使用RabbitMQ用异步队列处理下单，实际做了一层缓冲保护，做了一个窗口模型，窗口模型会实时的刷新用户秒杀的状态。
- 后端RabbitMQ监听秒杀MIAOSHA_QUEUE的这名字的通道，如果有消息过来，获取到传入的信息，执行真正的秒杀之前，要判断数据库的库存，判断是否重复秒杀，然后执行秒杀事务（减库存，下订单，写入秒杀订单），秒杀订单还需要写到Redis中，方便判断是否重复秒杀。
- 客户端根据商品id用js轮询接口，用来获取处理状态
2.代码实现
2.1 系统初始化，把商品库存数量加载到Redis
- 通过重写InitializingBean接口中的一个方法:afterPropertiesSet()，系统初始化会首先调用该函数：
/**
* 系统初始化时，加载秒杀商品库存到redis
* 如果商品库存不为0，则让本地内存标记为false，
* @throws Exception
*/
@Override
public void afterPropertiesSet() throws Exception {
List<GoodsVo> goodList = goodsService.listGoodsVo();
if(goodList == null){
return ;
}
for(GoodsVo goodsVo : goodList){
redisService.set(GoodsKey.getMiaoshaGoodsStock,"" + goodsVo.getId(), goodsVo.getStockCount());
if(goodsVo.getStockCount() > 0) {
localOverMap.put(goodsVo.getId(), false);
}else{
localOverMap.put(goodsVo.getId(), true);
}
}
}
@Service
public class GoodsService {
@Autowired
GoodsDao goodsDao;
public List<GoodsVo> listGoodsVo() {
return goodsDao.listGoodsVo();
}
public GoodsVo getGoodsVoByGoodsId(long goodsId) {
return goodsDao.getGoodsVoByGoodsId(goodsId);
}
public boolean reduceStock(GoodsVo goods) {
MiaoshaGoods g = new MiaoshaGoods();
g.setGoodsId(goods.getId());
return goodsDao.reduceStock(g) > 0 ;
}
}
@Mapper
public interface GoodsDao {
//连接查询
@Select("select g.*,mg.stock_count,mg.start_date,mg.end_date,mg.miaosha_price from miaosha_goods mg left join goods g on mg.goods_id=g.id")
public List<GoodsVo> getGoodsVoList();
}
2.2 RabbitMQ队列的实现
2.2.1 MQConfig，使用Direct交换机模式
@Configuration
public class MQConfig {
public static final String MIAOSHA_QUEUE = "miaosha.queue";
@Bean
public Queue queue() {
return new Queue(MIAOSHA_QUEUE, true);
}
2.2.2 MQSender 将用户信息和商品信息封装起来传入队列
- 消息队列这里，消息只能传字符串，MiaoshaMessage 这里是个Bean对象，是先用beanToString方法，将转换为String，放入队列，使用AmqpTemplate传输
@Service
public class MQSender {
@Autowired
AmqpTemplate amqpTemplate;
private static Logger log = LoggerFactory.getLogger(MQSender.class);
public void sendMiaoshaMessage(MiaoshaMessage message) {
String msg = RedisService.beanToString(message);
log.info("send message:"+msg);
amqpTemplate.convertAndSend(MQConfig.MIAOSHA_QUEUE,msg);
}
}
2.2.3 MQReceiver 请求出队，生成订单，减少库存
- 是先用stringToBean方法，将转换为MiaoshaMessage 的Bean，然后从Bean中获取use和goodsId
@Service
public class MQReceiver {
@Autowired
MiaoshaUserService userService;
@Autowired
RedisService redisService;
@Autowired
GoodsService goodsService;
@Autowired
OrderService orderService;
@Autowired
MiaoshaService miaoshaService;
private static Logger log = LoggerFactory.getLogger(MQReceiver.class);
@RabbitListener(queues=MQConfig.MIAOSHA_QUEUE)
public void receive(String message){
log.info("receive message :" + message);
MiaoshaMessage message1 = RedisService.stringToBean(message,MiaoshaMessage.class);
MiaoshaUser user = message1.getUser();
long goodsId = message1.getGoodsId();
//判断库存
GoodsVo goods = goodsService.getGoodsVoByGoodsId(goodsId);
int stock = goods.getStockCount();
if(stock <=0){
return ;
}
//判断是否重复秒杀到
MiaoshaOrder order = orderService.getMiaoshaOrderByUserIdGoodsId(user.getId(),goodsId);
if(order != null){
return ;
}
减库存 下订单 写入秒杀订单
miaoshaService.miaosha(user, goods);
}
}
2.2.4 MiaoshaMessage 消息的封装类，将user和goodsId封装进行传输
public class MiaoshaMessage {
private MiaoshaUser user;
private long goodsId;
public MiaoshaUser getUser() {
return user;
}
public void setUser(MiaoshaUser user) {
this.user = user;
}
public long getGoodsId() {
return goodsId;
}
public void setGoodsId(long goodsId) {
this.goodsId = goodsId;
}
}
2.3 Controller层：本地标记 + redis预处理 + RabbitMQ异步下单
@RequestMapping(value = "/{path}/do_miaosha", method = RequestMethod.POST)
@ResponseBody
public Result<Integer> miaosha(Model model, MiaoshaUser user,
@RequestParam("goodsId")long goodsId,
@PathVariable("path")String path) {
if(user == null){
return Result.error(CodeMsg.SESSION_ERROR);//return "login";
}
model.addAttribute("user", user);
//内存标记，减少redis访问
boolean isOver = localOverMap.get(goodsId);
if(isOver){
return Result.error(CodeMsg.MIAOSHA_OVER);
}
//reids预减库存
long stock = redisService.decr(GoodsKey.getMiaoshaGoodsStock,""+goodsId);
if(stock < 0){
localOverMap.put(goodsId,true);
return Result.error(CodeMsg.MIAOSHA_OVER);
}
logger.info("判断是否重复秒杀次数："+ time++);
//判断是否重复秒杀到
MiaoshaOrder order = orderService.getMiaoshaOrderByUserIdGoodsId(user.getId(),goodsId);
if(order != null){
//重复秒杀时需要把预减的库存加回去，并重置localOverMap
redisService.incr(GoodsKey.getMiaoshaGoodsStock,"" + goodsId);
localOverMap.put(goodsId,false);
return Result.error(CodeMsg.REPEATE_MIAOSHA);
}
//压入RabbitMQ队列
MiaoshaMessage message = new MiaoshaMessage();
message.setUser(user);
message.setGoodsId(goodsId);
sender.sendMiaoshaMessage(message);
return Result.success(0); //排队中
}
2.4 客户端轮询
2.4.1 前端代码修改 设置200ms轮询一次服务端，获取秒杀结果
function getMiaoshaResult(goodsId){
g_showLoading();
$.ajax({
url:"/miaosha/result",
type:"GET",
data:{
goodsId:$("#goodsId").val(),
},
success:function(data){
if(data.code == 0){
var result = data.data;
if(result < 0){
layer.msg("对不起，秒杀失败");
}else if(result == 0){//继续轮询
setTimeout(function(){
getMiaoshaResult(goodsId);
}, 200);
}else{
layer.confirm("恭喜你，秒杀成功！查看订单？", {btn:["确定","取消"]},
function(){
window.location.href="/order_detail.htm?orderId="+result;
},
function(){
layer.closeAll();
});
}
}else{
layer.msg(data.msg);
}
},
error:function(){
layer.msg("客户端请求有误");
}
});
}
2.4.2 后端Controller层
- 成功返回orderId，失败返回-1，排队中返回0
/**
* @return orderId：成功
* @return -1：秒杀失败
* @return 0： 排队中
*/
@RequestMapping(value = "/result", method = RequestMethod.GET)
@ResponseBody
public Result<Long> miaoshaResult(Model model, MiaoshaUser user,
@RequestParam("goodsId") long goodsId) {
model.addAttribute("user", user);
if (user == null) {
return Result.error(CodeMsg.SESSION_ERROR);
}
long orderId = miaoshaService.getMiaoshaResult(user.getId(), goodsId);
return Result.success(orderId);
}
2.4.3 后端Service层
- miaosha中若果商品库存为0，则在缓存中写入setGoodsOver(goods.getId());
- 获取秒杀结果时，如果通过userId和goodsId在缓存中查询到订单，则返回订单，如果订单为空,则getGoodsOver(goodsId)判断库存是否为空，如果为空，返回-1，否则返回0
//保证这三个操作，减库存 下订单 写入秒杀订单是一个事物
@Transactional
public OrderInfo miaosha(MiaoshaUser user, GoodsVo goods) {
boolean success = goodsService.reduceStock(goods);
if (success){
//下订单 写入秒杀订单
return orderService.createOrder(user, goods);
}else {
setGoodsOver(goods.getId());
return null;
}
}
public long getMiaoshaResult(Long userId, long goodsId) {
MiaoshaOrder order = orderService.getMiaoshaOrderByUserIdGoodsId(userId,goodsId);
if(order != null){
return order.getOrderId();
}else{
boolean isOver = getGoodsOver(goodsId);
if(isOver){
return -1;
}else{
return 0;
}
}
}
private void setGoodsOver(Long goodsId) {
redisService.set(MiaoshaKey.isGoodsOver,""+goodsId,true);
}
private boolean getGoodsOver(Long goodsId) {
return redisService.exists(MiaoshaKey.isGoodsOver,""+goodsId);
}
public MiaoshaOrder getMiaoshaOrderByUserIdGoodsId(long userId, long goodsId) {
return redisService.get(OrderKey.getMiaoshaOrderByUidGid,""+userId+"_"+goodsId,MiaoshaOrder.class);
}
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
