Redis学习笔记（七）—— 在Spring框架中实现基于Redis的分布式锁（单机版）

        目前很多大型网站及应用都是分布式部署的，分布式场景中的数据一致性问题一直是一个比较重要的话题。分布式的CAP理论告诉我们：“任何一个分布式系统都无法同时满足一致性(Consistency)、可用性(Availability)和分区容错性(Partition tolerance)，最多只能同时满足其中两项”。所以，很多系统在设计之初就要对这三者进行取舍。在互联网领域的绝大多数的场景中，都需要牺牲系统的强一致性来换取系统的高可用性，系统往往只需要保证“最终一致性”，只要这个最终时间在用户的可接受范围之内即可。

        我们为了保证数据的最终一致性，需要很多技术方案来支持，比如分布式事务、分布式锁等。针对分布式锁的实现，目前主要有三种实现方案，一是基于数据库(oracle、mysql)实现分布式锁；二是基于缓存(redis、memcached)实现分布式锁；三是基于Zookeeper实现分布式锁。下面实现的是基于Redis单机版实现的分布式锁，适合并发量不是很大的中小型项目。

一、实现分布式锁所需要的pom依赖

        5.0.0.RELEASE
        1.8.11
        2.9.0
        1.6.0.RELEASE

            
                org.springframework
                spring-orm
                ${spring.version}
            
            
                org.springframework
                spring-webmvc
                ${spring.version}
            
            
                org.aspectj
                aspectjweaver
                ${aspectj.version}
                    
            
                redis.clients
                jedis
                ${jedis.version}
            
            
                org.springframework.data
                spring-data-redis
                ${spring.data.redis.version}
            

二、添加spring测试文件applicationContext-test-redis.xml

此文件添加目录为：src/main/resources/spring/applicationContext-test-redis.xml

三、添加测试类 JedisTest

@Component
public class JedisTest {

    @Test
    public void example1() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext-test-redis.xml");
        JedisConnectionFactory jedisConnectionFactory = (JedisConnectionFactory) context.getBean("jedisConnectionFactory");
        Field jedisField = ReflectionUtils.findField(JedisConnection.class, "jedis");
        ReflectionUtils.makeAccessible(jedisField);
        System.out.println(jedisConnectionFactory.getConnection());
        Jedis jedis = (Jedis) ReflectionUtils.getField(jedisField, jedisConnectionFactory.getConnection());
        String result = jedis.set("test-key", "Hello world-", "NX", "EX", 100);
        System.out.println(result);
        //代码执行后,返回字符串”OK”或者”null”,表示是否设值成功。
    }
}

测试成功后就可以在项目中进行代码部署了，示例如下： 

四、实现分布式的工具类

import redis.clients.jedis.Jedis;

import java.util.Collections;

/**
 * author Alex
 * date 2018/01/22
 * description 一个用于获取redis分布式锁的工具类，适用于单机部署的redis
 * Redis如果是多机部署的，那么可以尝试使用Redisson实现分布式锁，这是Redis官方提供的Java组件
 * Redisson的github链接：https://github.com/redisson/redisson
 * Redisson的使用示例链接：https://blog.csdn.net/u014042066/article/details/72778440
 */
public class RedisDistributedLockUtil {

    private static final String LOCK_SUCCESS = "OK";
    private static final Long RELEASE_SUCCESS = 1L;
    //意思是SET IF NOT EXIST，即当key不存在时，我们进行set操作；若key已经存在，则不做任何操作
    private static final String SET_IF_NOT_EXIST = "NX";
    //意思是我们要给这个key加一个过期的设置，具体时间由第五个参数决定
    private static final String SET_WITH_EXPIRE_TIME = "EX";

    /**
     * 获取分布式锁
     * @param jedis Redis客户端
     * @param lockKey 锁的keyName
     * @param requestId 请求标识，可以使用UUID，为了确认在分布式环境下是哪个客户端加的锁，同时也用于解锁
     * @param expireTime 过期时间，单位（秒）
     * @return 是否获取成功
     */
    public static boolean getDistributedLock(Jedis jedis, String lockKey, String requestId, int expireTime) {

        //加锁
        String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);

