实战篇-25.Redis消息队列-认识消息队列_哔哩哔哩_bilibili
1.消息队列和阻塞队列不同
1）消息队列不在jvm里，所以内存不受jvm限制，避免内存溢出的风险。
2）消息队列会自己持久化，保证数据安全。避免因为服务宕机或者重启导致阻塞队列里的订单消失。
3）消息队列给消费者消息的时候会要求确认（签收），否则算没收到，下次继续给，确保每个消息至少被消费一次。
2List结构
Redis的list是一个双向链表，
BLPUSH和BRPOP在存取的时候会自动阻塞
3.PubSub
可以让一个消息被单个消费者拿到，也可以被多个消费者拿到
4.Stream类型
4.1单消费模式
4.1.1写
4.1.2读
Stream读完消息不会删除，所以自己和别人还能重复读取
4.2消费组模式
5.用Stream的消息队列
原来是用lua脚本进行资格判断，然后在java中对阻塞队列发消息。
现在因为用stream做消息队列，他也是在redis里的，所以可以直接在lua脚本里对Stream发消息，这样java的功能更简化了，能减少一次和redis的交互。
既然要给消息队列发，就要知道消息队列的队列号，传参要多传一个。
---资格判断，库存判断，以及对消息队列Stream发消息等一系列redis操作
--1.参数列表
--1.1优惠券id
local voucherId = ARGV[1]
--1.2用户id
local userId = Argv[2]
--1.3订单id
local orderId = ARGV[3]
--2.数据key
--2.1库存key
local stockKey = "seckill:stock" .. voucherId
--2.2订单key
local orderKey = "seckill:order" .. voucherId
--3.脚本业务
--3.1判断库存是否充足 get stock
if (tonumber(redis.call('get', stockKey)) <= 0) then
--库存不足返回1
return 1
end
--3.2判断用户是否下单
if (redis.call('sismember', orderKey, userId) == 1) then
--存在，返回2
return 2
end
--3.3扣库存incrby stockKey -1
redis.call('incrby', stockKey, -1)
--3.4下单，保存用户信息 sadd orderKey userId
redis.call('sadd', orderKey, userId)
--3.5 发送消息到redis stream队列，xadd stream.orders * k1 v1 k2 v2......
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0
package com.hmdp.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.dto.Result;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.UserHolder;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.aop.framework.AopContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.connection.stream.*;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.time.Duration;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* <p>
* 服务实现类
* </p>
*/
/*
* 主要是
* 读取的lua脚本
* 取消息队列的线程
*
*/
@Slf4j
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Resource
private ISeckillVoucherService seckillVoucherService;
//制造订单号
@Resource
private RedisIdWorker redisIdWorker;
@Resource
private StringRedisTemplate stringRedisTemplate;
//分布式锁
@Resource
private RedissonClient redissonClient;
//线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();
private IVoucherOrderService proxy;
private static final DefaultRedisScript<Long> SECKILL_SCRIPT;
//lua脚本资源
static {
SECKILL_SCRIPT = new DefaultRedisScript<>();
SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
SECKILL_SCRIPT.setResultType(Long.class);
}
//刚开始类加载就调用
@PostConstruct
private void init() {
SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}
//线程功能（去消息队列取消息下订单）
private class VoucherOrderHandler implements Runnable {
//消息队列的名字“orders”
String queueName = "stream.orders";
//取消息下订单
@Override
public void run() {
while (true) {
try {
//1.获取redis消息队列中的订单信息 XREADGROUP group g1 c1 count 1 block 2000 stream.orders >
List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
Consumer.from("g1", "c1"),
StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
StreamOffset.create(queueName, ReadOffset.lastConsumed())
);
//2.判断是否获取成功
if (list == null || list.isEmpty()) {
//获取失败，再来一次
continue;
}
//3.解析消息的订单信息
MapRecord<String, Object, Object> record = list.get(0);
Map<Object, Object> values = record.getValue();
VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(values, new VoucherOrder(), true);
//3.创建订单存到数据库
handleVoucherOrder(voucherOrder);
//4.ACK确认 SACK stream.orders g1 id
stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", record.getId());
} catch (Exception e) {
log.error("处理订单异常");
handlePendingList();
}
}
}
//出现异常处理pendinglist
private void handlePendingList() {
while (true) {
try {
//1.获取pendingList中的订单信息 XREADGROUP group g1 c1 count 1 stream.orders 0
List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
Consumer.from("g1", "c1"),
StreamReadOptions.empty().count(1),
StreamOffset.create(queueName, ReadOffset.from("0"))
);
//2.判断是否获取成功
if (list == null || list.isEmpty()) {
//获取失败，pendList没有信息结束循环
break;
}
//3.解析消息的订单信息
MapRecord<String, Object, Object> record = list.get(0);
Map<Object, Object> values = record.getValue();
VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(values, new VoucherOrder(), true);
//3.创建订单存到数据库
handleVoucherOrder(voucherOrder);
//4.ACK确认 SACK stream.orders g1 id
stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", record.getId());
} catch (Exception e) {
log.error("处理pendList异常");
try {
Thread.sleep(20);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}
}
/*
*
private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(10224 * 1024);
private class VoucherOrderHandler implements Runnable {
@Override
public void run() {
while (true) {
try {
//1.获取队列中的信息
VoucherOrder voucherOrder = orderTasks.take();
//2.创建订单存到数据库
handleVoucherOrder(voucherOrder);
} catch (InterruptedException e) {
log.error("处理订单异常");
}
}
}
}
*/
//加Redisson分布式锁
//加锁成功调用 下面的创建订单函数
private void handleVoucherOrder(VoucherOrder voucherOrder) {
//1.1获取用户id
Long userId = voucherOrder.getUserId();
//自己定义的SimpleRedisLock锁类
//SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
//使用的redisson获取的锁类
//1.2创建锁对象
RLock lock = redissonClient.getLock("lock:order:" + userId);
//1.3获取锁
boolean isLock = lock.tryLock();
//1.4判断获取锁是否成功
if (!isLock) {
//获取锁失败，返回错误
log.error("不允许重复下单");
return;
}
try {
proxy.createVoucherOrder(voucherOrder);
} finally {
//3.释放锁
lock.unlock();
}
}
/*
* 除了下面seckillVoucher其他都是线程里的操作
* 以下是redis判断的操作seckillVoucher
* */
//调用lua脚本判断资格，发送消息
@Override
public Result seckillVoucher(Long voucherId) {
//1.1获取用户id
Long userId = UserHolder.getUser().getId();
//获取订单id
long orderId = redisIdWorker.nextId("order");
//1.2执行lua脚本
Long result = stringRedisTemplate.execute(
SECKILL_SCRIPT,
Collections.emptyList(),
voucherId.toString(), userId.toString(), String.valueOf(orderId)
);
//2.判断执行结果是否为0
int r = result.intValue();
if (r != 0) {
//2.1不为0，没有购买资格
return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
}
//4.2获取代理对象（确保事务Transactional生效，保证createVoucherOrder 提交完事务之后再释放锁）
proxy = (IVoucherOrderService) AopContext.currentProxy();
//5返回订单id
return Result.ok(orderId);
}
/*
*
@Override
public Result seckillVoucher(Long voucherId) {
//1.1获取用户id
Long userId = UserHolder.getUser().getId();
//1.2执行lua脚本
Long result = stringRedisTemplate.execute(
SECKILL_SCRIPT,
Collections.emptyList(),
voucherId.toString(), userId.toString()
);
//2.判断执行结果是否为0
int r = result.intValue();
if (r != 0) {
//2.1不为0，没有购买资格
return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
}
//3--4为0，有购买资格，把下单信息保存到阻塞队列中
//3.创建订单
VoucherOrder voucherOrder = new VoucherOrder();
//3.1订单id
long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
//3.2保存用户id
voucherOrder.setUserId(userId);
//3.3优惠券id
voucherOrder.setVoucherId(voucherId);
//4.保存订单信息
//4.1放入阻塞队列
orderTasks.add(voucherOrder);
//4.2获取代理对象（确保事务Transactional生效，保证createVoucherOrder 提交完事务之后再释放锁）
proxy = (IVoucherOrderService) AopContext.currentProxy();
//5返回订单id
return Result.ok(orderId);
}
*/
/*
*
@Override
public Result seckillVoucher(Long voucherId) {
//1.查询优惠卷
SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
//2.判断秒杀是否开始
if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
//尚未开始
return Result.fail("秒杀尚未开始");
}
//3.判断秒杀是否已经结束
if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
//已经结束
return Result.fail("秒杀已经结束");
}
//4.判断库存是否充足
if (voucher.getStock() < 1) {
return Result.fail("库存不足");
}
//5.查询用户id
Long userId = UserHolder.getUser().getId();
//6.对相同用户id的操作加锁，防止并行执行，一人多单
//6.1创建锁对象
//自己定义的SimpleRedisLock锁类
//SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
//使用的redisson获取的锁类
RLock lock = redissonClient.getLock("lock:order:" + userId);
//6.2获取锁
boolean isLock = lock.tryLock();
//6.3判断获取锁是否成功
if (!isLock) {
//获取锁失败，返回错误
return Result.fail("一个用户只能下一单");
}
try {
//7获取代理对象（确保事务Transactional生效，保证createVoucherOrder 提交完事务之后再释放锁）
IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
return proxy.createVoucherOrder(voucherId);
} finally {
//8.释放锁
lock.unlock();
}
}
*/
//创建mysql订单方法，被加Redisson锁方法调用
@Transactional
public void createVoucherOrder(VoucherOrder voucherOrder) {
//1.一人一单判断
Long userId = voucherOrder.getUserId();
//1.1查询订单 判断存在用户id和优惠券id
Integer count = query().eq("user_id", userId)
.eq("voucher_id", voucherOrder.getVoucherId())
.count();
//1.2判断是否存在
if (count > 0) {
log.error("用户已经购买过一次");
return;
}
//2.扣减库存 乐观锁
boolean success = seckillVoucherService.update()
.setSql("stock = stock - 1") //set stock = stock-1
.eq("voucher_id", voucherOrder.getVoucherId()) //where voucher_id==voucherId
.gt("stock", 0) //where stock >0
.update();
if (!success) {
//扣减失败
log.error("库存不足！");
return;
}
//插入数据
save(voucherOrder);
}
}6.整体业务流程
6.1 redis判断流程
1.首先获取订单id和用户id，调用lua脚本进行redis操作，lua内包括 对购买资格/库存充足的判断 、 扣库存下单、发送订单消息到Stream。
2.Stream组成消息队列，有异常自动放到pending-list
6.2线程流程
1.线程读取消息队列（read消息队列），如果能不能读到消息，就继续读；如果读到了订单消息，就解析消息内容，调用下单函数3写入数据库，然后回复确认ack；如果出现了异常，就去处理penging-list 步骤2。
2.处理penging-list，解析消息，下单，处理；如有异常，重复循环继续处理；直到处理完跳出。
3. 加Redisson分布式锁，调用创建订单数据库操作。
831
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
