文章目錄

• 1、使用了jedis客戶端，對redis進行了封裝，包括：
• 1）使用了redispool獲取連線；以及連線的回收；
• 2）常用五種資料結構的常用操作封裝；
• 2、序列化、反序列化：
• 3、測試：
• 1）直接使用RedisUtils例項進行五大資料型別的操作：（這樣，使用完後會自動歸還到池子中）
• 2）通過RedisUtil例項獲取Jedis連線物件；這樣就可以用原生的方式使用；最後使用完後需要手動將其歸還到池子中：
• 3）將java物件存到redis中：
• 與spring整合的配置
• application-redis.xml
• redis.properties

1、使用了jedis客戶端，對redis進行了封裝，包括：

1）使用了redispool獲取連線；以及連線的回收；

2）常用五種資料結構的常用操作封裝；

package redis.utils;
 
import java.util.List;
import java.util.Map;
import java.util.Set;
 
//import org.apache.log4j.Logger;
 
 
import
 
 redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig; 
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.SafeEncoder;
 
/**
 * @author Mr.hu
 * @version crateTime：2013-10-30 下午5:41:30
 * Class Explain:JedisUtil  
 */
 

public class JedisUtil { 
	
	 //private Logger log = Logger.getLogger(this.getClass());  
	 /**快取生存時間 */
	 private final int expire = 60000;
	 /** 操作Key的方法 */
	 public Keys KEYS;
	 /** 對儲存結構為String型別的操作 */
	 public Strings STRINGS;
	 /** 對儲存結構為List型別的操作 */
	 public Lists LISTS;
 	 /** 對儲存結構為Set型別的操作 */
	 public Sets SETS;
	 /** 對儲存結構為HashMap型別的操作 */
	 public Hash HASH;
	 /** 對儲存結構為Set(排序的)型別的操作 */
	 public SortSet SORTSET;
	 private static JedisPool jedisPool = null;  
		 
	 private JedisUtil() {   
		
	 } 
     static {  
            JedisPoolConfig config = new JedisPoolConfig();  
            //控制一個pool可分配多少個jedis例項，通過pool.getResource()來獲取；  
            //如果賦值為-1，則表示不限制；如果pool已經分配了maxActive個jedis例項，則此時pool的狀態為exhausted(耗盡)。  
            config.setMaxTotal(500);  
            //控制一個pool最多有多少個狀態為idle(空閒的)的jedis例項。  
            config.setMaxIdle(5);  
            //表示當borrow(引入)一個jedis例項時，最大的等待時間，如果超過等待時間，則直接丟擲JedisConnectionException；  
            config.setMaxWaitMillis(1000 * 100);  
            //在borrow一個jedis例項時，是否提前進行validate操作；如果為true，則得到的jedis例項均是可用的；  
            config.setTestOnBorrow(true);  
            
            //redis如果設定了密碼：
            /*jedisPool = new JedisPool(config, JRedisPoolConfig.REDIS_IP, 
            		JRedisPoolConfig.REDIS_PORT,
            		10000,JRedisPoolConfig.REDIS_PASSWORD);    */
            
            //redis未設定了密碼：
           jedisPool = new JedisPool(config, "127.0.0.1",6379); 
	   }
     
 	public JedisPool getPool() {  
 		return jedisPool; 
 	}
 	
     /**
      * 從jedis連線池中獲取獲取jedis物件  
      * @return
      */
     public Jedis getJedis() {  
    	 return jedisPool.getResource(); 
 	}
     
     
     private static final JedisUtil jedisUtil = new JedisUtil();
	 
 
    /**
     * 獲取JedisUtil例項
     * @return
     */
    public static JedisUtil getInstance() {
		return jedisUtil; 
	}
 
    /**
     * 回收jedis(放到finally中)
     * @param jedis
     */
    public void returnJedis(Jedis jedis) {
    	if (null != jedis && null != jedisPool) {
    		jedisPool.returnResource(jedis);
    	}
	} 
    
    /**
     * 銷燬連線(放到catch中)
     * @param pool
     * @param jedis
     */
	public static void returnBrokenResource(Jedis jedis) {
		if (null != jedis && null != jedisPool) {
			jedisPool.returnResource(jedis);
		}
	}
 
    
    /**
	 * 設定過期時間
	 * @author ruan 2013-4-11
	 * @param key
	 * @param seconds
	 */
	public void expire(String key, int seconds) {
		if (seconds <= 0) { 
			return;
		}
		Jedis jedis = getJedis();
		jedis.expire(key, seconds);
		returnJedis(jedis);
	}
 
