Java集成Redis，编写Redis操作工具类（SpringMVC框架）

电玩女神 2023-03-12 09:10 11阅读 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
    
    redis.ip=127.0.0.1
    redis.port=6379
    
    
    #最大连接数
    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、设计RedisPool（redis连接池类） ##

**RedisPool.java**：

package com.jack.common;
    
    import com.jack.util.PropertiesUtil;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    /** * Created by jack */
    public class RedisPool { 
        private static JedisPool pool;//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 redisIp = PropertiesUtil.getProperty("redis.ip");
        private static Integer redisPort = Integer.parseInt(PropertiesUtil.getProperty("redis.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。
    
            pool = new JedisPool(config,redisIp,redisPort,1000*2);
        }
    
        static{ 
            initPool();
        }
    
        public static Jedis getJedis(){ 
            return pool.getResource();
        }
    
    
        public static void returnBrokenResource(Jedis jedis){ 
            pool.returnBrokenResource(jedis);
        }
    
    
        public static void returnResource(Jedis jedis){ 
            pool.returnResource(jedis);
        }
    
        public static void main(String[] args) { 
            Jedis jedis = pool.getResource();
            jedis.set("geelykey","geelyvalue");
            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、设计RedisPoolUtil（封装redis的操作方法） ##

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

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

## 完。 ##