黑马点评5——优惠券秒杀—优化秒杀

基于我们前面实现的优惠券的秒杀业务，我们接下来进行优化。

Redis优化秒杀

先回顾我们的业务流程

我们的秒杀过程中有很多个步骤都是去查询数据库，而我们知道，数据库的并发能力是比较弱的，我们该怎么做才能减少对数据库的并发压力呢？

我们可以把秒杀库存的判断、以及一人一单的校验放到redis中来做，这样可以快速的得到响应，并把得到的订单id返回给客户端，然后可以把扣减库存等操作放到阻塞队列里，使用异步线程等待阻塞队列的任务，这个异步线程可以慢慢处理。

那在redis中秒杀库存的判断、以及一人一单的校验怎么做呢？

基于Redis完成秒杀资格判断

新增秒杀优惠券的同时，将优惠券信息保存到Redis中

    @Override
    @Transactional
    public void addSeckillVoucher(Voucher voucher) {
        // 保存优惠券
        save(voucher);
        // 保存秒杀信息
        SeckillVoucher seckillVoucher = new SeckillVoucher();
        seckillVoucher.setVoucherId(voucher.getId());
        seckillVoucher.setStock(voucher.getStock());
        seckillVoucher.setBeginTime(voucher.getBeginTime());
        seckillVoucher.setEndTime(voucher.getEndTime());
        seckillVoucherService.save(seckillVoucher);
        // 保存秒杀的库存导redis中
        stringRedisTemplate.opsForValue().set(RedisConstants.SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
    }

基于lua脚本，判断秒杀库存、一人一单、决定用户是否抢购成功

-- 1. 参数列表
-- 1.1 优惠券id
local voucherId = ARGV[1]
-- 1.2 用户id
local userId = ARGV[2]

-- 2. 数据key
-- 2.1 库存key
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2 订单key
local orderKey = 'seckill:order:' .. voucherId

-- 3. 脚本业务
-- 3.1 判断库存是否充足 get stockKey
if(tonumber(redis.call('get', stockKey)) <= 0) then
    -- 3.2 库存不足，返回1
    return 1
end
-- 3.2 判断用户是否下单 SISMEMBER stockKey orderKey
if(redis.call('sismember', orderKey, userId) == 1) then
    -- 3.3 存在，说明是重复下单，返回2
    return 2
end
-- 3.4 扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5 下单（保存用户）sadd orderKey userId
redis.call('sadd', orderKey, userId)
return 0

 @Autowired
    private RedissonClient redissonClient;
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;
    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }
    @Override
    public Result seckillVoucher(Long voucherId) {
        // 获取用户
        Long userId = UserHolder.getUser().getId();
        // 1. 执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(),
                userId.toString()
        );
        // 2. 判断结果是否为0
        int r = result.intValue();
        if(result != 0){
            // 2.1 不为0， 代表没有购买资格
            return Result.fail(r == 1 ? "库存不足": "不能重复下单");
        }
        // 2.2 为0， 有购买资格，把下单信息保存导阻塞队列
        long orderId = redisIdWorker.nextId("order");
        // TODo 保存阻塞队列

        // 3.返回订单id
        return Result.ok(orderId);
    }

如果抢购成功，将优惠券id和用户id封装后存入阻塞队列

开启线程任务，不断从阻塞队列中获取信息，实现异步下单功能