	/**
	 * 設定預設過期時間
	 * @author ruan 2013-4-11
	 * @param key
	 */
	public void expire(String key) {
		expire(key, expire);
	}
	
	
	//*******************************************Keys*******************************************//
	public class Keys {
 
		/**
		 * 清空所有key
		 */
		public String flushAll() {
			Jedis jedis = getJedis();
			String stata = jedis.flushAll();
			returnJedis(jedis);
			return stata;
		}
 
		/**
		 * 更改key
		 * @param String oldkey
		 * @param String  newkey
		 * @return 狀態碼
		 * */
		public String rename(String oldkey, String newkey) { 
			return rename(SafeEncoder.encode(oldkey),
					SafeEncoder.encode(newkey));
		}
 
		/**
		 * 更改key,僅當新key不存在時才執行
		 * @param String oldkey
		 * @param String newkey 
		 * @return 狀態碼
		 * */
		public long renamenx(String oldkey, String newkey) {
			Jedis jedis = getJedis();
			long status = jedis.renamenx(oldkey, newkey);
			returnJedis(jedis);
			return status;
		}
 
		/**
		 * 更改key
		 * @param String oldkey
		 * @param String newkey
		 * @return 狀態碼
		 * */
		public String rename(byte[] oldkey, byte[] newkey) {
			Jedis jedis = getJedis();
			String status = jedis.rename(oldkey, newkey);
			returnJedis(jedis);
			return status;
		}
 
		/**
		 * 設定key的過期時間，以秒為單位
		 * @param String key
		 * @param 時間,已秒為單位
		 * @return 影響的記錄數
		 * */
		public long expired(String key, int seconds) {
			Jedis jedis = getJedis();
			long count = jedis.expire(key, seconds);
			returnJedis(jedis);
			return count;
		}
 
		/**
		 * 設定key的過期時間,它是距曆元（即格林威治標準時間 1970 年 1 月 1 日的 00:00:00，格里高利曆）的偏移量。
		 * @param String key
		 * @param 時間,已秒為單位
		 * @return 影響的記錄數
		 * */
		public long expireAt(String key, long timestamp) {
			Jedis jedis = getJedis();
			long count = jedis.expireAt(key, timestamp);
			returnJedis(jedis);
			return count;
		}
 
		/**
		 * 查詢key的過期時間
		 * @param String key
		 * @return 以秒為單位的時間表示
		 * */
		public long ttl(String key) {
			//ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis=getJedis(); 
			long len = sjedis.ttl(key);
			returnJedis(sjedis);
			return len;
		}
 
		/**
		 * 取消對key過期時間的設定
		 * @param key
		 * @return 影響的記錄數
		 * */
		public long persist(String key) {
			Jedis jedis = getJedis();
			long count = jedis.persist(key);
			returnJedis(jedis);
			return count;
		}
 
		/**
		 * 刪除keys對應的記錄,可以是多個key
		 * @param String  ... keys
		 * @return 刪除的記錄數
		 * */
		public long del(String... keys) {
			Jedis jedis = getJedis();
			long count = jedis.del(keys);
			returnJedis(jedis);
			return count;
		}
 
		/**
		 * 刪除keys對應的記錄,可以是多個key
		 * @param String .. keys
		 * @return 刪除的記錄數
		 * */
		public long del(byte[]... keys) {
			Jedis jedis = getJedis();
			long count = jedis.del(keys);
			returnJedis(jedis);
			return count;
		}
 
		/**
		 * 判斷key是否存在
		 * @param String key
		 * @return boolean
		 * */
		public boolean exists(String key) {
			//ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis=getJedis();  
			boolean exis = sjedis.exists(key);
			returnJedis(sjedis);
			return exis;
		}
 
		/**
		 * 對List,Set,SortSet進行排序,如果集合資料較大應避免使用這個方法
		 * @param String key
		 * @return List<String> 集合的全部記錄
		 * **/
		public List<String> sort(String key) {
			//ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis=getJedis();  
			List<String> list = sjedis.sort(key);
			returnJedis(sjedis);
			return list;
		}
 
