/**
 * 分布式锁 api接口
 */
public interface DistributeLock {

    
     * 尝试加锁
     * @param lockKey 锁的key
     * @return 加锁成功 返回uuid
     *         加锁失败 返回null
     * */
    String lock(String lockKey);

    
     * 尝试加锁 (requestID相等 可重入)
     *  expireTime 过期时间 单位：秒
     * 
    String lock(String lockKey,int expireTime);

     requestID 用户ID
     * 
     * 尝试加锁，失败自动重试 会阻塞当前线程
     * 
    String lockAndRetry(String lockKey);

    
     * 尝试加锁，失败自动重试 会阻塞当前线程 (requestID相等 可重入)
     * 
    String lockAndRetry(String lockKey,1)"> retryCount 重试次数
     * int expireTime, retryCount);

    
     * 释放锁
     *  true     释放自己所持有的锁 成功
     *         false    释放自己所持有的锁 失败
     * */
    boolean unLock(String lockKey,String requestID);
}

class RedisDistributeLock implements
     * 无限重试
     * int UN_LIMIT_RETRY = -1 RedisDistributeLock() {
        LuaScript.init();
    }

    static DistributeLock instance =  RedisDistributeLock();

    
     * 持有锁 成功标识
     * final Long ADD_LOCK_SUCCESS = 1L;
    
     * 释放锁 失败标识
     * final Integer RELEASE_LOCK_SUCCESS = 1
     * 默认过期时间 单位：秒
     * int DEFAULT_EXPIRE_TIME_SECOND = 300
     * 默认加锁重试时间 单位：毫秒
     * int DEFAULT_RETRY_FIXED_TIME = 3000
     * 默认的加锁浮动时间区间 单位：毫秒
     * int DEFAULT_RETRY_TIME_RANGE = 1000
     * 默认的加锁重试次数
     * int DEFAULT_RETRY_COUNT = 30
     * lockCount Key前缀
     * final String LOCK_COUNT_KEY_PREFIX = "lock_count:" DistributeLock getInstance(){
         instance;
    }
}

-- 获取参数
local requestIDKey = KEYS[1]

local currentRequestID = ARGV[]
local expireTimeTTL = ARGV[2 setnx 尝试加锁
local lockSet = redis.call('hsetnx',KEYS[1],lockKey'if lockSet == 1
then
     加锁成功 设置过期时间和重入次数=1
    redis.call(expire],expireTimeTTL)
    redis.call(hsetlockCount)
    return else
     判断是否是重入加锁
    local oldRequestID = redis.call(hgetif currentRequestID == oldRequestID
    then
         是重入加锁
        redis.call(hincrby)
         重置过期时间
        redis.call(1
    else
         requestID不一致，加锁失败
        0
    end
end

   @Override
    public String lock(String lockKey) {
        String uuid = UUID.randomUUID().toString();

         lock(lockKey,uuid);
    }

    @Override
    public String lock(String lockKey,1)"> expireTime) {
        String uuid = String lock(String lockKey,String requestID) {
         expireTime) {
        RedisClient redisClient = RedisClient.getInstance();

        List<String> keyList = Arrays.asList(
                lockKey
        );

        List<String> argsList = Arrays.asList(
                requestID,expireTime + ""
        );
        Long result = (Long)redisClient.eval(LuaScript.LOCK_SCRIPT,keyList,argsList);

        (result.equals(ADD_LOCK_SUCCESS)){
             requestID;
        }return ;
        }
    }

 判断requestID一致性
if redis.call(') == currentRequestID
 requestID相同，重入次数自减
    local currentCount = redis.call(if currentCount ==  重入次数为0，删除锁
        redis.call(del])
        0 else 
    end

 Collections.singletonList(requestID);

        Object result = RedisClient.getInstance().eval(LuaScript.UN_LOCK_SCRIPT,1)"> 释放锁成功
         RELEASE_LOCK_SUCCESS.equals(result);
    }

    @Override
     String lockAndRetry(String lockKey) {
        String uuid = lockAndRetry(lockKey,1)"> String lockAndRetry(String lockKey,1)">public String lockAndRetry(String lockKey,1)"> retryCount) {
        String uuid = expireTime) {
         retryCount) {
        if(retryCount <= 0 retryCount小于等于0 无限循环，一直尝试加锁
            while(true){
                String result =if(result != ){
                     result;
                }

                 休眠一会
                sleepSomeTime();
            }
        } retryCount大于0 尝试指定次数后，退出
            for(int i=0; i<retryCount; i++                sleepSomeTime();
            }

            ;
        }
    }

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @ RedisLock {
    int UN_LIMIT_RETRY = RedisDistributeLock.UN_LIMIT_RETRY;

    String lockKey();
     expireTime();
     retryCount();
}

@Component
@Aspect
 RedisLockAspect {

    final Logger LOGGER = LoggerFactory.getLogger(RedisLockAspect.final ThreadLocal<String> REQUEST_ID_MAP = new ThreadLocal<>();

    @Pointcut("@annotation(annotation.RedisLock)" annotationPointcut() {
    }

    @Around("annotationPointcut()"public Object around(ProceedingJoinPoint joinPoint)  Throwable {
        MethodSignature methodSignature = (MethodSignature)joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        RedisLock annotation = method.getAnnotation(RedisLock.);

        boolean lockSuccess = lock(annotation);
        (lockSuccess){
            Object result = joinPoint.proceed();
            unlock(annotation);
             result;
        }
        ;
    }

    
     * 加锁
     *  lock(RedisLock annotation){
        DistributeLock distributeLock = RedisDistributeLock.getInstance();

        int retryCount = annotation.retryCount();

        String requestID = REQUEST_ID_MAP.get();
        if(requestID !=  当前线程 已经存在requestID
            distributeLock.lockAndRetry(annotation.lockKey(),annotation.expireTime(),retryCount);
            LOGGER.info("重入加锁成功 requestID=" + requestID);

            ;
        } 当前线程 不存在requestID
            String newRequestID = distributeLock.lockAndRetry(annotation.lockKey(),retryCount);

            if(newRequestID !=  加锁成功，设置新的requestID
                REQUEST_ID_MAP.set(newRequestID);
                LOGGER.info("加锁成功 newRequestID=" + newRequestID);

                ;
            }{
                LOGGER.info("加锁失败，超过重试次数，直接返回 retryCount={}";
            }
        }
    }

    
     * 解锁
     *  unlock(RedisLock annotation){
        DistributeLock distributeLock = RedisDistributeLock.getInstance();
        String requestID = 解锁成功
            boolean unLockSuccess = distributeLock.unLock(annotation.lockKey(),requestID);
            (unLockSuccess){
                 移除 ThreadLocal中的数据
                REQUEST_ID_MAP.remove();
                LOGGER.info("解锁成功 requestID=" + requestID);
            }
        }
    }
}

@Service("testService")
class TestServiceImpl  TestService {

    @Override
    @RedisLock(lockKey = "lockKey",expireTime = 100,retryCount = RedisLock.UN_LIMIT_RETRY)
     String method1() {
        return "method1";
    }

    @Override
    @RedisLock(lockKey = "lockKey",retryCount = 3 String method2() {
        return "method2";
    }
}