java jedis操作工具类

package com.conb.util;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

/**
 * @description redis工具类
 * @author haixia.shi
 * @date 2017年12月1日
 *
 */
@Repository
public class RedisUtils {

	private static final Logger logger = LoggerFactory.getLogger(RedisUtils.class);

	@Autowired
	private JedisPool jedisPool;

	/************************************* String ***********************************/

	/**
	 * 存储字符串类型的数据(存在则覆盖，不存在则新增)
	 * 
	 * @param key
	 * @param value
	 * @return 操作成功返回 ok ，否则返回null及错误信息
	 */
	public String setString(String key, String value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.set(key, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 存储字符串类型的数据(存在则不变，不存在则新增)
	 * 
	 * @param key
	 * @param value
	 * @return 1：成功，0：失败
	 */
	public Long setnxString(String key, String value) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.setnx(key, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 存储一个或多个字符串类型的数据(存在则覆盖，不存在则新增)
	 * 
	 * @param keysvalues
	 *            key value对
	 * @return 操作成功返回 ok ，否则返回null及错误信息
	 */
	public String mset(String... keysvalues) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.mset(keysvalues);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 存储一个或多个字符串类型的数据(有一个存在则不变，全不存在则新增)
	 * 
	 * @param keysvalues
	 *            keysvalues key value对
	 * @return 1：成功，0：失败
	 */
	public Long msetnx(String... keysvalues) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.msetnx(keysvalues);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 存储有时效的字符串类型的数据
	 * 
	 * @param key
	 * @param value
	 * @param time
	 *            过期时间 单位：秒
	 * @return 操作成功返回 ok ，否则返回null及错误信息
	 */
	public String setexString(String key, String value, int time) {
		// 从redis连接池中获取一个连接
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.setex(key, time, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取字符串类型的数据
	 * 
	 * @param key
	 * @return
	 */
	public String getString(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.get(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 删除String类型的数据
	 * 
	 * @param key
	 * @return 操作次数
	 */
	public Long delString(String key) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.del(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 删除String类型(流化后)的数据
	 * 
	 * @param key
	 */
	public Long delSerializeString(String key) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.del(SerializeUtils.serialize(key));
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 判断String类型的key是否存在
	 * 
	 * @param key
	 * @return 存在：true ， 不存在：false
	 */
	public Boolean existStringKey(String key) {
		Jedis jedis = null;
		Boolean result = false;
		try {
			jedis = jedisPool.getResource();
			result = jedis.exists(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 判断String类型的key的value是否存在
	 * 
	 * @param key
	 * @param value
	 * @return 存在：true ， 不存在：false
	 */
	public Boolean existStringValue(String key, String value) {
		Jedis jedis = null;
		boolean result = true;
		try {
			jedis = jedisPool.getResource();
			result = jedis.sismember(key, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * String类型key的value值增加1
	 * 
	 * @param key
	 * @return 返回新value
	 */
	public Long incr(String key) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.incr(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * String类型key的value值增加n(n可以为负数，n为负数时做减法)
	 * 
	 * @param key
	 * @param integer
	 * @return 返回新value
	 */
	public Long incrBy(String key, int integer) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.incrBy(key, integer);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * String类型key的value值1减少1
	 * 
	 * @param key
	 * @return 返回新value
	 */
	public long decrString(String key) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.decr(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * String类型key的value值1减少n(n可以为负数，n为负数时做加法)
	 * 
	 * @param key
	 * @param integer
	 * @return 返回新value
	 */
	public Long decrBy(String key, long integer) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.decrBy(key, integer);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 在String类型key的value后面追加值
	 * 
	 * @param key
	 * @param value
	 * @return 返回新value的长度
	 */
	public Long appendString(String key, String value) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.append(key, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 截取字符串
	 * 
	 * @param key
	 * @param start
	 *            开始下标
	 * @param end
	 *            结束下标
	 * @return 返回截取后的字符串
	 */
	public String substr(String key, int start, int end) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.substr(key, start, end);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * String类型的key重命名(如果新key存在，则覆盖)
	 * 
	 * @param oldKey
	 *            旧key
	 * @param newKey
	 *            新key
	 * @return 操作成功返回 ok ，否则返回null及错误信息
	 */
	public String renameKey(String oldKey, String newKey) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.rename(oldKey, newKey);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * String类型的key重命名(如果新key存在，则修改失败)
	 * 
	 * @param oldKey
	 *            旧key
	 * @param newKey
	 *            新key
	 * @return 1：成功 ， 0：失败
	 */
	public long renamenxKey(String oldKey, String newKey) {
		Jedis jedis = null;
		long result = 1;
		try {
			jedis = jedisPool.getResource();
			result = jedis.renamenx(oldKey, newKey);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取并修改value（返回修改前的value）
	 * 
	 * @param key
	 * @param value
	 * @return 返回新value
	 */
	public String getSetKey(String key, String value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.getSet(key, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/************************************* Object ***********************************/

	/**
	 * 存储Object类型的数据(流化后的key和value)
	 * 
	 * @param key
	 * @param value
	 */
	public void setSerializeObject(Object key, Object value) {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			jedis.set(SerializeUtils.serialize(key), SerializeUtils.serialize(value));
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
	}

	/**
	 * 存储有时效的（流化后的）Object类型的数据
	 * 
	 * @param key
	 * @param time
	 * @param value
	 */
	public void setexSerializeTime(Object key, int time, Object value) {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			jedis.setex(SerializeUtils.serialize(key), time, SerializeUtils.serialize(value));
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
	}

	/**
	 * 获取Object类型(流化后的)的数据并解流
	 * 
	 * @param key
	 * @return
	 */
	public Object getSerializeObject(Object key) {
		Jedis jedis = null;
		Object obj = null;
		try {
			jedis = jedisPool.getResource();
			obj = SerializeUtils.unserialize(jedis.get(SerializeUtils.serialize(key)));
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return obj;
	}
	
	/**
	 * 获取Object类型的数据2
	 * @param key
	 * @return
	 */
	public Object getObject(Object key) {
		Jedis jedis = null;
		Object obj = null;
		try {
			jedis = jedisPool.getResource();
			obj = SerializeUtils.unserialize(jedis.get(key.toString().getBytes()));
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		}finally{
			if (jedis != null) {
				jedis.close();
			}
		}
		return obj;
	}

	/**
	 * 删除流化后的Object类型的key
	 * 
	 * @param key
	 */
	public void deSerializelObject(Object key) {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			jedis.del(SerializeUtils.serialize(key));
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
	}

	/**
	 * 判断（流化的）Object类型的key是否存在
	 * 
	 * @param key
	 * @return 存在：true ， 不存在：false
	 */
	public Boolean existObjectKey(Object key) {
		Jedis jedis = null;
		Boolean result = false;
		try {
			jedis = jedisPool.getResource();
			result = jedis.exists(SerializeUtils.serialize(key));
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/************************************* Byte ***********************************/

	/**
	 * 存储byte类型(二进制流)的key
	 * 
	 * @param key
	 * @return
	 */
	public void setByte(byte[] key, byte[] value) {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			jedis.set(key, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
	}

	/**
	 * 存储byte类型(二进制流)的key
	 * 
	 * @param key
	 * @param value
	 * @param seconds
	 */
	public void setexByteTime(byte[] key, byte[] value, int seconds) {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			jedis.setex(key, seconds, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
	}

	/**
	 * 获取byte类型(二进制流)的key
	 * 
	 * @param key
	 * @return
	 */
	public byte[] getByte(byte[] key) {
		Jedis jedis = null;
		byte[] bs = null;
		try {
			jedis = jedisPool.getResource();
			bs = jedis.get(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return bs;
	}

	/**
	 * 删除byte类型(二进制流)的key
	 * 
	 * @param key
	 */
	public void delByte(byte[] key) {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			jedis.del(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
	}

	/************************************** List **********************************/

	/**
	 * 插入所有指定的值(表尾)
	 * 
	 * @param key
	 * @param strings
	 *            list元素
	 * @return 列表长度
	 */
	public Long rpush(String key, String... strings) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.rpush(key, strings);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 插入所有指定的值(表头)
	 * 
	 * @param key
	 * @param strings
	 *            list元素
	 * @return 列表长度
	 */
	public Long lpush(String key, String... strings) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.lpush(key, strings);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取列表长度
	 * 
	 * @param key
	 * @return
	 */
	public Long llen(String key) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.llen(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取存储在key列表的特定元素(0：第一位，-1：最后一位)
	 * 
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public List<String> lrange(String key, long start, long end) {
		List<String> list = new ArrayList<String>();
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			list = jedis.lrange(key, start, end);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return list;
	}

	/**
	 * 修剪现有列表，使其包含指定的元素仅在指定的范围内
	 * 
	 * @param key
	 * @param start
	 * @param end
	 * @return 操作成功返回 ok ，否则返回null及错误信息
	 */
	public String ltrim(String key, long start, long end) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.ltrim(key, start, end);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取第n位索引的值
	 * 
	 * @param key
	 * @param index
	 * @return 当索引超出范围返回"null"
	 */
	public String lindex(String key, long index) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.lindex(key, index);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 通过索引来设置元素的值
	 * 
	 * @param key
	 * @param index
	 * @param value
	 * @return 操作成功返回 ok ，否则返回null及错误信息
	 */
	public String lset(String key, long index, String value) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.lset(key, index, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素(移除count绝对值数量的value)
	 * 
	 * @param key
	 * @param count
	 *            移除数量(count > 0：从表头开始搜索，count < 0：从表尾开始搜索)
	 * @param value
	 * @return
	 */
	public Long lrem(String key, long count, String value) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.lrem(key, count, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 删除列表第一个元素返回删除的元素
	 * 
	 * @param key
	 * @return
	 */
	public String lpop(String key) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.lpop(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 删除列表最后一个元素返回删除的元素
	 * 
	 * @param key
	 * @return
	 */
	public String rpop(String key) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.rpop(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 将第一个列表中的第一个元素放入第二个列表头部，并返回该元素
	 * 
	 * @param srckey
	 * @param dstkey
	 * @return
	 */
	public String rpoplpush(String srckey, String dstkey) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.rpoplpush(srckey, dstkey);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/************************************ Hash ************************************/

	/**
	 * 通过key设置哈希中某个域的值(field 存在则覆盖值，不存在则新建)
	 * 
	 * @param key
	 *            哈希的key
	 * @param field
	 *            域名
	 * @param value
	 *            值
	 * @return 1：成功，0：失败，如果操作的不是Hash返回错误信息
	 */
	public Long hset(String key, String field, String value) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.hset(key, field, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 通过key设置哈希中某个域的值(field 存在则不变，不存在则新建)
	 * 
	 * @param key
	 *            哈希的key
	 * @param field
	 *            域名
	 * @param value
	 *            值
	 * @return 1：成功，0：失败，如果操作的不是Hash返回错误信息
	 */
	public Long hsetnx(String key, String field, String value) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.hsetnx(key, field, value);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 存储哈希
	 * 
	 * @param key
	 *            哈希的key
	 * @param map
	 * @param return
	 *            如果操作的不是Hash返回错误信息
	 */
	public String hmset(String key, Map<String, String> map) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.hmset(key, map);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 通过key获取哈希中某个域的数据
	 * 
	 * @param key
	 *            哈希的key
	 * @param field
	 *            域名
	 * @return 如果操作的不是Hash返回错误信息
	 */
	public String hget(String key, String field) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.hget(key, field);

		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 通过key获取哈希中所有数据
	 * 
	 * @param key
	 *            哈希的key
	 * @return 如果操作的不是Hash返回错误信息
	 */
	public Map<String, String> hgetAll(String key) {
		Jedis jedis = null;
		Map<String, String> hgetAll = new LinkedHashMap<String, String>();
		try {
			jedis = jedisPool.getResource();
			hgetAll = jedis.hgetAll(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return hgetAll;
	}

	/**
	 * 对哈希中的某个域的值加n(n可以是负数，n为负数时做减法)
	 * 
	 * @param key
	 *            哈希的key
	 * @param field
	 *            域名
	 * @param value
	 *            值
	 * @return 修改后的值，如果操作的不是Hash或修改的域的值不是数字返回错误信息
	 */
	public Long hincrBy(String key, String field, long value) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = jedisPool.getResource();
			result = jedis.hincrBy(key, field, value);

		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;

	}

	/**
	 * 判断哈希中的域是否存在
	 * 
	 * @param key
	 *            哈希的key
	 * @param field
	 *            域名
	 * @return true为存在，false为不存在，如果操作的不是Hash返回错误信息
	 */
	public Boolean hexists(String key, String field) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.hexists(key, field);

		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 删除哈希中的一个或多个域的值(如果域名不存在则忽略)
	 * 
	 * @param key
	 *            哈希的key
	 * @param fields
	 *            域名
	 * @return 被成功删除字段的数量，如果操作的不是Hash返回错误信息
	 */
	public Long hdel(String key, String... fields) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.hdel(key, fields);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}

		return result;
	}

	/**
	 * 获取哈希表中字段的数量
	 * 
	 * @param key
	 *            哈希的key
	 * @return
	 */
	public Long hlen(String key) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.hlen(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}

		return result;
	}

	/**
	 * 返回散列中的所有字段
	 * 
	 * @param key
	 *            哈希的key
	 * @return
	 */
	public Set<String> hkeys(String key) {
		Set<String> set = new HashSet<String>();
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			set = jedis.hkeys(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return set;
	}

	/**
	 * 返回散列中的所有值
	 * 
	 * @param key
	 *            哈希的key
	 * @return
	 */
	public List<String> hvals(String key) {
		List<String> list = new ArrayList<String>();
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			list = jedis.hvals(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return list;
	}

	/************************************ Set ************************************/

	/**
	 * 存储set集合(存在进行修改存储，不存在则新建)
	 * 
	 * @param key
	 * @param members
	 *            元素
	 * @return 被添加到集合中的新元素的数量,如果操作的不是set返回错误信息
	 */
	public Long sadd(String key, String... members) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.sadd(key, members);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取set集合中的所有的成员
	 * 
	 * @param key
	 * @return
	 */
	public Set<String> sgetAll(String key) {
		Jedis jedis = null;
		Set<String> set = new HashSet<String>();
		try {
			jedis = jedisPool.getResource();
			set = jedis.smembers(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return set;
	}

	/**
	 * 移除集合中的一个或多个成员元素(不存在则忽略)
	 * 
	 * @param key
	 * @param members
	 *            元素
	 * @return 移除的元素数量,如果操作的不是set返回错误信息
	 */
	public Long srem(String key, String... members) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.srem(key, members);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 移除并返回集合中的一个随机元素
	 * 
	 * @param key
	 * @return 返回删除的随机元素,如果操作的不是set返回错误信息
	 */
	public String spop(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.spop(key);

		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 将第一集合的元素移动到第二个集合
	 * 
	 * @param srckey
	 *            第一个集合
	 * @param dstkey
	 *            第二个集合
	 * @param member
	 *            元素
	 * @return 1：成功，0：失败，如果操作的不是set返回错误信息
	 */
	public Long smove(String srckey, String dstkey, String member) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.smove(srckey, dstkey, member);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取集合中元素的数量
	 * 
	 * @param key
	 * @return 如果操作的不是set返回错误信息
	 */
	public Long scard(String key) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.scard(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 判断元素是否是集合的成员
	 * 
	 * @param key
	 * @param member
	 *            元素 元素
	 * @return 是：true ， 否：false
	 */
	public Boolean sismember(String key, String member) {
		Jedis jedis = null;
		Boolean result = false;
		try {
			jedis = jedisPool.getResource();
			result = jedis.sismember(key, member);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取给定所有给定集合的交集(有一个集合为空集，结果也为空集)
	 * 
	 * @param keys
	 * @return 如果操作的不是set返回错误信息
	 */
	public Set<String> sinter(String... keys) {
		Set<String> set = new HashSet<String>();
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			set = jedis.sinter(keys);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return set;
	}

	/**
	 * 将给定集合之间的交集存储在指定的集合中(如果指定的集合已经存在则将其覆盖，如果是空集，原来的集合被删除)
	 * 
	 * @param dstkey
	 *            指定集合
	 * @param keys
	 * @return 指定集合的元素数量，如果操作的不是set返回错误信息
	 */
	public Long sinterstore(String dstkey, String... keys) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.sinterstore(dstkey, keys);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取给定集合的并集
	 * 
	 * @param keys
	 * @return
	 */
	public Set<String> sunion(String... keys) {
		Set<String> set = new HashSet<String>();
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			set = jedis.sunion(keys);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return set;
	}

	/**
	 * 将给定集合之间的并集存储在指定的集合中(如果指定的集合已经存在则将其覆盖，如果是空集，原来的集合被删除)
	 * 
	 * @param dstkey
	 * @param keys
	 * @return 指定集合的元素数量，如果操作的不是set返回错误信息
	 */
	public Long sunionstore(String dstkey, String... keys) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.sunionstore(dstkey, keys);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取给定集合之间的差集
	 * 
	 * @param keys
	 * @return 如果操作的不是set返回错误信息
	 */
	public Set<String> sdiff(String... keys) {
		Set<String> set = new HashSet<String>();
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			set = jedis.sdiff(keys);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return set;
	}

	/**
	 * 将给定集合之间的差集集存储在指定的集合中(如果指定的集合已经存在则将其覆盖，如果是空集，原来的集合被删除)
	 * 
	 * @param dstkey
	 * @param keys
	 * @return 指定集合的元素数量，如果操作的不是set返回错误信息
	 */
	public Long sdiffstore(String dstkey, String... keys) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.sdiffstore(dstkey, keys);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取集合中的一个随机元素(集合不存在返回null)
	 * 
	 * @param key
	 * @return 如果操作的不是set返回错误信息
	 */
	public String srandmember(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.srandmember(key);

		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/************************************* 其他 ***********************************/

	/**
	 * 模糊查询所有类似的key
	 * 
	 * @param key
	 */
	public Set<byte[]> getLikeKeys(byte[] key) {
		Jedis jedis = null;
		Set<byte[]> list = new HashSet<byte[]>();
		try {
			jedis = jedisPool.getResource();
			list = jedis.keys(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return list;
	}

	/**
	 * 获取key的类型
	 * 
	 * @param key
	 * @return
	 */
	public String typeOfString(String key) {
		Jedis jedis = null;
		String type = "";
		try {
			jedis = jedisPool.getResource();
			type = jedis.type(key);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return type;
	}

	/**
	 * 删除所有的key
	 * 
	 * @return ok：成功 ， err：失败
	 */
	public String flushAllKey() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = jedisPool.getResource();
			result = jedis.flushAll();
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

	/**
	 * 获取一个或多个指定键的值
	 * 
	 * @param keys
	 * @return
	 */
	public List<String> mgetKeys(String... keys) {
		Jedis jedis = null;
		List<String> result = new ArrayList<String>();
		try {
			jedis = jedisPool.getResource();
			result = jedis.mget(keys);
		} catch (Exception e) {
			logger.info("redis报错啦：" + e.getMessage());
		} finally {
			if (jedis != null) {
				jedis.close();
			}
		}
		return result;
	}

}