		/**
		 * 對List,Set,SortSet進行排序或limit
		 * @param String key
		 * @param SortingParams parame 定義排序型別或limit的起止位置.
		 * @return List<String> 全部或部分記錄
		 * **/
		public List<String> sort(String key, SortingParams parame) {
			//ShardedJedis sjedis = getShardedJedis(); 
			Jedis sjedis=getJedis(); 
			List<String> list = sjedis.sort(key, parame);
			returnJedis(sjedis);
			return list;
		}
 
		/**
		 * 返回指定key儲存的型別
		 * @param String key
		 * @return String string|list|set|zset|hash
		 * **/
		public String type(String key) {
			//ShardedJedis sjedis = getShardedJedis(); 
			Jedis sjedis=getJedis();  
			String type = sjedis.type(key); 
			returnJedis(sjedis);
			return type;
		}
 
		/**
		 * 查詢所有匹配給定的模式的鍵
		 * @param String  key的表示式,*表示多個，？表示一個
		 * */
		public Set<String> keys(String pattern) {
			Jedis jedis = getJedis();
			Set<String> set = jedis.keys(pattern);
			returnJedis(jedis);
			return set;
		}
	}
 
	//*******************************************Sets*******************************************//
	public class Sets {
 
		/**
		 * 向Set新增一條記錄，如果member已存在返回0,否則返回1
		 * @param String  key
		 * @param String member
		 * @return 操作碼,0或1
		 * */
		public long sadd(String key, String member) {
			Jedis jedis = getJedis();
			long s = jedis.sadd(key, member);
			returnJedis(jedis);
			return s;
		}
 
		public long sadd(byte[] key, byte[] member) {
			Jedis jedis = getJedis();
			long s = jedis.sadd(key, member);
			returnJedis(jedis);
			return s;
		}
 
		/**
		 * 獲取給定key中元素個數
		 * @param String key
		 * @return 元素個數
		 * */
		public long scard(String key) {
		    //ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis = getJedis(); 
			long len = sjedis.scard(key);
			returnJedis(sjedis);
			return len;
		}
 
		/**
		 * 返回從第一組和所有的給定集合之間的差異的成員
		 * @param String ... keys
		 * @return 差異的成員集合
		 * */
		public Set<String> sdiff(String... keys) {
			Jedis jedis = getJedis();
			Set<String> set = jedis.sdiff(keys);
			returnJedis(jedis);
			return set;
		}
 
		/**
		 * 這個命令等於sdiff,但返回的不是結果集,而是將結果集儲存在新的集合中，如果目標已存在，則覆蓋。
		 * @param String newkey 新結果集的key
		 * @param String ... keys 比較的集合
		 * @return 新集合中的記錄數
		 * **/
		public long sdiffstore(String newkey, String... keys) {
			Jedis jedis = getJedis();
			long s = jedis.sdiffstore(newkey, keys);
			returnJedis(jedis);
			return s;
		}
 
		/**
		 * 返回給定集合交集的成員,如果其中一個集合為不存在或為空，則返回空Set
		 * @param String ... keys
		 * @return 交整合員的集合
		 * **/
		public Set<String> sinter(String... keys) {
			Jedis jedis = getJedis();
			Set<String> set = jedis.sinter(keys);
			returnJedis(jedis);
			return set;
		}
 
		/**
		 * 這個命令等於sinter,但返回的不是結果集,而是將結果集儲存在新的集合中，如果目標已存在，則覆蓋。
		 * @param String  newkey 新結果集的key
		 * @param String ... keys 比較的集合
		 * @return 新集合中的記錄數
		 * **/
		public long sinterstore(String newkey, String... keys) {
			Jedis jedis = getJedis();
			long s = jedis.sinterstore(newkey, keys);
			returnJedis(jedis);
			return s;
		}
 
		/**
		 * 確定一個給定的值是否存在
		 * @param String  key
		 * @param String member 要判斷的值
		 * @return 存在返回1，不存在返回0
		 * **/
		public boolean sismember(String key, String member) {
			//ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis = getJedis(); 
			boolean s = sjedis.sismember(key, member);
			returnJedis(sjedis);
			return s;
		}
 
