Java集成Redis分布式（SpringMVC框架）

以你之姓@ 2023-02-09 14:26 32阅读 0赞

# Java集成Redis+Jedis分布式 #

## 0、pom.xml依赖、redis.properties属性配置 ##

**pom.xml**：

<dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
          <version>2.6.0</version>
        </dependency>

**redis.properties**：

#redis config start
    
    redis1.ip=127.0.0.1
    redis1.port=6379
    
    redis2.ip=127.0.0.1
    redis2.port=6380
    
    
    #最大连接数
    redis.max.total=20
    
    #最大空闲数
    redis.max.idle=10
    
    #最小空闲数
    redis.min.idle=2
    
    #从jedis连接池获取连接时，校验并返回可用的连接
    redis.test.borrow=true
    
    #把连接放回jedis连接池时，校验并返回可用的连接
    redis.test.return=false
    
    
    #redis config end

## 1、设计RedisShardedPool（redis分片连接池类） ##

**RedisShardedPool.java**：

package com.jack.common;
    
    import com.mmall.util.PropertiesUtil;
    import redis.clients.jedis.JedisPoolConfig;
    import redis.clients.jedis.JedisShardInfo;
    import redis.clients.jedis.ShardedJedis;
    import redis.clients.jedis.ShardedJedisPool;
    import redis.clients.util.Hashing;
    import redis.clients.util.Sharded;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * Created by jack */
    public class RedisShardedPool { 
        private static ShardedJedisPool pool;//sharded jedis连接池
        private static Integer maxTotal = Integer.parseInt(PropertiesUtil.getProperty("redis.max.total","20")); //最大连接数
        private static Integer maxIdle = Integer.parseInt(PropertiesUtil.getProperty("redis.max.idle","20"));//在jedispool中最大的idle状态(空闲的)的jedis实例的个数
        private static Integer minIdle = Integer.parseInt(PropertiesUtil.getProperty("redis.min.idle","20"));//在jedispool中最小的idle状态(空闲的)的jedis实例的个数
    
        private static Boolean testOnBorrow = Boolean.parseBoolean(PropertiesUtil.getProperty("redis.test.borrow","true"));//在borrow一个jedis实例的时候，是否要进行验证操作，如果赋值true。则得到的jedis实例肯定是可以用的。
        private static Boolean testOnReturn = Boolean.parseBoolean(PropertiesUtil.getProperty("redis.test.return","true"));//在return一个jedis实例的时候，是否要进行验证操作，如果赋值true。则放回jedispool的jedis实例肯定是可以用的。
    
        private static String redis1Ip = PropertiesUtil.getProperty("redis1.ip");
        private static Integer redis1Port = Integer.parseInt(PropertiesUtil.getProperty("redis1.port"));
        private static String redis2Ip = PropertiesUtil.getProperty("redis2.ip");
        private static Integer redis2Port = Integer.parseInt(PropertiesUtil.getProperty("redis2.port"));
    
    
    
    
        private static void initPool(){ 
            JedisPoolConfig config = new JedisPoolConfig();
    
            config.setMaxTotal(maxTotal);
            config.setMaxIdle(maxIdle);
            config.setMinIdle(minIdle);
    
            config.setTestOnBorrow(testOnBorrow);
            config.setTestOnReturn(testOnReturn);
    
            config.setBlockWhenExhausted(true);//连接耗尽的时候，是否阻塞，false会抛出异常，true阻塞直到超时。默认为true。
    
            JedisShardInfo info1 = new JedisShardInfo(redis1Ip,redis1Port,1000*2);
    
            JedisShardInfo info2 = new JedisShardInfo(redis2Ip,redis2Port,1000*2);
    
            List<JedisShardInfo> jedisShardInfoList = new ArrayList<JedisShardInfo>(2);
    
            jedisShardInfoList.add(info1);
            jedisShardInfoList.add(info2);
    
            pool = new ShardedJedisPool(config,jedisShardInfoList, Hashing.MURMUR_HASH, Sharded.DEFAULT_KEY_TAG_PATTERN);
        }
    
        static{ 
            initPool();
        }
    
        public static ShardedJedis getJedis(){ 
            return pool.getResource();
        }
    
    
        public static void returnBrokenResource(ShardedJedis jedis){ 
            pool.returnBrokenResource(jedis);
        }
    
    
    
        public static void returnResource(ShardedJedis jedis){ 
            pool.returnResource(jedis);
        }
    
    
        public static void main(String[] args) { 
            ShardedJedis jedis = pool.getResource();
    
            for(int i =0;i<10;i++){ 
                jedis.set("key"+i,"value"+i);
            }
            returnResource(jedis);
    
    // pool.destroy();//临时调用，销毁连接池中的所有连接
            System.out.println("program is end");
    
    
        }
    }

**PropertiesUtil.java**：（获取redis.properties属性工具类）

**因为有用到Slf4j来输出日志所以需要导入lombok依赖：**

<dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.16.18</version>
        </dependency>

