Redis 分布式锁实现及缓存工具类

﹏ヽ暗。殇╰゛Y 2022-03-15 12:40 334阅读 0赞

# 1.Maven依赖 #

<project xmlns="http://maven.apache.org/POM/4.0.0"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com.weichai</groupId>
    	<artifactId>JedisTest</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>JedisTest</name>
    	<url>http://maven.apache.org</url>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>3.8.1</version>
    			<scope>test</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    			<version>2.9.0</version>
    		</dependency>
    	</dependencies>
    </project>

# 2.redis 服务连接类 #

package com.weichai.jedisPool;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    public class RedisUtil {
    
    	// Redis服务器IP
    	private static String localhost = "127.0.0.1";
    	// Redis的端口号
    	private static int port = 6380;
    	//连接密码
    	private static String password = "123456";
    	//过期时间: 12小时
    	private static int timeout = 43200;
    	// 可用连接实例的最大数目，默认值为8；
    	// 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    	private static int max_active = 1024;
    	// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    	private static int max_idle = 200;
    	// 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    	private static int max_wait = 10000;
    	// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    	private static boolean test_on_borrow = true;  
    	private static JedisPool jedisPool = null;
    	
    	JedisPoolConfig config = new JedisPoolConfig();
    	
    	static {
    		try {
    			JedisPoolConfig config = new JedisPoolConfig();
    			config.setMaxTotal(max_active);
    			config.setMaxIdle(max_idle);
    			config.setMaxWaitMillis(max_wait);
    			config.setTestOnBorrow(test_on_borrow);
    			jedisPool = new JedisPool(config, localhost, port, timeout,password);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	 * 获取Jedis连接实例
    	 * @return
    	 */
    	public synchronized static Jedis getJedis() {
    		try {
    			if(jedisPool != null) {
    				Jedis resource = jedisPool.getResource();
    				return resource;
    			}else {
    				return null;
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			System.out.println("连接失败");
    			return null;
    		}
    	}
    	
    	public static void ReleaseJedis(final Jedis jedis) {
    		if(jedis != null) {
    			jedisPool.returnResourceObject(jedis);
    		}
    	}
    }

# 3.Jedis 工具类 #

package com.weichai.redisUtil;
    
    import java.util.List;
    import java.util.Set;
    
    import com.weichai.jedisPool.RedisUtil;
    
    import redis.clients.jedis.Jedis;
    
    /**
     * Jedis 工具类
     * @author lhy
     * @date 2018.12.18
     */
    public class JedisUtils {
    
    	/**
    	 * 添加key value 并且设置存活时间(byte)
    	 * @param key
    	 * @param value
    	 * @param liveTime
    	 */
    	public void set(byte [] key,byte [] value,int liveTime) {
    		Jedis jedis = RedisUtil.getJedis();
    		jedis.select(2);
    		jedis.set(key, value);
    		jedis.expire(key, liveTime);
    		RedisUtil.ReleaseJedis(jedis);
    	}
    	
    	/**
    	 * 添加key value 并且设置存活时间
    	 * @param key
    	 * @param value
    	 * @param liveTime
    	 */
    	public void set(String key, String value, int liveTime) {
    		Jedis jedis = RedisUtil.getJedis();
    		jedis.select(10);
    		jedis.set(key, value);
    		jedis.expire(key, liveTime);
    		System.out.println("Key添加成功！");
    		RedisUtil.ReleaseJedis(jedis);
    	}
    	
    	/**
    	 * 添加key value
    	 * @param key
    	 * @param value
    	 */
    	public void set(String key, String value) {
    		Jedis jedis = RedisUtil.getJedis();
    		jedis.set(key, value);
    		RedisUtil.ReleaseJedis(jedis);
    	}
    	
    	/**
    	 * 添加key value (字节)(序列化)
    	 * @param key
    	 * @param value
    	 */
    	public void set(byte[] key, byte[] value) {
    		Jedis jedis = RedisUtil.getJedis();
    		jedis.set(key, value);
    		RedisUtil.ReleaseJedis(jedis);
    	}
    	
    	/**
    	 * 通过key删除（字节）
    	 * @param key
    	 */
    	public void del(byte [] key){
    		Jedis jedis = RedisUtil.getJedis();
    		jedis.del(key);
    		RedisUtil.ReleaseJedis(jedis);
    	}
    	
    	/**
    	 * 通过key删除
    	 * @param key
    	 */
    	public void del(String key){
    		Jedis jedis = RedisUtil.getJedis();
    		jedis.del(key);
    		RedisUtil.ReleaseJedis(jedis);
    	}
    	
    	/**
    	 * 获取redis value (String)
    	 * @param key
    	 * @return
    	 */
    	public String get(String key) {
    		Jedis jedis = RedisUtil.getJedis();
    		String value = jedis.get(key);
    		RedisUtil.ReleaseJedis(jedis);
    		return value;
    	}
    	
    	/**
    	 * 获取redis value (byte [] )(反序列化)
    	 * @param key
    	 * @return
    	 */
    	public byte[] get(byte[] key) {
    		Jedis jedis = RedisUtil.getJedis();
    		byte[] value = jedis.get(key);
    		RedisUtil.ReleaseJedis(jedis);
    		return value;
    	}
    	
    	/**
    	 * 通过正则匹配keys
    	 * @param pattern
    	 * @return
    	 */
    	public Set<String> keys(String pattern) {
    		Jedis jedis = RedisUtil.getJedis();
    		Set<String> value = jedis.keys(pattern);
    		RedisUtil.ReleaseJedis(jedis);
    		return value;
    	}
    	
    	/**
    	 * 检查key是否已经存在
    	 * @param key
    	 * @return
    	 */
    	public boolean exists(String key) {
    		Jedis jedis = RedisUtil.getJedis();
    		boolean value = jedis.exists(key);
    		RedisUtil.ReleaseJedis(jedis);
    		return value;
    	}
    	
    	/**
    	 * 获取key的剩余超时时间
    	 * @param key
    	 * @return
    	 */
    	public Long ttl(String key) {
    		Jedis jedis = RedisUtil.getJedis();
    		Long time = jedis.ttl(key);
    		RedisUtil.ReleaseJedis(jedis);
    		return time;
    	}
    	/*******************redis list操作************************/
    	/**
    	 * 往list中添加元素
    	 * @param key
    	 * @param value
    	 */
    	public void lpush(String key,String value){
    		Jedis jedis = RedisUtil.getJedis();
    		jedis.lpush(key, value);
    		RedisUtil.ReleaseJedis(jedis);
    	}
    	
    	public void rpush(String key,String value){
    		Jedis jedis = RedisUtil.getJedis();
    		jedis.rpush(key, value);
    		RedisUtil.ReleaseJedis(jedis);
    	}
    	
    	/**
    	 * 数组长度
    	 * @param key
    	 * @return
    	 */
    	public Long llen(String key){
    		Jedis jedis = RedisUtil.getJedis();
    		Long len = jedis.llen(key);
    		RedisUtil.ReleaseJedis(jedis);
        	return len;
        }
    	
    	/**
    	 * 获取下标为index的value
    	 * @param key
    	 * @param index
    	 * @return
    	 */
    	public String lindex(String key,Long index){
    		Jedis jedis = RedisUtil.getJedis();
    		String str = jedis.lindex(key, index);
    		RedisUtil.ReleaseJedis(jedis);
    		return str;
    	}
    	
    	public String lpop(String key) {
    		Jedis jedis = RedisUtil.getJedis();
    		String str = jedis.lpop(key);
    		RedisUtil.ReleaseJedis(jedis);
    		return str;
    	}
    	
    	public List<String> lrange(String key, long start, long end) {
    		Jedis jedis = RedisUtil.getJedis();
    		List<String> str = jedis.lrange(key, start, end);
    		RedisUtil.ReleaseJedis(jedis);
    		return str;
    	}
    	
    	/*********************redis list操作结束**************************/
    	
    	/**
    	 * 清空redis 所有数据
    	 * @return
    	 */
    	public String flushDB(){
    		Jedis jedis = RedisUtil.getJedis();
    		String str = jedis.flushDB();
    		RedisUtil.ReleaseJedis(jedis);
        	return str;
        }
    	
    	/**
         * 查看redis里有多少数据
         */
        public long dbSize(){
        	Jedis jedis = RedisUtil.getJedis();
    		long len = jedis.dbSize();
    		RedisUtil.ReleaseJedis(jedis);
        	return len;
        }
        
        /**
         * 检查是否连接成功
         * @return
         */
        public String ping(){
        	Jedis jedis = RedisUtil.getJedis();
    		String str = jedis.ping();
    		RedisUtil.ReleaseJedis(jedis);
        	return str;
        }
    }

# 4.分布式锁工具类 #

package com.weichai.redisUtil;
    
    import com.weichai.jedisPool.RedisUtil;
    
    import redis.clients.jedis.Jedis;
    
    public class RedisPoolUtil {
    
    	public RedisPoolUtil() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	public static String get(String key) {
    		Jedis jedis = null;
    		String result = null;
    		try {
    			jedis = RedisUtil.getJedis();
    			result = jedis.get(key);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (jedis != null) {
    				jedis.close();
    			}
    			return result;
    		}
    	}
    
    	public static Long setnx(String key, String value) {
    		Jedis jedis = null;
    		Long result = null;
    		try {
    			jedis = RedisUtil.getJedis();
    			result = jedis.setnx(key, value);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (jedis != null) {
    				jedis.close();
    			}
    			return result;
    		}
    	}
    
    	public static String getSet(String key, String value) {
    		Jedis jedis = null;
    		String result = null;
    		try {
    			jedis = RedisUtil.getJedis();
    			result = jedis.getSet(key, value);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (jedis != null) {
    				jedis.close();
    			}
    			return result;
    		}
    	}
    
    	public static Long expire(String key, int seconds) {
    		Jedis jedis = null;
    		Long result = null;
    		try {
    			jedis = RedisUtil.getJedis();
    			result = jedis.expire(key, seconds);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (jedis != null) {
    				jedis.close();
    			}
    			return result;
    		}
    	}
    
    	public static Long del(String key) {
    		Jedis jedis = null;
    		Long result = null;
    		try {
    			jedis = RedisUtil.getJedis();
    			result = jedis.del(key);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (jedis != null) {
    				jedis.close();
    			}
    			return result;
    		}
    	}
    
    }

# 5.分布式锁实现 #

package com.weichai.lock;
    
    import com.weichai.redisUtil.RedisPoolUtil;
    
    /**
     * @deprecated 分布式锁工具类的实现
     * @author lhy
     * @date 2018.12.20
     */
    public class LockUtil {
    
    	public LockUtil() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	/**
    	 * 
    	 * @param lockName可以为共享变量名，也可以为方法名，主要是用于模拟锁信息 
    	 * @return
    	 */
    	public static boolean lock(String lockName){
    		System.out.println(Thread.currentThread() + "开始尝试加锁！");
    		Long result = RedisPoolUtil.setnx(lockName, String.valueOf(System.currentTimeMillis() + 5000));
    		if(result !=null && result.intValue() == 1) {
    			System.out.println(Thread.currentThread() + "加锁成功！");
    			RedisPoolUtil.expire(lockName, 5);
    			System.out.println(Thread.currentThread() + "执行业务逻辑！");
    			RedisPoolUtil.del(lockName);
    			return true;
    		}else {
    			String lockValueA = RedisPoolUtil.get(lockName);
    			if (lockValueA != null && Long.parseLong(lockValueA) >= System.currentTimeMillis()){
    				String lockValueB = RedisPoolUtil.getSet(lockName, String.valueOf(System.currentTimeMillis() + 5000));
    				if (lockValueB == null || lockValueB.equals(lockValueA)){
    					System.out.println(Thread.currentThread() + "加锁成功！");
                        RedisPoolUtil.expire(lockName, 5);
                        System.out.println(Thread.currentThread() + "执行业务逻辑！");
                        RedisPoolUtil.del(lockName);
                        return true;
    				} else {
    					return false;
    				}
    			} else {
    				return false;
    			}
    		}
    	}
    }

# 6.测试类 #

package com.weichai.test;
    
    import com.weichai.lock.LockUtil;
    
    public class lockTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
            boolean status = LockUtil.lock("海哥");
            System.out.println("分布式锁的状态 ：" + status);
    	}
    
    }

package com.weichai.test;
    
    import com.weichai.jedisPool.RedisUtil;
    import com.weichai.redisUtil.JedisUtils;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    //		Jedis jedis = RedisUtil.getJedis();
    //		jedis.select(5);
    //		jedis.slaveofNoOne();
    //		jedis.set("name", "haige");
    //		String name = jedis.get("name");
    //		System.out.println("Redis name : " + name);
    		
    		JedisUtils util = new JedisUtils();
    		boolean status = util.exists("user");
    		if(status == false) {
    			util.set("user", "杨旭", 240);
    		}
    		String name = util.get("name");
    	}
    
    }