java redis连接池、redis单例模式以及简单工具类

ゝ一纸荒年。 2023-01-14 11:54 100阅读 0赞

/**
     * 获取redis连接池
     */
    public final class RedisPro  {
        private static final Logger log = LoggerFactory.getLogger(RedisPro.class);
    
        //Redis服务器地址
        private static String redisHost = LoadProperties.getProperty("redis.host");
        //Redis服务端口
        private static Integer redisPort = Integer.parseInt(LoadProperties.getProperty("redis.port"));
        //Redis密码
        private static String redisPassword = LoadProperties.getProperty("redis.password");
        //Redis可连接实例最大数目
        private static Integer redisMaxTotal = Integer.parseInt(LoadProperties.getProperty("redis.maxTotal"));
        //Redis最多有多少个状态为idle(空闲)的jedis实例，默认值是8
        private static Integer redisMaxIdle = Integer.parseInt(LoadProperties.getProperty("redis.maxIdle"));
        //Reids等待可用连接的最大时间，单位是毫秒，默认值为-1，表示永不超时。
        private static Integer redisMaxWaitNillis = Integer.parseInt(LoadProperties.getProperty("redis.maxWaitNillis"));
        //Redis设置超时时间
        private static Integer redisTimeOut = Integer.parseInt(LoadProperties.getProperty("redis.timeOut"));
    
        //在borrow(用)一个jedis实例时，是否提前进行validate(验证)操作；
        private static Boolean redisTestOnBorrow = true;
        private static JedisPool jedisPool = null;
    
        static {
            try {
                JedisPoolConfig config = new JedisPoolConfig();
                config.setMaxTotal(redisMaxTotal);
                config.setMaxIdle(redisMaxIdle);
                config.setMaxWaitMillis(redisMaxWaitNillis);
                config.setTestOnBorrow(redisTestOnBorrow);
                jedisPool = new JedisPool(config, redisHost, redisPort, redisTimeOut);
            } catch (Exception e) {
                log.warn("Redis初始化失败{}", e.getMessage());
            }
        }
    
        //获取连接池对象
        public synchronized static Jedis getJedisPool(int index) {
            try {
                if (jedisPool != null) {
                    Jedis jedis = jedisPool.getResource();
                    jedis.select(index);
                    return jedis;
                } else {
                    log.warn("获取Redis对象失败");
                    return null;
                }
            } catch (Exception e) {
                log.warn("获取Redis对象失败{}", e.getMessage());
                return null;
            }
        }
    
        //关闭redis连接池
        public static void close() {
            if (jedisPool != null) {
                jedisPool.close();
            }
        }
    
        /**
         * JSON数据，转成Object对象
         */
        public static <T> T fromJson(String json, Class<T> clazz){
            try{
                return JSON.parseObject(json, clazz);
            }catch (Exception e){
                log.warn("redis value fromJson error. msg: {}, value: {}, class: {}", e.getMessage(), json, clazz);
            }
            return null;
        }
    
        /**
         * Object转成JSON数据
         */
        public static String toJson(Object object){
            try {
                if (object instanceof Integer || object instanceof Long || object instanceof Float ||
                        object instanceof Double || object instanceof Boolean || object instanceof String) {
                    return String.valueOf(object);
                }
                return JSON.toJSONString(object);
            }catch (Exception e){
                log.warn("value toJson error. msg: {}, object: {}", e.getMessage(), object);
            }
            return null;
        }
    
        /**
         * redis get
         */
        public static <T> T get(Integer index, String key, Class<T> clazz){
            try{
                Jedis jedis = RedisPro.getJedisPool(index);
                String value =jedis.get(key);
                return value==null?null:fromJson(value, clazz);
            }catch (Exception e){
                log.warn(" redis get operation error. msg: {} index: {}, key: {}, class: {}",e.getMessage(), index, key, clazz);
            }
            return null;
        }
    
        /**
         * redis hget
         */
        public static <T> T hget(Integer index, String name, String key, Class<T> clazz){
            try{
                Jedis jedis = RedisPro.getJedisPool(index);
                String value = jedis.hget(name, key);
                return value==null?null:fromJson(value, clazz);
            }catch (Exception e){
                log.warn(" redis hget operation error. msg: {} index: {}, key: {}, class: {}",e.getMessage(), index, key, clazz);
            }
            return null;
        }
    
        /**
         * redis get keys
         */
        public static List<String> getKeys(Integer index){
            try{
                Jedis jedis = RedisPro.getJedisPool(index);
                return new ArrayList<String>(jedis.keys("*"));
            }catch (Exception e){
                log.warn(" redis getKeys operation error. msg: {} index: {}",e.getMessage(), index);
            }
            return null;
        }
    
        /**
         * redis get keys by prefix
         */
        public static List<String> getPrefixKeys(Integer index, String prefix){
            try{
                Jedis jedis = RedisPro.getJedisPool(index);
                return new ArrayList<String>(jedis.keys(prefix + "*"));
            }catch (Exception e){
                log.warn(" redis getPrefixKeys operation error. msg: {} index: {} prefix: {}",e.getMessage(), index, prefix);
            }
            return null;
        }
    
    }