Jedis操作redis工具类 JedisUtil

package com.wxj.common;

import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.SortingParams;
import redis.clients.util.SafeEncoder;

public class JedisUtil {
       /*缓存生存时间  */
	private int expire = 60000;
	
	  /*对key的操作方法 */
	private static JedisPool jedisPool = null;
	
	public JedisPool getPool(){
		return jedisPool;
	}
	
	/*从jedispool中获取jedis对象*/
	public Jedis getJedis(){
		if(jedisPool == null){
			throw new NullPointerException();
		}
		return jedisPool.getResource();
	}	
	
	public static JedisPool getJedisPool(){
		return jedisPool;
	}
	
	public static void setJedisPool(JedisPool jedisPool){
		JedisUtil.jedisPool = jedisPool;
	}
	
	
	/*
	 * 在finaally中回收jedis
	 */
	public void returnJedis(Jedis jedis){
		if(null != jedis && null != jedisPool){
			jedisPool.returnResource(jedis);
		}
	}
	
	/*
	 * 销毁链接(放入catch
	 */
	public static void returnBrokenResource(Jedis jedis){
		if (null !=jedis && null !=jedisPool) {
			jedisPool.returnResource(jedis);
		}
	}
	
	/*
	 * 设置过期时间
	 */
	public void expire(String key,int seconds){
		if(seconds<0){
			return;
		}
		Jedis jedis = getJedis();
		jedis.expire(key, seconds);
		returnJedis(jedis);
	}
	
	/*
	 * 设置默认过期时间
	 */
	public void expire(String key){
		expire(key,expire);
	}
	
	/*
	 * 清空所有key
	 */
	public String flushAll(){
		Jedis jedis = getJedis();
		String stata = jedis.flushAll();
		returnJedis(jedis);
		return stata;
	}
	
	/*
	 * 更改key 返回值是状态吗
	 */
	
	public String rename(String oldkey,String newkey){
		return rename(SafeEncoder.encode(oldkey),SafeEncoder.encode(newkey));
	}
	
	/*
	 * 更改key，仅当新key不存在时才执行
	 */
	public long renamenx(String oldkey,String newkey){
		Jedis jedis = getJedis();
		long status = jedis.renamenx(oldkey, newkey);
		returnJedis(jedis);
		return status;
		
	}
	
	/*
	 * 更改key
	 */
	public String rename(byte[] oldkey,byte[] newkey){
		Jedis jedis = getJedis();
		String status = jedis.rename(oldkey,newkey);
		returnJedis(jedis);
		return status;	
	}
	
	/*
	 * 设置key的过期时间，以秒为单位             返回值是影响的记录数
	 */
	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,格里高利历)的偏移量
	 */
	public long expireAt(String key,long timestamp){
		Jedis jedis = getJedis();
		long count = jedis.expireAt(key, timestamp);
		returnJedis(jedis);
		return count;
	}
	/*
	 * 查询key的过期时间       以秒为单位的时间表示返回的是指定key的剩余的生存时间
	 */
	public long ttl(String key){
		Jedis sjedis = getJedis();
		long len = sjedis.ttl(key);
		returnJedis(sjedis);
		return len;
		
	}
	/*
	 * 取消对key过期时间的设置  将带生存时间的转换成一个永不过期的key
	 * 
	 * 当移除成功时返回1，key不存在或者移除不成功时返回0
	 */
	public long persist(String key){
		Jedis jedis = getJedis();
		long count = jedis.persist(key);
		returnJedis(jedis);
		return count;	
	}
	
	/*
	 * 删除keys对应的记录，可以是多个key
	 * 
	 * 返回值是被删除的数量
	 */
	public long del(String...keys){
		Jedis jedis = getJedis();
		long count = jedis.del(keys);
		returnJedis(jedis) ;
		return count;
	}
	
	/*
	 * 删除keys对应的记录，可以是多个key
	 */
	public long del(byte[]...keys){
		Jedis jedis = getJedis();
		long count = jedis.del(keys);
		returnJedis(jedis);
		return count;
	}
	/*
	 * 判断key是否存在
	 */
	public boolean exists(String key){
		Jedis jedis = getJedis();
		boolean exists = jedis.exists(key);
		returnJedis(jedis);
		return exists;
	}
	
	/*
	 * 对List，set，SortSet 进行排序，如果集合数据较大应避免使用这个方法
	 * 
	 * 返回排序后的结果，默认升序 sort key Desc为降序
	 */
	public List<String> sort(String key){
		Jedis jedis = getJedis();
		List<String> list = jedis.sort(key);
		
		returnJedis(jedis);
		return list;
	}
	
	/*
	 * 对List，set，SortSet 进行排序，如果集合数据较大应避免使用这个方法
	 * 
	 * 返回排序后的结果，默认升序 sort key Desc为降序
	 */
	public List<String> sort(String key,SortingParams parame){
		Jedis jedis = getJedis();
		List<String> list = jedis.sort(key,parame);
		returnJedis(jedis);
		return list;
	}
	/*
	 * 返回指定key的存储类型
	 */
	
	public String type(String key){
		Jedis jedis = getJedis();
		String type = jedis.type(key);
		returnJedis(jedis);
		return type;
	}
	
	/*
	 * 查找所有匹配模式的键
	 * 
	 * key的查询表达式 *代表任意多个 ？代表一个
	 */
	public Set<String> Keys(String pattern){
		Jedis jedis = getJedis();
		Set<String> set = jedis.keys(pattern);
		
		returnJedis(jedis);
		return set;
	}
	
	/*************************set部分*******************************/
	/*
	 * 向set添加一条记录，如果member已经存在则返回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中元素个数
	 * 
	 * @return 元素个数
	 */
	public long scard(String key){
		Jedis jedis = getJedis();
		Long count = jedis.scard(key);		
		returnJedis(jedis);
		return count;
	}
	
	/*
	 * 返回从第一组和所有的给定集合之间的有差异的成员
	 * 
	 * @return 有差异成员的集合
	 */
	public Set<String> sdiff(String...keys){
		Jedis jedis = getJedis();
		Set<String> set = jedis.sdiff(keys);
		returnJedis(jedis);
		return set;
	}
	
	/*
	 * 这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集,如果目标已存在，则覆盖
	 * 
	 * @return  新集合的记录数
	 */
	public long sdiffstore(String newkey,String...keys){
		Jedis jedis = getJedis();
		Long count = jedis.sdiffstore(newkey, keys);
		returnJedis(jedis);
		return count;
	}
	
	/*
	 * sinter 返回给定集合交集成员，如果其中一个集合为不存在或为空，则返回空set
	 * @return 交集成员的集合
	 */
	public Set<String> sinter(String...keys){
		Jedis jedis = getJedis();
		Set<String> set = jedis.sinter(keys);
		returnJedis(jedis);
		return set;
	}
	/*