【5】Redis从入门到放弃---秒杀案例（Redis的事务+锁机制+lua脚本）

/**
 * 秒杀案例，一个用户只能秒杀成功一次
 */
@RestController
@RequestMapping("/testRedisSeckill")
public class TestRedisSeckillController {

    @Autowired
    private RedisTemplate redisTemplate;


    @GetMapping("/doSeckill")
    public boolean doSeckill() throws IOException {
        String usrId = new Random().nextInt(50000) + "";
        return doSeckillFun(usrId, "20210731");
    }
}

/**
     * 秒杀过程1（高并发下会超卖）
     *
     * @param usrId 用户id
     * @param atcId 活动id
     * @return
     * @throws IOException
     */
    private boolean doSeckillFun(String usrId, String atcId) throws IOException {
        //1.参数校验
        if (usrId == null || atcId == null) return false;

        //2.设置Redis值（库存key== atcId:stock, 秒杀成功用户key== atcId:userId）
        String stockKey = atcId + ":stock";
        String userIdKey = atcId + ":userId";

        //3.获取库存，如果库存是空,秒杀还没开始
        Object stock = redisTemplate.opsForValue().get(stockKey);//获取库存
        if (stock == null) {
            System.out.println("别着急，秒杀还没开始呢！！");
            return false;
        }

        //4.判断用户是否重复秒杀操作(Set类型操作)
        if (redisTemplate.opsForSet().isMember(userIdKey, usrId)) {
            System.out.println("你已经秒杀成功了，不能重复秒杀");
            return false;
        }

        //5.判断库存数量，小于1，秒杀结束
        int stock1 = (int) stock;
        if (stock1 < 1) {
            System.out.println("秒杀结束了。。。");
            return false;
        }

        //6.秒杀过程（库存减1，把秒杀成功用户添加到用户清单）
        redisTemplate.opsForSet().add(userIdKey, usrId);
        redisTemplate.opsForValue().decrement(stockKey);//库存-1
        System.out.println("恭喜你！秒杀成功了！");
        return true;
    }

/**
     * 秒杀过程2(乐观锁解决超卖问题)
     *
     * @param usrId 用户id
     * @param atcId 活动id
     * @return
     * @throws IOException
     */
    private boolean doSeckillFun(String usrId, String atcId) throws IOException {
        //1.参数校验
        if (usrId == null || atcId == null) return false;

        //2.设置Redis值（库存key== atcId:stock, 秒杀成功用户key== atcId:userId）
        String stockKey = atcId + ":stock";
        String userIdKey = atcId + ":userId";

        //通过 SessionCallback，保证所有的操作都在同一个 Session 中完成
        //更常见的写法仍是采用 RedisTemplate 的默认配置，即不开启事务支持。
        // 但是，我们可以通过使用 SessionCallback，该接口保证其内部所有操作都是在同一个Session中
        SessionCallback<Object> callback = new SessionCallback<Object>() {

            @Override
            public Object execute(RedisOperations operations) throws DataAccessException {
                //3. 打开事务支持
                //redisTemplate.setEnableTransactionSupport(true);

                //4.增加乐观锁进行对库存的监视
                operations.watch(stockKey);

                //5.获取库存，如果库存是空,秒杀还没开始
                Object stock = operations.opsForValue().get(stockKey);//获取库存
                if (stock == null) {
                    System.out.println("别着急，秒杀还没开始呢！！");
                    return false;
                }

                //6.判断用户是否重复秒杀操作(Set类型操作)
                if (operations.opsForSet().isMember(userIdKey, usrId)) {
                    System.out.println("你已经秒杀成功了，不能重复秒杀");
                    return false;
                }

                //7.判断库存数量，小于1，秒杀结束
                int stock1 = (int) stock;
                if (stock1 < 1) {
                    System.out.println("秒杀结束了。。。");
                    return false;
                }

                //8. 增加事务
                operations.multi();

                //9.秒杀过程
                operations.opsForValue().decrement(stockKey);//库存-1
                operations.opsForSet().add(userIdKey, usrId);//把秒杀成功用户添加到用户清单

                //10.执行事务
                List<Object> list = operations.exec();

                //11.判断事务提交是否失败
                if (list == null || list.size() == 0) {
                    System.out.println("秒杀失败");
                    return false;
                }

                System.out.println("恭喜你！秒杀成功了！");
                return true;
            }
        };

        return (boolean) redisTemplate.execute(callback);
    }

 /**
     * 秒杀过程3(LUA解决库存剩余问题)
     *
     * @param usrId 用户id
     * @param atcId 活动id
     * @return
     * @throws IOException
     */
    private boolean doSeckillFun(String usrId, String atcId) throws IOException {

        String luaScript = "local userId=KEYS[1];
" +
                "local stockKey=KEYS[2];
" +
                "local userIdKey=KEYS[3];
" +
                "local userExists=redis.call("sismember",userIdKey,userId); 
" +
                "if tonumber(userExists)==1 
" +
                "then 
" +
                "  return 2;
" +
                "end 
" +
                "local num= redis.call("get" ,stockKey);
" +
                "if tonumber(num)<=0 then   return 0;
" +
                "else 
 " +
                " redis.call("decr",stockKey);
" +
                "redis.call("sadd",userIdKey,userId);
" +
                "end 
" +
                "return 1;";

        // 指定 lua 脚本，并且指定返回值类型
        // (为什么返回值不用 Integer 接收而是用 Long。这里是因为 spring-boot-starter-data-redis 提供的返回类型里面不支持 Integer。)
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
        List<String> keys = new ArrayList<>();
        keys.add(usrId);
        keys.add(atcId + ":stock");
        keys.add(atcId + ":userId");
        // 参数一：redisScript，参数二：key列表，参数三：arg（可多个）
        Long result = (Long) redisTemplate.execute(redisScript, keys);
        if (0 == result) {
            System.out.println("秒杀结束了。。。");
        } else if (1 == result) {
            System.out.println("恭喜你！秒杀成功了！");
            return true;
        } else if (2 == result) {
            System.out.println("你已经秒杀成功了，不能重复秒杀");
        } else {
            System.out.println("秒杀异常啦~");
        }

        return false;
    }

local userId=KEYS[1];
local stockKey=KEYS[2];
local userIdKey=KEYS[3];
local userExists=redis.call("sismember",userIdKey,userId); 
if tonumber(userExists)==1
then
  return 2;
end
local num= redis.call("get" ,stockKey);
if tonumber(num)<=0 then   return 0;
else
 redis.call("decr",stockKey);
redis.call("sadd",userIdKey,userId);
end
return 1;