Redis锁幂处理

---

学习xx框架整理Redis幂处理

---

研究来下xx框架的幂等性处理，下面给简单记录下

---

一、幂等性是什么？

官方解释：在编程中一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同
我的解释：其实就是增删改的时候，用户同一时间点击了几次操作，而我们需要控制的是将几次化为一次的结果

二、幂等性的意义

在很多企业级应用比较广泛，例如：订单支付时由于网络原因，用户多点击几次支付，如果点几次扣几次，那软件注定要凉凉了

三、核心代码

1.Redis

@Component
@Slf4j
public class RedisService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     *
     * @param key
     * @return roger:lock:key
     */
    private String globalLockKey(String key) {
        return "roger:lock:" + key;
    }

    /**
     * 加锁方式1
     * 默认尝试一次
     * 默认加锁3s
     *
     * @param key
     */
    public boolean lock(String key) {
        return lock(key, 1, 3);
    }

    /**
     * 加锁方式2
     *
     * @param key       需加锁的键
     * @param retryTime 尝试次数
     * @param lockTime  加锁时间
     */
    public boolean lock(String key, int retryTime, long lockTime) {
        String rKey = globalLockKey(key);
        boolean lock = lockEvent(rKey, retryTime, lockTime);
        return lock;
    }
	 /**
     * 解锁
     * @param key
     */
    public void unlock(String key) {
        String rKey = globalLockKey(key);
        AssertUtil.notNull(redisTemplate, "未注入StringRedisTemplate");
        redisTemplate.delete(rKey);
        log.debug("解锁[{}]完成", rKey);
    }

    public boolean lockEvent(String key, int retryTime, long lockTime) {
        if (retryTime > 0 && lockTime <= 0L) {
            lockTime = 5L;
        }
        AssertUtil.notNull(redisTemplate, "未注入StringRedisTemplate");
        //循环加锁累加次数-->循环加锁次数超过你规定的加锁次数就返回false
        int count = 0;
        ValueOperations<String, String> ops = redisTemplate.opsForValue();
        while (true) {
            count++;
            Boolean locked;
            // 看参数加锁时间是否正确，然后给该key设置该加锁时间
            if (lockTime > 0) {
                locked = ops.setIfAbsent(key, key, lockTime, TimeUnit.SECONDS);
            } else {
                // 如果传入的时间不合法，或者是不知道程序会执行多久，因此就不设置加锁时间，锁还是有的，伴随程序执行完而结束
                locked = ops.setIfAbsent(key, key);
            }
            //redis中添加成功 ===加锁成功====  退出循环
            if (Boolean.TRUE.equals(locked)) {
                break;
            }
            // ====下面就是加锁失败=====
            log.debug("加锁:[{}]失败-----尝试次数[{}]", key, count);
            // 传入的加锁尝试次数为0，不符合要求直接返回false
            if (retryTime == 0) {
                return false;
            }
            // 循环次数超过设置的加锁次数，就不能尝试了，返回false跳出循环
            if (retryTime > 0 && count > retryTime) {
                return false;
            }
            //每次循环加锁等待0.5s   差不多0.5s，可能其他程序执行完并删除了该key的redis，就能加锁成功了
            try {
                Thread.sleep(500L);
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.error("错误信息：", e);
                Thread.currentThread().interrupt();
                return false;
            }
        }
        log.debug("加锁:[{}]成功-----尝试次数[{}]", key, count);
        return true;
    }

    /**
     * 获取缓存数据
     */
    public String getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取缓存数据
     */
    public void setValue(String key, String value) {
        redisTemplate.opsForValue().set(key, value, 90L, TimeUnit.MINUTES);
    }

}

2.在项目中运用

代码如下（示例）：

    @Override
    public Integer updateOrderOne(OrderVO orderVO) {
        int orderId = orderVO.getId();
        String key = String.format("updateOrderOne:%s", orderId);
        boolean lock = redisService.lock(key, 1, 5);
        AssertUtil.isTrue(lock,"请勿重复修改");
        // 这里是模拟程序执行很久
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Integer integer = orderMapper.updateOne(orderVO);
        redisService.unlock(key);
        return integer;
    }

---