package com.jack.util;
    
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.Properties;
    
    /** * Created by jack */
    @Slf4j
    public class PropertiesUtil { 
    
    
        private static Properties props;
    
        static { 
            String fileName = "redis.properties";
            props = new Properties();
            try { 
                props.load(new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName),"UTF-8"));
            } catch (IOException e) { 
                log.error("配置文件读取异常",e);
            }
        }
    
        public static String getProperty(String key){ 
            String value = props.getProperty(key.trim());
            if(StringUtils.isBlank(value)){ 
                return null;
            }
            return value.trim();
        }
    
        public static String getProperty(String key,String defaultValue){ 
    
            String value = props.getProperty(key.trim());
            if(StringUtils.isBlank(value)){ 
                value = defaultValue;
            }
            return value.trim();
        }
    }

## 2、设计RedisShardedPoolUtil（封装redis分布式的操作方法） ##

**同样pom需要导入lombok依赖支持**

package com.jack.util;
    
    import com.jack.common.RedisShardedPool;
    import lombok.extern.slf4j.Slf4j;
    import redis.clients.jedis.ShardedJedis;
    
    /** * Created by jack */
    @Slf4j
    public class RedisShardedPoolUtil { 
    
        /** * 设置key的有效期，单位是秒 * @param key * @param exTime * @return */
        public static Long expire(String key,int exTime){ 
            ShardedJedis jedis = null;
            Long result = null;
            try { 
                jedis = RedisShardedPool.getJedis();
                result = jedis.expire(key,exTime);
            } catch (Exception e) { 
                log.error("expire key:{} error",key,e);
                RedisShardedPool.returnBrokenResource(jedis);
                return result;
            }
            RedisShardedPool.returnResource(jedis);
            return result;
        }
    
        //exTime的单位是秒
        public static String setEx(String key,String value,int exTime){ 
            ShardedJedis jedis = null;
            String result = null;
            try { 
                jedis = RedisShardedPool.getJedis();
                result = jedis.setex(key,exTime,value);
            } catch (Exception e) { 
                log.error("setex key:{} value:{} error",key,value,e);
                RedisShardedPool.returnBrokenResource(jedis);
                return result;
            }
            RedisShardedPool.returnResource(jedis);
            return result;
        }
    
        public static String set(String key,String value){ 
            ShardedJedis jedis = null;
            String result = null;
    
            try { 
                jedis = RedisShardedPool.getJedis();
                result = jedis.set(key,value);
            } catch (Exception e) { 
                log.error("set key:{} value:{} error",key,value,e);
                RedisShardedPool.returnBrokenResource(jedis);
                return result;
            }
            RedisShardedPool.returnResource(jedis);
            return result;
        }
    
        public static String getSet(String key,String value){ 
            ShardedJedis jedis = null;
            String result = null;
    
            try { 
                jedis = RedisShardedPool.getJedis();
                result = jedis.getSet(key,value);
            } catch (Exception e) { 
                log.error("getset key:{} value:{} error",key,value,e);
                RedisShardedPool.returnBrokenResource(jedis);
                return result;
            }
            RedisShardedPool.returnResource(jedis);
            return result;
        }
    
        public static String get(String key){ 
            ShardedJedis jedis = null;
            String result = null;
            try { 
                jedis = RedisShardedPool.getJedis();
                result = jedis.get(key);
            } catch (Exception e) { 
                log.error("get key:{} error",key,e);
                RedisShardedPool.returnBrokenResource(jedis);
                return result;
            }
            RedisShardedPool.returnResource(jedis);
            return result;
        }
    
        public static Long del(String key){ 
            ShardedJedis jedis = null;
            Long result = null;
            try { 
                jedis = RedisShardedPool.getJedis();
                result = jedis.del(key);
            } catch (Exception e) { 
                log.error("del key:{} error",key,e);
                RedisShardedPool.returnBrokenResource(jedis);
                return result;
            }
            RedisShardedPool.returnResource(jedis);
            return result;
        }
    
        public static Long setnx(String key,String value){ 
            ShardedJedis jedis = null;
            Long result = null;
    
            try { 
                jedis = RedisShardedPool.getJedis();
                result = jedis.setnx(key,value);
            } catch (Exception e) { 
                log.error("setnx key:{} value:{} error",key,value,e);
                RedisShardedPool.returnBrokenResource(jedis);
                return result;
            }
            RedisShardedPool.returnResource(jedis);
            return result;
        }
    
    
        public static void main(String[] args) { 
            ShardedJedis jedis = RedisShardedPool.getJedis();
    
            RedisPoolUtil.set("keyTest","value");
    
            String value = RedisPoolUtil.get("keyTest");
    
            RedisPoolUtil.setEx("keyex","valueex",60*10);
    
            RedisPoolUtil.expire("keyTest",60*20);
    
            RedisPoolUtil.del("keyTest");
    
    
            String aaa = RedisPoolUtil.get(null);
            System.out.println(aaa);
    
            System.out.println("end");
    
    
        }
    
    
    
    }

## 完。 ##