RedisLock 锁注解，基于springboot2.0.4，lettuce

最近因为业务需要用到加锁，所以就想用redis锁，因为对于业务来说，redis锁已经能够满足需求了。

但是，因为需要很多地方需要用到加锁，项目又是基于springboot，所以，就想写个springboot-starter，然后封装个注解，需要的项目中只要引入starter，并且在需要加锁的方法上加上注解就可以了。

1、添加pom依赖

    
      org.springframework.boot
      spring-boot-autoconfigure
    
    
      org.springframework.boot
      spring-boot-starter-aop
    
    
      org.springframework.boot
      spring-boot-starter-data-redis
    
    
      org.apache.commons
      commons-lang3
    
    
      org.apache.commons
      commons-pool2
    

2、定义锁注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisLock {

    /**
     * 锁key
     */
    String key() default "";

    /**
     * key前缀
     */
    String prefix() default "";

    /**
     * 过期时间，单位毫秒
     */
    long expire() default 15000;

    /**
     * 重试次数
     */
    int retryTimes() default 0;

    /**
     * 重试间隔,单位毫秒
     */
    int retryInterval() default 1000;

    /**
     * 绑定类型(作用于key的生成)
     */
    BindType bindType() default BindType.DEFAULT;

    /**
     * 绑定参数索引，从0开始，与 bindType.ARGS_INDEX 组合使用
     */
    int[] bindArgsIndex() default 0;

    /**
     * 对象参数属性 示例：ClassName.field, 与bingType.OBJECT_PROPERTIES 组合使用
     */
    String[] properties() default "";

    /**
     * 失败策略
     */
    ErrorStrategy errorStrategy() default ErrorStrategy.THROW_EXCEPTION;

    /**
     * 参数key绑定类型
     */
    enum BindType {
        /**
         * 默认，将所有参数toString
         */
        DEFAULT,
        /**
         * 参数索引，从0开始
         */
        ARGS_INDEX,
        /**
         * 对象属性
         */
        OBJECT_PROPERTIES;
    }


    /**
     * 获取锁失败策略
     */
    enum ErrorStrategy {
        /**
         * 抛异常
         */
        THROW_EXCEPTION,

        /**
         * 返回NULL
         */
        RETURN_NULL;
    }

}

3、定义加锁逻辑

@Slf4j
public class DistributedRedisLock {

    private RedisTemplate redisTemplate;

    private ThreadLocal lockKey = new ThreadLocal<>();

    public 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();
    }

    public DistributedRedisLock(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 加锁
     * @param key 锁key
     * @param expire 过期时间
     * @param retryTimes 重试次数
     * @param retryInterval 重试间隔
     * @return true 加锁成功， false 加锁失败
     */
    public boolean lock(String key, long expire, int retryTimes, long retryInterval) {
        boolean result = setRedisLock(key, expire);
        /**
         * 如果获取锁失败，进行重试
         */
        while((!result) && retryTimes-- > 0){
            try {
                log.info("lock failed, retrying..." + retryTimes);
                Thread.sleep(retryInterval);
            } catch (InterruptedException e) {
                return false;
            }
            result = setRedisLock(key, expire);
        }
        return result;
    }

    /**
     * 释放锁
     * @param key 锁key
     * @return true 释放成功， false 释放失败
     */
    public boolean unLock(String key) {
        /**
         * 释放锁的时候，有可能因为持锁之后方法执行时间大于锁的有效期，此时有可能已经被另外一个线程持有锁，所以不能直接删除
         * 使用lua脚本删除redis中匹配value的key，可以避免由于方法执行时间过长而redis锁自动过期失效的时候误删其他线程的锁
         */
        try {
            RedisCallback callback = (connection) -> {
                String value = lockKey.get();
                return connection.eval(UNLOCK_LUA.getBytes(), ReturnType.BOOLEAN ,1, key.getBytes(), value.getBytes());
            };
            return redisTemplate.execute(callback);
        } catch (Exception e) {
            log.error("release lock occured an exception", e);
        } finally {
            lockKey.remove();
        }
        return false;
    }

    /**
     * 设置redis锁
     * @param key  锁key
     * @param expire 过期时间
     * @return true 设置成功，false 设置失败
     */
    private boolean setRedisLock(String key, long expire) {
        try {
            RedisCallback callback = (connection) -> {
                String uuid = UUID.randomUUID().toString();
                lockKey.set(uuid);
                return connection.set(key.getBytes(), uuid.getBytes(), Expiration.milliseconds(expire), RedisStringCommands.SetOption.SET_IF_ABSENT);
            };
            return redisTemplate.execute(callback);
        }catch (Exception e){
            log.error("set redis error", e);
        }
        return false;
    }


}

4、定义redis锁切面

@Slf4j
@Aspect
public class DistributedRedisLockAspect {

    private DistributedRedisLock distributedRedisLock;

    public DistributedRedisLockAspect(DistributedRedisLock distributedRedisLock){
        this.distributedRedisLock = distributedRedisLock;
    }

    @Pointcut("@annotation(com.springboot.starter.redis.annotation.RedisLock)")
    private void redisLockPoint(){}

    @Around("redisLockPoint() && @annotation(redisLock)")
    public Object around(ProceedingJoinPoint pjp, RedisLock redisLock) throws Throwable {
        String key = redisLock.key();
        if(StringUtils.isBlank(key)){
            Object[] args = pjp.getArgs();
            if(redisLock.bindType().equals(RedisLock.BindType.DEFAULT)){
                key = StringUtils.join(args);
            }else if(redisLock.bindType().equals(RedisLock.BindType.ARGS_INDEX)){
                key = getArgsKey(redisLock, args);
            }else if(redisLock.bindType().equals(RedisLock.BindType.OBJECT_PROPERTIES)){
                key = getObjectPropertiesKey(redisLock, args);
            }
        }
        Assert.hasText(key, "key does not exist");
        String prefix = redisLock.prefix();
        boolean lock = distributedRedisLock.lock(prefix + key, redisLock.expire(), redisLock.retryTimes(), redisLock.retryInterval());
        if(!lock) {
            log.error("get lock failed : " + key);
            if(redisLock.errorStrategy().equals(RedisLock.ErrorStrategy.THROW_EXCEPTION)){
                throw new RedisLockException("Get redis lock failed");
            }
            return null;
        }
        log.info("get lock success : {}" ,key);
        try {
            return pjp.proceed();
        }finally {
            boolean result = distributedRedisLock.unLock(prefix + key);
            log.info("release lock : {} {}", prefix + key ,result ? " success" : " failed");
        }
    }

    /**
     * 通过绑定的args生成key
     * @param redisLock redisLock注解
     * @param args 所有参数
     * @return key
     */
    private String getArgsKey(RedisLock redisLock, Object[] args){
        int[] index = redisLock.bindArgsIndex();
        Assert.notEmpty(Arrays.asList(index), "ArgsIndex is empty");

        int len = index.length;
        Object[] indexArgs = new Object[index.length];
        for(int i = 0; i < len; i++){
            indexArgs[i] = args[index[i]];
        }
        return StringUtils.join(indexArgs);
    }

    /**
     * 通过绑定的对象属性生成key
     * @param redisLock redisLock注解
     * @param args 所有参数
     * @return key
     */
    private String getObjectPropertiesKey(RedisLock redisLock, Object[] args) throws NoSuchFieldException, IllegalAccessException {

        String[] properties = redisLock.properties();
        List