RedisPool操作Redis，工具类实例

redis.properties

配置文件内容

redis.pool.maxActive=100
redis.pool.maxIdle=20
redis.pool.maxWait=3000
redis.pool.testOnBorrow=false
redis.pool.testOnReturn=false

redis.ip=127.0.0.1
redis.port=6379
redis.port1=6380
redis.password=****

package com.szreach.rcrp.redis;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;

import org.apache.log4j.Logger;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class RedisUtil {

    private static final Logger log = Logger.getLogger(RedisUtil.class);
    private static JedisPool jedisPool = null;
    private static ShardedJedisPool shardedJedisPool = null;
    /**
     * 初始化Redis连接池
     */
    static {
        try {
            // 加载redis配置文件
            ResourceBundle bundle = ResourceBundle.getBundle("redis");
            if (bundle == null) {
                throw new IllegalArgumentException(
                        "[redis.properties] is not found!");
            }
            int maxActivity = Integer.valueOf(bundle
                    .getString("redis.pool.maxActive"));
            int maxIdle = Integer.valueOf(bundle
                    .getString("redis.pool.maxIdle"));
            long maxWait = Long.valueOf(bundle.getString("redis.pool.maxWait"));
            boolean testOnBorrow = Boolean.valueOf(bundle
                    .getString("redis.pool.testOnBorrow"));
            boolean onreturn = Boolean.valueOf(bundle
                    .getString("redis.pool.testOnReturn"));
            // 创建jedis池配置实例
            JedisPoolConfig config = new JedisPoolConfig();
            // 设置池配置项值
            config.setMaxActive(maxActivity);
            config.setMaxIdle(maxIdle);  //最大空闲连接数
            config.setMaxWait(maxWait);
            config.setTestOnBorrow(testOnBorrow);
            config.setTestOnReturn(onreturn);
            jedisPool = new JedisPool(config, bundle.getString("redis.ip"),
                    Integer.valueOf(bundle.getString("redis.port")), 10000,
                    bundle.getString("redis.password"));
            // slave链接
            List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
            shards.add(new JedisShardInfo(bundle.getString("redis.ip"), Integer
                    .valueOf(bundle.getString("redis.port1"))));
            shardedJedisPool = new ShardedJedisPool(config, shards);
            log.info("初始化Redis连接池success");
        } catch (Exception e) {
            log.error("初始化Redis连接池 出错！", e);
        }
    }

    /**
     * 获取Jedis实例
     * 
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            log.error("Redis缓存获取Jedis实例 出错！", e);
            return null;
        }
    }

    /**
     * 获取shardedJedis实例
     * 
     * @return
     */
    public static ShardedJedis getShardedJedis() {
        try {
            if (shardedJedisPool != null) {
                ShardedJedis resource = shardedJedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            log.error("Redis缓存获取shardedJedis实例 出错！", e);
            return null;
        }
    }

    /**
     * 释放jedis资源
     * 
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }

    /**
     * 释放shardedJedis资源
     * 
     * @param jedis
     */
    public static void returnResource(final ShardedJedis shardedJedis) {
        if (shardedJedis != null) {
            shardedJedisPool.returnResource(shardedJedis);
        }
    }

    /**
     * 向缓存中设置字符串内容
     * 
     * @param key
     *            key
     * @param value
     *            value
     * @return
     * @throws Exception
     */
    public static boolean set(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if(jedis != null){
                jedis.set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error("Redis缓存设置key值 出错！", e);
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * 判断key是否存在
     */
    public static boolean exists(String key){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if (jedis == null) {
                return false;
            } else {
                return jedis.exists(key);
            }
        } catch (Exception e) {
            log.error("Redis缓存判断key是否存在 出错！", e);
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * 删除缓存中的对象，根据key
     * @param key
     * @return
     */
    public static boolean del(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.del(key);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    
    //*******************key-value****************start
    
    /**
     * 向缓存中设置对象
     * 
     * @param key
     * @param value
     * @return
     */
    public static boolean set(String key, Object value) {
        Jedis jedis = null;
        try {
            String objectJson = JSONObject.fromObject(value).toString();
            jedis = getJedis();
            if (jedis != null) {
                jedis.set(key, objectJson);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }

    /**
     * 根据key 获取内容
     * 
     * @param key
     * @return
     */
    public static Object get(String key) {
        ShardedJedis jedis = null;
        try {
            jedis = shardedJedisPool.getResource();
            Object value = jedis.get(key);
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            shardedJedisPool.returnResource(jedis);
        }
    }
    
    /**
     * 根据key 获取对象
     * 
     * @param key
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T get(String key, Class<T> clazz) {
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if (jedis != null) {
                return (T) JSONObject.toBean(JSONObject.fromObject(jedis.get(key)), clazz);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    //*******************key-value****************end
    
    //*************** 操作list****************start
    /**
     * 向缓存中设置对象 
     * @param key
     * @param list
     * T string calss
     * @return
     */
    public static <T> boolean setList(String key,List<T> list){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                for (T vz : list) {
                    if (vz instanceof String) {
                        jedis.lpush(key, (String) vz);
                    } else {
                        String objectJson = JSONObject.fromObject(vz).toString();
                        jedis.lpush(key, objectJson);
                    }
                }
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    
    @SuppressWarnings("unchecked")
    public static <T> List<T> getListEntity(String key,Class<T> entityClass){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if (jedis != null) {
                List<String> valueJson = jedis.lrange(key, 0, -1);
                JSONArray json = new JSONArray();
                json.addAll(valueJson);
                JSONArray jsonArray = JSONArray.fromObject(json.toString());
                return (List<T>) JSONArray.toCollection(jsonArray, entityClass);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    public static List<String> getListString(String key){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if (jedis != null) {
                return jedis.lrange(key, 0, -1);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    //*************** 操作list****************end
    
    //*************** 操作map****************start
    public static <K,V> boolean setMap(String key,Map<String,V> map){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                Set<Map.Entry<String, V>> entry = map.entrySet();
                for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
                    Map.Entry<String, V> kv = ite.next();
                    if (kv.getValue() instanceof String) {
                        jedis.hset(key, kv.getKey(), (String) kv.getValue());
                    }else if (kv.getValue() instanceof List) {
                        jedis.hset(key, kv.getKey(), JSONArray.fromObject(kv.getValue()).toString());
                    } else {
                        jedis.hset(key, kv.getKey(), JSONObject.fromObject(kv.getValue()).toString());
                    }
                }
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    public static boolean setMapKey(String key,String mapKey,Object value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                if (value instanceof String) {
                    jedis.hset(key, mapKey, String.valueOf(value));
                } else if (value instanceof List) {
                    jedis.hset(key, mapKey, JSONArray.fromObject(value).toString());
                } else {
                    jedis.hset(key, mapKey, JSONObject.fromObject(value).toString());
                }
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * seconds key和value 保存的有效时间（单位：秒）
     * @return
     */
    public static boolean setMapKeyExpire(String key,String mapKey,Object value, int seconds){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                if (value instanceof String) {
                    jedis.hset(key, mapKey, String.valueOf(value));
                } else if (value instanceof List) {
                    jedis.hset(key, mapKey, JSONArray.fromObject(value).toString());
                } else {
                    jedis.hset(key, mapKey, JSONObject.fromObject(value).toString());
                }
                jedis.expire(key, seconds);
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    @SuppressWarnings("unchecked")
    public static <K,V> Map<String,V> getMap(String key){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if (jedis != null) {
                Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
                return map;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    @SuppressWarnings("unchecked")
    public static <K,V> Map<String,V> getMapEntityClass(String key,Class<V> clazz){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if (jedis != null) {
                Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
                Set<Map.Entry<String, V>> entry = map.entrySet();
                for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
                    Map.Entry<String, V> kv = ite.next();
                    map.put(kv.getKey(), (V) JSONObject.toBean(JSONObject.fromObject(kv.getValue()), clazz));
                }
                return map;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    @SuppressWarnings("unchecked")
    public static <K,V> Map<String,List<V>> getMapList(String key,Class<V> clazz){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if (jedis != null) {
                Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
                Set<Map.Entry<String, V>> entry = map.entrySet();
                for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
                    Map.Entry<String, V> kv = ite.next();
                    JSONArray jsonArray = JSONArray.fromObject(kv.getValue());
                    map.put(kv.getKey(), (V) JSONArray.toCollection(jsonArray, clazz));
                }
                return (Map<String, List<V>>) map;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    @SuppressWarnings("unchecked")
    public static <T> List<T> getMapKeyListEntity(String key,String mapKey,
            Class<T> entityClass){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if (jedis != null) {
                String valueJson = jedis.hget(key, mapKey);
                JSONArray jsonArray = JSONArray.fromObject(valueJson);
                return (List<T>) JSONArray.toCollection(jsonArray, entityClass);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    @SuppressWarnings("unchecked")
    public static <T> T getMapKeyEntity(String key,String mapKey,
            Class<T> entityClass){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if(jedis != null){
            String valueJson=jedis.hget(key, mapKey);
            return (T) JSONObject.toBean(JSONObject.fromObject(valueJson), entityClass);
            }else{return null;}
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    public static Object getMapKey(String key,String mapKey){
        ShardedJedis jedis = null;
        try {
            jedis = getShardedJedis();
            if(jedis != null){
            return jedis.hget(key, mapKey);
            }else{return null;}
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    public static boolean delMapKey(String key,String mapKey){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.hdel(key, mapKey);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    public static boolean hexists(String key,String mapKey){
        ShardedJedis jedis = null;
        try {
            jedis = shardedJedisPool.getResource();
            return jedis.hexists(key,mapKey);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            shardedJedisPool.returnResource(jedis);
        }
    }
    //*************** 操作map****************end
    
    //***************计数器应用INCR,DECR****************begin
    //Redis的命令都是原子性的，你可以轻松地利用INCR，DECR命令来构建计数器系统
    
    /**
     * incr(key)：名称为key的string增1操作
     */
    public static boolean incr(String key){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.incr(key);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * incrby(key, integer)：名称为key的string增加integer
     */
    public static boolean incrBy(String key, int value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.incrBy(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * decr(key)：名称为key的string减1操作
     */
    public static boolean decr(String key){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.decr(key);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * decrby(key, integer)：名称为key的string减少integer
     */
    public static boolean decrBy(String key, int value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.decrBy(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    //***************计数器应用INCR,DECR****************end
    
    //***************使用sorted set(zset)甚至可以构建有优先级的队列系统***************begin
    /**
     * 向名称为key的zset中添加元素member，score用于排序。
     * 如果该元素已经存在，则根据score更新该元素的顺序
     */
    public static boolean zadd(String key, double score, String member){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.zadd(key, score, member);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * 删除名称为key的zset中的元素member
     */
    public static boolean zrem(String key, String... members){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.zrem(key, members);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * 返回集合中score在给定区间的元素
     */
    public static Set<String> zrangeByScore(String key, double min, double max){
        ShardedJedis jedis = null;
        try {
            jedis = shardedJedisPool.getResource();
            return jedis.zrangeByScore(key, min, max);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    //***************使用sorted set(zset)甚至可以构建有优先级的队列系统***************end
    
    //***************sorted set 处理***************************************begin
    //zset 处理
    public static boolean zaddObject(String key, double score, Object value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            String objectJson = JSONObject.fromObject(value).toString();
            jedis.zadd(key, score, objectJson);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * score值递减(从大到小)次序排列。
     * @param key
     * @param max score
     * @param min score
     * @param entityClass
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  <T> List<T> zrevrangeByScore(String key,double max,double min, 
            Class<T> entityClass){
        ShardedJedis jedis = null;
        try {
            jedis =shardedJedisPool.getResource();
            Set<String> set=jedis.zrevrangeByScore(key, max, min);
            List<T> list=new ArrayList<T>();
            for (String str : set) {  
                list.add((T) JSONObject.toBean(JSONObject.fromObject(str), entityClass));
            } 
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    /**
     * score值递减(从大到小)次序排列。
     * @param key
     * @param max score
     * @param min score
     * @param offset count (类似mysql的 LIMIT)
     * @param entityClass
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  <T> List<T> zrevrangeByScore(String key,double max,double min,
            int offset, int count,Class<T> entityClass){
        ShardedJedis jedis = null;
        try {
            jedis =shardedJedisPool.getResource();
            Set<String> set=jedis.zrevrangeByScore(key, max, min,offset,count);
            List<T> list=new ArrayList<T>();
            for (String str : set) {  
                list.add((T) JSONObject.toBean(JSONObject.fromObject(str), entityClass));
            } 
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            returnResource(jedis);
        }
    }
    
    
    //得到总记录数
    public static long zcard(String key){
        ShardedJedis jedis = null;
        try {
            jedis =shardedJedisPool.getResource();
            return jedis.zcard(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            returnResource(jedis);
        }
    }
    
    //删除 元素
    public static  boolean zremObject(String key, Object value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            String objectJson = JSONObject.fromObject(value).toString();
            jedis.zrem(key, objectJson);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }
    
    //统计zset集合中score某个范围内（1-5），元素的个数
    public static long zcount(String key,double min, double max){
        ShardedJedis jedis = null;
        try {
            jedis =shardedJedisPool.getResource();
            return jedis.zcount(key,min,max);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            returnResource(jedis);
        }
    }
    
    //查看zset集合中元素的score
    public static double zscore(String key,Object value){
        ShardedJedis jedis = null;
        try {
            jedis =shardedJedisPool.getResource();
            String objectJson = JSONObject.fromObject(value).toString();
            return jedis.zscore(key,objectJson);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            returnResource(jedis);
        }
    }
    //**************sorted set******************************************end
    
    //***********************Redis Set集合操作**************************begin
    /**
     * sadd:向名称为Key的set中添加元素,同一集合中不能出现相同的元素值。（用法：sadd set集合名称 元素值）
     * @param key
     * @param value
     * @return
     */
    public static boolean sadd(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.sadd(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }

    /**
     * srem:删除名称为key的set中的元素。（用法：srem set集合名称 要删除的元素值）
     * 
     * @param key
     * @param value
     * @return
     */
    public static boolean srem(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.srem(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }

    /**
     * sdiff:返回所有给定key与第一个key的差集。（用法：sdiff set集合1 set集合2）
     * 
     * @param key1
     * @param key2
     * @return
     */
    public static Set<String> sdiff(String key1, String key2) {
        Jedis jedis = null;
        Set<String> diffList = null;
        try {
            jedis = getJedis();
            diffList = jedis.sdiff(key1, key2);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            returnResource(jedis);
        }
        return diffList;
    }

    /**
     * sismember:判断某个值是否是集合的元素。（用法：sismember 集合1 指定的元素值）
     * 
     * @param key
     * @param value
     * @return
     */
    public static boolean sismember(String key, String value) {
        ShardedJedis jedis = null;
        try {
            jedis = shardedJedisPool.getResource();
            return jedis.sismember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            returnResource(jedis);
        }
    }

    /**
     * smembers(key) ：返回名称为key的set的所有元素
     * 
     * @param key
     * @return
     */
    public static Set<String> smembers(String key) {
        Jedis jedis = null;
        Set<String> list = null;
        try {
            jedis = getJedis();
            list = jedis.smembers(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            returnResource(jedis);
        }
        return list;
    }
    
    //***********************Redis Set集合操作****************************end
}