@Slf4j
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

    @Autowired
    private ISeckillVoucherService seckillVoucherService;

    @Autowired
    private RedisIdWorker redisIdWorker;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedissonClient redissonClient;
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;
    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

    private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);  // 阻塞队列
    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();  // 单线程的线程池


    @PostConstruct // 当前类初始化完毕后执行
    private void init(){
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }
    // 这个任务必须在这个类初始化之后就得执行，用spring提供的注解实现PostConstruct实现
    private class VoucherOrderHandler implements Runnable{  // 线程任务，通过内部类来实现
        @Override
        public void run() {  // 这里就不断的从阻塞队列里取，然后执行
            while(true){
                try{
                    // 1. 获取队列中的订单信息
                    VoucherOrder voucherOrder = orderTasks.take();
                    // 2. 创建订单
                    handlerVoucherOrder(voucherOrder);
                }catch (Exception e){
                    log.error("处理订单异常",e);
                }
            }
        }
    }

    private void handlerVoucherOrder(VoucherOrder voucherOrder) {
        // 1.获取用户
        Long userId = voucherOrder.getUserId();
        // 2.创建锁对象
        RLock lock = redissonClient.getLock("lock:oder:" + userId);  // 使用Redisson获取锁
        // 3.获取锁
        boolean isLock = lock.tryLock();
        // 4.判断是否获取锁成功
        if(!isLock){
            // 获取锁失败，返回错误信息或重试
            log.error("不允许重复下单");
            return;
        }
        try{
            // 获取代理对象（事务）
            proxy.createVoucherOrder(voucherOrder);
        }finally{
            // 释放锁
            lock.unlock();
        }
    }

    private IVoucherOrderService proxy;

    @Override
    public Result seckillVoucher(Long voucherId) {
        // 获取用户
        Long userId = UserHolder.getUser().getId();
        // 1. 执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(),
                userId.toString()
        );
        // 2. 判断结果是否为0
        int r = result.intValue();
        if(result != 0){
            // 2.1 不为0， 代表没有购买资格
            return Result.fail(r == 1 ? "库存不足": "不能重复下单");
        }
        // 2.2 为0， 有购买资格，把下单信息保存导阻塞队列
        // 创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 2.3 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 2.4 用户id
        voucherOrder.setUserId(userId);
        // 2.5 代金券id
        voucherOrder.setVoucherId(voucherId);
        // 2.6 放入阻塞队列
        orderTasks.add(voucherOrder);
        // 3. 获取代理对象
        proxy = (IVoucherOrderService) AopContext.currentProxy();
        // 3.返回订单id
        return Result.ok(orderId);
    }

    /**
     * 事务加在这，就失效了，为什么呢？
     * 加载这是对createVoucherOrder函数加了事务，没有给seckillVoucher函数加事务，而seckillVoucher函数调用的时候
     * createVoucherOrder(voucherId);
     * 这样使用this调用的，这个this拿到的是当前的VoucherOrderServiceImpl对象
     * 而不是VoucherOrderServiceImpl的代理对象
     * 而事务要想生效，是spring对当前这个类做了动态代理，拿到代理对象做的事务处理
     * 而我们当前的this是非代理对象，这就是事务失效的几种可能性之一
     * 解决方法之一：
     * AopContext.currentProxy()拿到代理对象来调用createVoucherOrder
     *
     * 当然这样解决还得做两件事：
     * 1. 引入aspectj的依赖
     * 2. 启动类添加注解@EnableAspectJAutoProxy(exposeProxy = true)暴露代理对象
     */
    @Transactional
    public void createVoucherOrder(VoucherOrder voucherOrder){
        // 5. 一人一单
//        Long userId = UserHolder.getUser().getId();
        Long userId = voucherOrder.getUserId();
        // 5.1 查询订单
        Integer count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();
        // 5.2 判断是否存在
        if(count > 0){
            log.error("用户已经购买过一次！");
            return;
        }

        // 6.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherOrder.getVoucherId())
                .gt("stock",0)   // 把判断条件改成库存大于0就可以避免乐观锁的弊端
                .update();

        if(!success){
            log.error("库存不足！");
            return;
        }
        // 7.创建订单
        save(voucherOrder);
    }
}

至此，我们的秒杀优化的思路就初步实现了，其实就是把同步处理的业务，分两部分，然后异步执行

1. 我们在jdk中搞了个阻塞队列，这个阻塞队列会不会引起Java虚拟机内存溢出呢？
2. 我们基于内存保存这些订单信息，要是服务宕机了，订单信息丢了怎么办呢？

那且看下章