		/**
		 * 返回集合中的所有成員
		 * @param String  key
		 * @return 成員集合
		 * */
		public Set<String> smembers(String key) {
			//ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis = getJedis(); 
			Set<String> set = sjedis.smembers(key);
			returnJedis(sjedis);
			return set;
		}
 
		public Set<byte[]> smembers(byte[] key) {
			//ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis = getJedis();  
			Set<byte[]> set = sjedis.smembers(key);
			returnJedis(sjedis);
			return set;
		}
 
		/**
		 * 將成員從源集合移出放入目標集合 <br/>
		 * 如果源集合不存在或不包哈指定成員，不進行任何操作，返回0<br/>
		 * 否則該成員從源集合上刪除，並新增到目標集合，如果目標集合中成員已存在，則只在源集合進行刪除
		 * @param String  srckey 源集合
		 * @param String dstkey 目標集合
		 * @param String member 源集合中的成員
		 * @return 狀態碼，1成功，0失敗
		 * */
		public long smove(String srckey, String dstkey, String member) {
			Jedis jedis = getJedis();
			long s = jedis.smove(srckey, dstkey, member);
			returnJedis(jedis);
			return s;
		}
 
		/**
		 * 從集合中刪除成員
		 * @param String  key
		 * @return 被刪除的成員
		 * */
		public String spop(String key) {
			Jedis jedis = getJedis();
			String s = jedis.spop(key);
			returnJedis(jedis);
			return s;
		}
 
		/**
		 * 從集合中刪除指定成員
		 * @param String key
		 * @param String  member 要刪除的成員
		 * @return 狀態碼，成功返回1，成員不存在返回0
		 * */
		public long srem(String key, String member) {
			Jedis jedis = getJedis();
			long s = jedis.srem(key, member);
			returnJedis(jedis);
			return s;
		}
 
		/**
		 * 合併多個集合並返回合併後的結果，合併後的結果集合並不儲存<br/>
		 * @param String  ... keys
		 * @return 合併後的結果集合
		 * @see sunionstore
		 * */
		public Set<String> sunion(String... keys) {
			Jedis jedis = getJedis();
			Set<String> set = jedis.sunion(keys);
			returnJedis(jedis);
			return set;
		}
 
		/**
		 * 合併多個集合並將合併後的結果集儲存在指定的新集合中，如果新集合已經存在則覆蓋
		 * @param String  newkey 新集合的key
		 * @param String ... keys 要合併的集合
		 * **/
		public long sunionstore(String newkey, String... keys) {
			Jedis jedis = getJedis();
			long s = jedis.sunionstore(newkey, keys);
			returnJedis(jedis);
			return s;
		}
	}
 
	//*******************************************SortSet*******************************************//
	public class SortSet {
 
		/**
		 * 向集合中增加一條記錄,如果這個值已存在，這個值對應的權重將被置為新的權重
		 * @param String  key
		 * @param double score 權重
		 * @param String  member 要加入的值，
		 * @return 狀態碼 1成功，0已存在member的值
		 * */
		public long zadd(String key, double score, String member) {
			Jedis jedis = getJedis();
			long s = jedis.zadd(key, score, member);
			returnJedis(jedis);
			return s;
		}
 
		/*public long zadd(String key, Map<Double, String> scoreMembers) {
			Jedis jedis = getJedis();
			long s = jedis.zadd(key, scoreMembers);
			returnJedis(jedis);
			return s;
		}*/
 
		/**
		 * 獲取集合中元素的數量
		 * @param String  key
		 * @return 如果返回0則集合不存在
		 * */
		public long zcard(String key) {
			//ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis = getJedis();
			long len = sjedis.zcard(key);
			returnJedis(sjedis);
			return len;
		}
 
		/**
		 * 獲取指定權重區間內集合的數量
		 * @param String key
		 * @param double min 最小排序位置
		 * @param double max 最大排序位置
		 * */
		public long zcount(String key, double min, double max) {
			//ShardedJedis sjedis = getShardedJedis();
			Jedis sjedis = getJedis();
			long len = sjedis.zcount(key, min, max);
			returnJedis(sjedis);
			return len;
		}
 
		/**
		 * 獲得set的長度
		 * 
		 * @param key
		 * @return
		 */
		public long zlength(String key) {
			long len = 0;
			Set<String> set = zran