打开Redis分布式锁的正确方式

使用redis实现分布式锁的目的是防止多台机器共享同一资源，保证该资源只在某一台机器处理，且只处理一次，但是使用redis实现分布式锁时需要保证以下两点，
（1）设置key和过期时间需要在同一个事务内完成
（2）设置key和删除key的属于同一个客户端
根据以上分析，我们使用spring-data-redis实现分布式锁的加锁和删除功能，talk is cheap，show your code.

1、引用的包,核心包是：
  		<!-- spring data redis -->
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
                <version>1.6.1</version>
            </dependency>
 **其他Spring的包自己引用**。

2、redis实现分布式锁的加锁功能
public class RedisManager {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final String luaString = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    private static final DefaultRedisScript<Boolean> defaultRedisScript  = new DefaultRedisScript<Boolean>(luaString, Boolean.class);

    /**
     * 查询redis数据库
     *
     * @param key 查询关键字
     * @return redis        返回对象
     */
    public String queryObjectByKey(final String key) {
        log.debug("redisManager queryObjectByKey request:{}", key);
        try {
            String resultStr = (String) redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public String doInRedis(RedisConnection connection) throws DataAccessException {
                    byte[] redisKey = redisTemplate.getStringSerializer().serialize(key);
                    byte[] value = connection.get(redisKey);
                    if (value == null) {
                        return null;
                    }
                    return redisTemplate.getStringSerializer().deserialize(value);
                }
            });
            log.debug("redisManager queryObjectByKey response:{}", resultStr);
            return resultStr;
        } catch (Exception e) {
            log.error("redis 查询异常:{}", e);
            return null;
        }
    }

    /**
     *  加锁
     * @param key key
     * @param value 加锁的标识
     * @param timeout 过期时间
     * @return 是否加锁成功
     */
    public boolean setIfNotExistRepair(final String key, final String value,final long timeout){
        log.debug("lockRedis request:key={}", key);
        if (timeout <= 0) {
            log.warn("lockRedis Fail lock Time gt 0");
            return false;
        }
        try {
            boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    try {
                        byte[] redisKey = redisTemplate.getStringSerializer().serialize(key);
                        byte[] redisValue = redisTemplate.getStringSerializer().serialize(value);
                        byte[] redisExpire = redisTemplate.getStringSerializer().serialize(String.valueOf(timeout));
                        byte[] operateNX = redisTemplate.getStringSerializer().serialize("NX");
                        byte[] operatePX = redisTemplate.getStringSerializer().serialize("PX");
                        String result = new String((byte[]) connection.execute("set",redisKey,redisValue,operatePX,redisExpire,operateNX));
                        log.debug("lockRedis return {}",result);
                        if("OK".equals(result)){
                            return Boolean.TRUE;
                        }
                        return Boolean.FALSE;
                    }catch (Exception e){
                        log.warn("lockRedis Fail Exception:{}", e);
                    }

                    return Boolean.FALSE;
                }
            });
            log.debug("lockRedis request Result:{}", result);
            return result;
        }catch (Exception e) {
            log.error("lockRedis exception, e:{}", e);
            return false;
        }
    }


    /**
     * 删除
     * @param lockKey key
     * @param value value
     * @return 删除结果
     */
    public Boolean deleteKey (final String lockKey, final String value){
        List<Object> keyList = new ArrayList<Object>();
        keyList.add(lockKey);
        return(Boolean) ((RedisTemplate)redisTemplate).execute(defaultRedisScript,keyList,value);
    }
}
3. 测试代码
测试的场景：（1）设置key，value，在超时后，会不会再次抢锁成功。测试结果：会。
		  （2）设置key，value，在超时时间内，会不会抢锁失败。测试结果：会。
		  （3）设置key，value，删除时不同value是否可以删除数据成功。测试结果：不同的value删除失败，同一个value删除成功。
    public void testRedisLock() throws InterruptedException {
        String requestId = toJSONString(UUID.randomUUID().toString());
        redisManager.setIfNotExistRepair("today",requestId,3000L);
        System.out.println("query key"+redisManager.queryObjectByKey("today"));
        Thread.sleep(3000L);
        System.out.println("delete key"+ redisManager.deleteKey("today", requestId));
        System.out.println("query delete key" + redisManager.queryObjectByKey("today"));
    }

总结 ：redis实现分布式锁，可以帮助我们解决多台机器共享同一资源的问题。我们假设当某一业务请求处理超过锁的超时时间，但是这个业务还没有处理完，这个时候，同一个业务又请求系统时，还是可以拿到锁，这个时候就会重复处理，这时我们可以使用数据库锁或者幂等校验来避免这类问题。因此redis实现的分布式锁并不能解决所有的问题，需要根据自身的业务进行灵活处理。