基于redis分布式锁_代码实现

柔光的暖阳◎ 2022-10-01 12:54 185阅读 0赞

### 1、工具类实现redis分布式锁 ###

说明，代码可以封装在工具jar中，方便各系统引用。

import com.myfutech.common.util.constant.RedisPrefix;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.data.redis.connection.RedisStringCommands;
    import org.springframework.data.redis.connection.ReturnType;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.types.Expiration;
    
    import java.nio.charset.StandardCharsets;
    import java.util.UUID;
    
    
    /**
     * 基于redis分布式锁
     */
    @Slf4j
    public class RedisLockUtils {
    
        /**
         * 默认轮休获取锁间隔时间， 单位：毫秒
         */
        private static final int DEFAULT_ACQUIRE_RESOLUTION_MILLIS = 100;
    
        private static final String UNLOCK_LUA;
    
        static {
            StringBuilder sb = new StringBuilder();
            sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
            sb.append("then ");
            sb.append("    return redis.call(\"del\",KEYS[1]) ");
            sb.append("else ");
            sb.append("    return 0 ");
            sb.append("end ");
            UNLOCK_LUA = sb.toString();
        }
    
        /**
         * 获取锁，没有获取到则一直等待，异常情况则返回null
         *
         * @param redisTemplate     redis连接
         * @param key               redis key
         * @param expire            锁过期时间, 单位 秒
         * @return                  当前锁唯一id，如果没有获取到，返回 null
         */
        public static String lock(RedisTemplate redisTemplate, final String key, long expire){
            return lock(redisTemplate, key, expire, -1);
        }
    
        /**
         * 获取锁，acquireTimeout时间内没有获取到，则返回null，异常情况返回null
         *
         * @param redisTemplate     redis连接
         * @param key               redis key
         * @param expire            锁过期时间, 单位 秒
         * @param acquireTimeout    获取锁超时时间, -1代表永不超时, 单位 秒
         * @return                  当前锁唯一id，如果没有获取到，返回 null
         */
        public static String lock(RedisTemplate redisTemplate, final String key, long expire, long acquireTimeout){
            try {
                return acquireLock(redisTemplate, key, expire, acquireTimeout);
            } catch (Exception e) {
                log.error("acquire lock exception", e);
            }
            return null;
        }
    
        /**
         * 获取锁，没有获取到则一直等待，没有获取到则抛出异常
         *
         * @param redisTemplate     redis连接
         * @param key               redis key
         * @param expire            锁过期时间, 单位 秒
         * @return                  当前锁唯一id，如果没有获取到，返回 null
         */
        public static String lockFailThrowException(RedisTemplate redisTemplate, final String key, long expire){
            return lockFailThrowException(redisTemplate, key, expire, -1);
        }
    
        /**
         * 获取锁，到达超时时间时没有获取到，则抛出异常
         *
         * @param redisTemplate     redis连接
         * @param key               redis key
         * @param expire            锁过期时间, 单位 秒
         * @param acquireTimeout    获取锁超时时间, -1代表永不超时, 单位 秒
         * @return                  当前锁唯一id，如果没有获取到，返回 null
         */
        public static String lockFailThrowException(RedisTemplate redisTemplate, final String key, long expire, long acquireTimeout){
            try {
                String lockId = acquireLock(redisTemplate, key, expire, acquireTimeout);
                if (lockId != null) {
                    return lockId;
                }
                throw new RuntimeException("acquire lock fail");
            } catch (Exception e) {
                throw new RuntimeException("acquire lock exception", e);
            }
        }
    
        private static String acquireLock(RedisTemplate redisTemplate, String key, long expire, long acquireTimeout) throws InterruptedException {
            long acquireTime = -1;
            if (acquireTimeout != -1) {
                acquireTime = acquireTimeout * 1000 + System.currentTimeMillis();
            }
            synchronized (key) {
                String lockId = UUID.randomUUID().toString();
                while (true) {
    
                    if (acquireTime != -1 && acquireTime < System.currentTimeMillis()) {
                        break;
                    }
                    //调用tryLock
                    boolean hasLock = tryLock(redisTemplate, key, expire, lockId);
    
                    //获取锁成功
                    if (hasLock) {
                        return lockId;
                    }
                    Thread.sleep(DEFAULT_ACQUIRE_RESOLUTION_MILLIS);
                }
            }
            return null;
        }
    
    
        /**
         *  释放锁
         *
         * @param redisTemplate     redis连接
         * @param key               redis key
         * @param lockId            当前锁唯一id
         */
        public static void unlock(RedisTemplate redisTemplate, String key, String lockId) {
            try {
                RedisCallback<Boolean> callback = (connection) ->
                        connection.eval(UNLOCK_LUA.getBytes(StandardCharsets.UTF_8),ReturnType.BOOLEAN, 1,
                                (RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8), lockId.getBytes(StandardCharsets.UTF_8));
                redisTemplate.execute(callback);
            } catch (Exception e) {
                log.error("release lock exception", e);
            }
        }
    
        /**
         * 获取当前锁的id
         *
         * @param key       redis key
         * @return          当前锁唯一id
         */
        public static String get(RedisTemplate redisTemplate, String key) {
            try {
                RedisCallback<String> callback = (connection) -> {
                    byte[] bytes = connection.get((RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8));
                    if (bytes != null){
                        return new String(bytes, StandardCharsets.UTF_8);
                    }
                    return null;
                };
                return (String)redisTemplate.execute(callback);
            } catch (Exception e) {
                log.error("get lock id exception", e);
            }
            return null;
        }
    
        private static boolean tryLock(RedisTemplate redisTemplate, String key, long expire, String lockId) {
            RedisCallback<Boolean> callback = (connection) ->
            connection.set((RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8),
                    lockId.getBytes(StandardCharsets.UTF_8), Expiration.seconds(expire), RedisStringCommands.SetOption.SET_IF_ABSENT);
            return (Boolean)redisTemplate.execute(callback);
        }
    }

