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
}