        if (LOCK_SUCCESS.equals(result)) {
            return true;
        }
        return false;

    }

    /**
     * 释放分布式锁
     * @param jedis Redis客户端
     * @param lockKey 锁的keyName
     * @param requestId 请求标识，使用加锁时生成的UUID
     * @return 是否释放成功
     */
    public static boolean releaseDistributedLock(Jedis jedis, String lockKey, String requestId) {

        //Lua脚本代码，KEYS[1]使用lockKey参数，ARGV[1]使用requestId参数
        //Lua脚本含义：首先获取锁的value值，看是否与请求的标识相匹配，如果匹配则删除锁，否则就返回0
        //Lua脚本代码在执行时将会被当作一个命令来执行，并且直到eval命令执行完成，才会执行其他命令，它具有原子性
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        //eval()方法是将Lua代码交给Redis服务端执行
        Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));

        if (RELEASE_SUCCESS.equals(result)) {
            return true;
        }
        return false;

    }
}

五、实现分布式锁的伪代码

@Autowired
private JedisConnectionFactory jedisConnectionFactory;

public void handleService() throws Exception {
        Jedis jedis = null;
        try {
            //通过反射获取Jedis连接对象
            Field jedisField = ReflectionUtils.findField(JedisConnection.class, "jedis");
            //将该字段设置为可访问，主要是针对private字段
            ReflectionUtils.makeAccessible(jedisField);
            jedis = (Jedis) ReflectionUtils.getField(jedisField, jedisConnectionFactory.getConnection());
            //获取请求客户端标识
            String requestId = UUID.randomUUID().toString();
            //设置超时时间
            long timeOut = System.currentTimeMillis() + 3 * 1000;
            //更新缓存数据之前先获取Redis分布式锁，如果获取到Redis分布式锁则进行更新，否则就循环获取锁直到超时
            while (true) {
                //获取分布式锁并设置锁的自动过期时间为2秒
                boolean distributedLock = RedisDistributedLockUtil.getDistributedLock(
                        jedis, RedisKeyNameEnum.TEL_TIP_DISTRIBUTED_LOCK.getFactValue(), requestId, 2);
                if (distributedLock) {
                    //进行业务处理....

                    //处理结束后要释放锁
                    boolean b = RedisDistributedLockUtil.releaseDistributedLock(
                            jedis, RedisKeyNameEnum.TEL_TIP_DISTRIBUTED_LOCK.getFactValue(), requestId);
                    if (b) {
                        System.out.println("成功释放Redis分布式锁！");
                    } else {
                        System.out.println("释放Redis分布式锁失败，等待锁自动超时.........");
                    }
                    //业务处理结束后要中止循环
                    break;
                } else {
                    //超时还未获取到锁则中止循环
                    if (System.currentTimeMillis() > timeOut) {
                        System.out.println("获取Redis分布式锁超时，可能是连接异常，循环中止..........");
                        break;
                    }
                    System.out.println("获取Redis分布式锁失败，休眠100毫秒再重新尝试获取锁，休眠中..........");
                    //获取分布式锁失败休眠100毫秒再重新获取锁
                    Thread.sleep(100);
                }
            }
        } finally {
            //异常抛给上层应用去处理，这里只进行关闭资源的操作处理
            if (null != jedis) {
                jedis.close();
            }
        }
    }

六、项目中配置Redis的缓存管理器

七、进行redis业务操作的工具类RedisUtil

 

package com.mengfei.redis;

import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;

public class RedisUtil {

private RedisTemplate redisTemplate;

    public void setRedisTemplate(RedisTemplate redisTemplate) {
    	RedisSerializer redisSerializer = new JdkSerializationRedisSerializer();
    	RedisSerializer redisSerializerString = new StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializerString);
        redisTemplate.setValueSerializer(redisSerializer);
        this.redisTemplate = redisTemplate;  
    }  
    
    public RedisTemplate getRedisTemplate() {
		return redisTemplate;
	}

	//=============================common============================  
    
    public Set getKeys(String key){
    	if(key == null || "".equals(key)){
    		return null;
    	}
    
    	Set r = redisTemplate.keys(key);
    	return r;
    }
    /**
     * 批量获取redis string
     * @param keys
     * @return
     */
    public List