redis的分布式锁

网上找了好多redis的分布式锁，很多都是错误的，已经测试redis分布式锁，记录一下
业务代码的处理逻辑为：
String key=xxx;
String value=xxx;
try{
if(ResisLock .lock(key,value))
{
执行代码
}
}finally{
ResisLock .lock(key,value)
}

import org.springframework.beans.factory.annotation.Autowired;
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 org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 应用模块名称<p>
 * 代码描述<p>
 * Copyright: Copyright (C) 2019 XXX, Inc. All rights reserved. <p>
 * Company: xxx有限公司<p>
 *
 * @author Joker
 * @since 2019/3/31 19:25
 */
@Component
public class ResisLock {
    //过期时间为3分钟
    private static final long time=1000*60*3;
    private static final String PX="px";
    private static final String nx="nx";
    private static final String success="OK";


    public static final String UNLOCK_LUA;
    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == KEYS[2] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 22 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();
    }


    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    public boolean lock(String key,String value) {
        try {
            RedisCallback<String> callback = (connection) -> {
//目前只测试了单机的redis可用，集群版的带后期测试了再补充，
               return  String.valueOf(connection.set(key.getBytes(),value.getBytes(),Expiration.from(time, TimeUnit.SECONDS), RedisStringCommands.SetOption.SET_IF_ABSENT));
            };
            String result = redisTemplate.execute(callback);

            return Boolean.valueOf(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    public boolean unLock(String key,String value) {

        // 释放锁的时候，有可能因为持锁之后方法执行时间大于锁的有效期，此时有可能已经被另外一个线程持有锁，所以不能直接删除
        try {
            List<String> keys = new ArrayList<>();
            keys.add(key);
            List<String> args = new ArrayList<>();
            args.add(value);

            // 使用lua脚本删除redis中匹配value的key，可以避免由于方法执行时间过长而redis锁自动过期失效的时候误删其他线程的锁
            // spring自带的执行脚本方法中，集群模式直接抛出不支持执行脚本的异常，所以只能拿到原redis的connection来执行脚本
            RedisCallback<Long> callback = (connection) -> {
            //目前只测试了单机的redis可用，集群版的带后期测试了再补充，
                return connection.eval(UNLOCK_LUA.getBytes(), ReturnType.INTEGER,2,key.getBytes(),value.getBytes());
            };
            Long result = redisTemplate.execute(callback);

            return result != null && result > 0;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 清除掉ThreadLocal中的数据，避免内存溢出
            //lockFlag.remove();
        }
        return false;

    }
}