### redis之key前缀单独定义类 ###

/**
     * redis key 前缀
     *
     *  默认key规范 数据的意义_系统编码_唯一的标识
     */
    public class RedisPrefix {
    
        /**
         * 鉴权信息 key 前缀
         */
        public static final String AUTH_REDIS_PREFIX = "UNIF_AUTH_";
    
        /**
         * 缓存信息 key 前缀
         */
        public static final String CACHE_REDIS_PREFIX = "UNIF_CACHE_";
    
        /**
         * 分布式锁信息 key 前缀
         */
        public static final String LOCK_REDIS_PREFIX = "UNIF_LOCK_";
    }

### 2、调用示例 ###

@ApiOperation(value = "新增客户更换理财顾问")
        @PostMapping("/addCustomerAdviser")
        public Long addCustomerAdviser(@Validated(CustomerAdviserModifyVO.Create.class) @RequestBody CustomerAdviserModifyVO vo) {
            String lockId = RedisLockUtils.lockFailThrowException(redisTemplate, "addCustomerAdviser", 10);
            try {
                Long num = customerAdviserService.countByCustomerIdAndAuditStatus(vo.getCustomerId(),0);
    
                if (num > 0){
                    throw new BusinessException("申请审核中，不可重复提交");
                }
                LoginUserVO userVO = UserInfoUtil.getUserInfo();
                CustomerAdviser data = new CustomerAdviser();
                BeanUtils.copyProperties(vo, data);
                data.setOptUserCode(userVO.getUserCode());
                data.setOptUserName(userVO.getRealName());
                data.setChangeTime(new Date());
                data.setAuditStatus(0);
                data = customerAdviserService.save(data);
                customerOperateLogService.save(new CustomerOperateLog(vo.getCustomerId(), "提交由"+vo.getOldAdviserUserName()+"(" + vo.getOldAdviserUserCode() +
                        ")到"+vo.getNewAdviserUserName()+"(" + vo.getNewAdviserUserCode() + ")的更换理财顾问审核申请"));
                return data.getId();
            }finally {
                RedisLockUtils.unlock(redisTemplate, "addCustomerAdviser", lockId);
            }
        }