Jedis

一、导入jedis的依赖包，然后导入FastJason的包

连接数据库

操作命令

通过jedis获取连接

 public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        //验证密码，如果没有设置密码这段代码省略
//        jedis.auth("password");

        jedis.connect(); //连接
        jedis.disconnect(); //断开连接

        jedis.flushAll(); //清空所有的key
    }

Key

 public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        System.out.println("清空数据："+jedis.flushDB());
        System.out.println("判断某个键是否存在："+jedis.exists("username"));
        System.out.println("新增<'username','kuangshen'>的键值对："+jedis.set("username", "kuangshen"));
        System.out.println("新增<'password','password'>的键值对："+jedis.set("password", "password"));
        System.out.print("系统中所有的键如下：");
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
        System.out.println("删除键password:"+jedis.del("password"));
        System.out.println("判断键password是否存在："+jedis.exists("password"));
        System.out.println("查看键username所存储的值的类型："+jedis.type("username"));
        System.out.println("随机返回key空间的一个："+jedis.randomKey());
        System.out.println("重命名key："+jedis.rename("username","name"));
        System.out.println("取出改后的name："+jedis.get("name"));
        System.out.println("按索引查询："+jedis.select(0));
        System.out.println("删除当前选择数据库中的所有key："+jedis.flushDB());
        System.out.println("返回当前数据库中key的数目："+jedis.dbSize());
        System.out.println("删除所有数据库中的所有key："+jedis.flushAll());
    }

String

public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        System.out.println("===========增加数据===========");
        System.out.println(jedis.set("key1","value1"));
        System.out.println(jedis.set("key2","value2"));
        System.out.println(jedis.set("key3", "value3"));
        System.out.println("删除键key2:"+jedis.del("key2"));
        System.out.println("获取键key2:"+jedis.get("key2"));
        System.out.println("修改key1:"+jedis.set("key1", "value1Changed"));
        System.out.println("获取key1的值："+jedis.get("key1"));
        System.out.println("在key3后面加入值："+jedis.append("key3", "End"));
        System.out.println("key3的值："+jedis.get("key3"));
        System.out.println("增加多个键值对："+jedis.mset("key01","value01","key02","value02","key03","value03"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03","key04"));
        System.out.println("删除多个键值对："+jedis.del("key01","key02"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));

        jedis.flushDB();
        System.out.println("===========新增键值对防止覆盖原先值==============");
        System.out.println(jedis.setnx("key1", "value1"));
        System.out.println(jedis.setnx("key2", "value2"));
        System.out.println(jedis.setnx("key2", "value2-new"));
        System.out.println(jedis.get("key1"));
        System.out.println(jedis.get("key2"));

        System.out.println("===========新增键值对并设置有效时间=============");
        System.out.println(jedis.setex("key3", 2, "value3"));
        System.out.println(jedis.get("key3"));
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(jedis.get("key3"));

        System.out.println("===========获取原值，更新为新值==========");
        System.out.println(jedis.getSet("key2", "key2GetSet"));
        System.out.println(jedis.get("key2"));

        System.out.println("获得key2的值的字串："+jedis.getrange("key2", 2, 4));
    }

List

public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        System.out.println("===========添加一个list===========");
        jedis.lpush("collections", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashMap");
        jedis.lpush("collections", "HashSet");
        jedis.lpush("collections", "TreeSet");
        jedis.lpush("collections", "TreeMap");
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));//-1代表倒数第一个元素，-2代表倒数第二个元素,end为-1表示查询全部
        System.out.println("collections区间0-3的元素："+jedis.lrange("collections",0,3));
        System.out.println("===============================");
        // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈
        System.out.println("删除指定元素个数："+jedis.lrem("collections", 2, "HashMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("删除下表0-3区间之外的元素："+jedis.ltrim("collections", 0, 3));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（左端）："+jedis.lpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections添加元素，从列表右端，与lpush相对应："+jedis.rpush("collections", "EnumMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（右端）："+jedis.rpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("修改collections指定下标1的内容："+jedis.lset("collections", 1, "LinkedArrayList"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("===============================");
        System.out.println("collections的长度："+jedis.llen("collections"));
        System.out.println("获取collections下标为2的元素："+jedis.lindex("collections", 2));
        System.out.println("===============================");
        jedis.lpush("sortedList", "3","6","2","0","7","4");
        System.out.println("sortedList排序前："+jedis.lrange("sortedList", 0, -1));
        System.out.println(jedis.sort("sortedList"));
        System.out.println("sortedList排序后："+jedis.lrange("sortedList", 0, -1));
    }

Hash

 public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        Map<String,String> map = new HashMap<String,String>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        map.put("key4","value4");
        //添加名称为hash（key）的hash元素
        jedis.hmset("hash",map);
        //向名称为hash的hash中添加key为key5，value为value5元素
        jedis.hset("hash", "key5", "value5");
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));//return Map<String,String>
        System.out.println("散列hash的所有键为："+jedis.hkeys("hash"));//return Set<String>
        System.out.println("散列hash的所有值为："+jedis.hvals("hash"));//return List<String>
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 6));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 3));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("删除一个或者多个键值对："+jedis.hdel("hash", "key2"));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("散列hash中键值对的个数："+jedis.hlen("hash"));
        System.out.println("判断hash中是否存在key2："+jedis.hexists("hash","key2"));
        System.out.println("判断hash中是否存在key3："+jedis.hexists("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3","key4"));
    }

Set

public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        System.out.println("============向集合中添加元素（不重复）============");
        System.out.println(jedis.sadd("eleSet", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除一个元素e0："+jedis.srem("eleSet", "e0"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除两个元素e7和e6："+jedis.srem("eleSet", "e7","e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("eleSet中包含元素的个数："+jedis.scard("eleSet"));
        System.out.println("e3是否在eleSet中："+jedis.sismember("eleSet", "e3"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e1"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e5"));
        System.out.println("=================================");
        System.out.println(jedis.sadd("eleSet1", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet2", "e1","e2","e4","e3","e0","e8"));
        System.out.println("将eleSet1中删除e1并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e1"));//移到集合元素
        System.out.println("将eleSet1中删除e2并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e2"));
        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
        System.out.println("eleSet3中的元素："+jedis.smembers("eleSet3"));
        System.out.println("============集合运算=================");
        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
        System.out.println("eleSet2中的元素："+jedis.smembers("eleSet2"));
        System.out.println("eleSet1和eleSet2的交集:"+jedis.sinter("eleSet1","eleSet2"));
        System.out.println("eleSet1和eleSet2的并集:"+jedis.sunion("eleSet1","eleSet2"));
        System.out.println("eleSet1和eleSet2的差集:"+jedis.sdiff("eleSet1","eleSet2"));//eleSet1中有，eleSet2中没有
        jedis.sinterstore("eleSet4","eleSet1","eleSet2");//求交集并将交集保存到dstkey的集合
        System.out.println("eleSet4中的元素："+jedis.smembers("eleSet4"));
    }

redis事务

public static void main(String[] args) {
        //创建客户端连接服务端，redis服务端需要被开启
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "java");
        //开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        try{
            //向redis存入一条数据
            multi.set("json", result);
            //再存入一条数据
            multi.set("json2", result);
            //这里引发了异常，用0作为被除数
            int i = 100/0;
            //如果没有引发异常，执行进入队列的命令
            multi.exec();
        }catch(Exception e){
            e.printStackTrace();
            //如果出现异常，回滚
            multi.discard();
        }finally{
            System.out.println(jedis.get("json"));
            System.out.println(jedis.get("json2"));
            //最终关闭客户端
            jedis.close();
        }
    }

redis2.x版本之前用jedis调用，之后用lettuce调用

原因：

所有传入redis的值或对象都需要序列化，不然会报错

序列化操作

package com.kuang.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    //自己定义一个redistemplate
  @Bean
  @SuppressWarnings("all")
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
      //为了方便我们z自己开发方便，一般使用<String, Object>
      RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
      //注入工厂
      template.setConnectionFactory(factory);
      //序列化配置，Jason序列化
      Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
      //通过maper进行转义
      ObjectMapper om = new ObjectMapper();
      om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
      om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
      jackson2JsonRedisSerializer.setObjectMapper(om);
      //String的序列化
      StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

      // key采用String的序列化方式
      template.setKeySerializer(stringRedisSerializer);
      // hash的key也采用String的序列化方式
      template.setHashKeySerializer(stringRedisSerializer);
      // value序列化方式采用jackson
      template.setValueSerializer(jackson2JsonRedisSerializer);
      // hash的value序列化方式采用jackson
      template.setHashValueSerializer(jackson2JsonRedisSerializer);
      //将所有的序列化操作注入进去
      template.afterPropertiesSet();

      return template;
  }


}

redis的工具类，redisUtil

package com.tianxing.loan.common.utils;

import java.util.Collections;
import java.util.List;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * redis 单机工具类
 * @author 
 */
public class RedisSingleonUtil {

	private volatile static RedisSingleonUtil singleton;
	private static Logger logger = LoggerFactory.getLogger(RedisSingleonUtil.class);
	
    private JedisPool jedisPool = SpringContextHolder.getBean("jedisPool");
	
	public static RedisSingleonUtil getInstance() {
		if (singleton == null) {
			synchronized (RedisSingleonUtil.class) {
				if (singleton == null) {
					singleton = new RedisSingleonUtil();
				}
			}
		}
		return singleton;
	}
	 
    public Jedis getJedis() {
	   return this.jedisPool.getResource();
    }
	
	/**
	 * 获取数据
	 * 
	 * @param key
	 * @return
	 */
	public String get(String key) {
		Jedis jedis = null;
		String value = null;
		try {
			jedis = getJedis();
			value = jedis.get(key);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return value;
	}

	/**
	 * 获取key的有效期
	 * 
	 * @param key
	 * @return
	 */
	public Long getTTL(String key) {
		Jedis jedis = null;
		Long value = (long) -1;
		try {
			jedis = getJedis();
			value = jedis.ttl(key);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return value;
	}
	
	/**
	 * 
	 * @desc 插入数据
	 * @author 
	 * @date 2017年3月16日 下午2:41:34
	 * @param
	 */
	public void set(String key, String value, int liveTime) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.set(key, value);
			jedis.expire(key, liveTime);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
	}

	/**
	 * 插入数据，并设置固定的过期时间
	 * @param key
	 * @param value
	 * @param unixTime
	 */
	public void set(String key, String value, long unixTime) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.set(key, value);
			jedis.expireAt(key, unixTime);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
	}
	
	/**
	 * 
	 * @desc 插入数据
	 * @author 
	 * @date 2017年3月16日 下午2:41:34
	 * @param
	 */
	public void set(String key, String value) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.set(key, value);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
	}

	public String setString(String key, String value) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			return jedis.set(key, value);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return null;
	}

	public Long lpush(String key, String... values) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			return jedis.lpush(key, values);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return null;
	}
	
	public List<String> lrange(String key, Long start, Long end) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			return jedis.lrange(key, start, end);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return Collections.emptyList();
	}

	public Long sadd(String key, String... values) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.del(key);
			return jedis.sadd(key, values);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return null;
	}
	
	public Long zadd(String key, String... values) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.del(key);
			if(null != values
					&& values.length > 0) {
				int i = 0;
				for(String a : values) {
					jedis.zadd(key, i, a);
					i++;
				}
				return 1L;
			}
			
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return null;
	}
	
	public Set<String> zrange(String key, Long start, Long end) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			return jedis.zrange(key, start, end);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return Collections.emptySet();
	}
	
	public Set<String> zrevrange(String key, Long start, Long end) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			return jedis.zrevrange(key, start, end);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return Collections.emptySet();
	}

	public Set<String> smembers(String key) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			return jedis.smembers(key);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return Collections.emptySet();
	}

	public void del(String key) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.del(key);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
	}

	/**
	 * 
	 * @desc 存入hash数据类型
	 * @author 
	 * @date 2017年5月25日 上午11:13:27
	 * @param
	 */
	public void hset(String key, String field, String value, int liveTime) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.hset(key, field, value);
			jedis.expire(key, liveTime);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
	}

	/**
	 * 
	 * @desc 获取hash数据
	 * @author 
	 * @date 2017年5月25日 上午11:13:59
	 * @param
	 */
	public String hget(String key, String field) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getJedis();
			result = jedis.hget(key, field);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
			e.printStackTrace();
		} finally{
			if(jedis != null)jedis.close();
		}
		return result;
	}

	/**
	 * 
	 * @desc   通过设置key的过期时间为1秒来删除key
	 * @author 
	 * @date   2017年6月15日 上午9:13:02
	 * @param
	 */
	public void delKeyExpire(String key) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.expire(key, 1);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
	}
	/**
	 * 
	 * @desc   通过设置key的过期时间为1秒来删除key(批量)
	 * @author 
	 * @date   2017年6月15日 上午10:14:54
	 * @param
	 */
	public void delKeysExpire(String[] keys) {
		for (String key : keys) {
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.expire(key, 1);
			} catch (Exception e) {
				logger.error(ExceptionUtils.getString(e));
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	}

	/**
	 * 
	 * @desc   删除hashmap对应的key
	 * @author 
	 * @date   2017年6月15日 上午9:13:02
	 * @param
	 */
	public void delHashKey(String key, String hKey) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			jedis.hdel(hKey, hKey);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
	}
	

	/**
	 * value计算加一
	 * @param key
	 */
	public Long incr(String key) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			return jedis.incr(key);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return (long) -1;
	}
	
	/**
	 * value计算减一
	 * @param key
	 */
	public Long decr(String key) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			Long num = jedis.decr(key);
			return num < 0 ? 0 : num;
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return (long) -1;
	}

	/**
	 * value计算加一，设置失效时间
	 * @param key
	 */
	public Long incr(String key, int liveTime) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			Long num = jedis.incr(key);
			if(num == 1){
				jedis.expire(key, liveTime);
			}
			return num;
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return (long) -1;
	}
	
	/**
	 * value计算加一，设置失效时间
	 * @param key
	 * 		键
	 * @param liveTime
	 * 	           秒
	 */
	public Long incrExpireTime(String key, int liveTime) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			Long num = jedis.incr(key);
			if(num ==1)
				jedis.expire(key, liveTime);
			return num;
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return (long) -1;
	}
	
	/**
	 * 设置初始值
	 * @param key
	 * @param unixTime 失效时间
	 * @return 1：设置成功，默认0：已存在，设置失败
	 */
	public int setnx(String key, String value, long unixTime) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			if(jedis.setnx(key , value) == 1){
				jedis.expireAt(key, unixTime);
				return 1;
			}
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return 0;
	}
	
	/**
	 * 计算incr的数量
	 * @param key
	 */
	public Long bitcount(String key) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			return  jedis.bitcount(key);
		} catch (Exception e) {
			logger.error(ExceptionUtils.getString(e));
		} finally{
			if(jedis != null)jedis.close();
		}
		return (long) 0;
	}
}

redis集群工具包

package com.tianxing.loan.common.utils;

import com.tianxing.loan.common.Global;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import redis.clients.jedis.*;

import java.util.*;

/**
 * redis 集群工具类
 * @author 
 */
@Component
public class RedisClusterUtil {

	private volatile static RedisClusterUtil singleton;
	private Logger logger = LoggerFactory.getLogger(RedisClusterUtil.class);
	private static Set<HostAndPort> nodes = null;
	
	private JedisCluster jedisCluster;
    private String isRedisCluster = "0";
	public static RedisClusterUtil getInstance() {
		if (singleton == null) {
			synchronized (RedisClusterUtil.class) {
				if (singleton == null) {
					singleton = new RedisClusterUtil();
				}
			}
		}
		return singleton;
	}
	 
    public Jedis getJedis() {
       JedisPool jedisPool = SpringContextHolder.getBean("jedisPool");
	   return jedisPool.getResource();
    }
    
	private RedisClusterUtil() {
		init();
	}

	private void init() {
		isRedisCluster = Global.getIsRedisCluster();
		//1 redis集群，0 redis非集群
		if("1".equals(isRedisCluster)){
			if(nodes != null){
				jedisCluster = new JedisCluster(nodes); // JedisCluster中默认分装好了连接池.
				return ;
			}
			
			nodes = new HashSet<HostAndPort>();
			String sentinelStr = Global.getSentinels();
			logger.info("=============缓存配置开始================");
			logger.info(sentinelStr);
			logger.info("=============缓存配置结束================");
			String[] sentinelArray = sentinelStr.split(",");
			for (String sentinel : sentinelArray) {
				HostAndPort hostAndPort = new HostAndPort(sentinel.split(":")[0], Integer.parseInt(sentinel.split(":")[1]));
				nodes.add(hostAndPort);
			}
			jedisCluster = new JedisCluster(nodes);// JedisCluster中默认分装好了连接池.
//			jedisCluster.auth("qwer12512");
			// redis内部会创建连接池，从连接池中获取连接使用，然后再把连接返回给连接池
			logger.info("============jedisCluster启动信息==========" + jedisCluster);
		}
	}
	public static void main(String[] args) {
//		Jedis jedis = 
	}

	/**
	 * 获取数据
	 * 
	 * @param key
	 * @return
	 */
	public String get(String key) {
		String value = null;
		if("1".equals(isRedisCluster)){
			try {
				value = jedisCluster.get(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				value = jedis.get(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return value;
	}

	/**
	 * 获取key的有效期
	 * 
	 * @param key
	 * @return
	 */
	public Long getTTL(String key) {
		Long value = (long) -1;
		if("1".equals(isRedisCluster)){
			try {
				value = jedisCluster.ttl(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				value = jedis.ttl(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return value;
	}
	
	/**
	 * 
	 * @desc 插入数据
	 * @author 
	 * @date 2017年3月16日 下午2:41:34
	 * @param
	 */
	public void set(String key, String value, int liveTime) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.set(key, value);
				jedisCluster.expire(key, liveTime);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		} else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.set(key, value);
				jedis.expire(key, liveTime);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	}

	/**
	 * 插入数据，并设置固定的过期时间
	 * @param key
	 * @param value
	 * @param unixTime
	 */
	public void set(String key, String value, long unixTime) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.set(key, value);
				jedisCluster.expireAt(key, unixTime);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.set(key, value);
				jedis.expireAt(key, unixTime);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	}
	
	/**
	 * 
	 * @desc 插入数据
	 * @author 
	 * @date 2017年3月16日 下午2:41:34
	 * @param
	 */
	public void set(String key, String value) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.set(key, value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.set(key, value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	
	}

	public String setString(String key, String value) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.set(key, value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.set(key, value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}

	public Long lpush(String key, String... values) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.lpush(key, values);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.lpush(key, values);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		
		return null;
	}
	
	public List<String> lrange(String key, Long start, Long end) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.lrange(key, start, end);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.lrange(key, start, end);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return Collections.emptyList();
	}

	/**
	 *  后出
	 * @param key
	 * @return
	 */
	public String lpop(String key) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.lpop(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.lpop(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}

	/**
	 *  出队
	 * @param key
	 * @return
	 */
	public String rpop(String key) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.rpop(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.rpop(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}

	public Long rpush(String key,String value) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.rpush(key,value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.rpush(key,value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}

	/**
	 * Redis Lrem 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素
	 * @param key
	 * @param value
	 * @return
	 */
	public Long lrem(String key,String value) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.lrem(key,0,value);//count = 0 : 移除表中所有与 VALUE 相等的值
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.lrem(key,0,value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}


	public Long sadd(String key, String... values) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.del(key);
				return jedisCluster.sadd(key, values);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.del(key);
				return jedis.sadd(key, values);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}
	
	public Long zadd(String key, String... values) {
		if("1".equals(isRedisCluster)){
			try {
				//jedisCluster.del(key);
				if(null != values
						&& values.length > 0) {
					//int i = 0;
					for(String a : values) {
						jedisCluster.zadd(key, 0, a);
						//i++;
					}
					return 1L;
				}
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				//jedis.del(key);
				if(null != values
						&& values.length > 0) {
					//int i = 0;
					for(String a : values) {
						jedis.zadd(key, 0, a);
						//i++;
					}
					return 1L;
				}
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}
	
	public Set<String> zrange(String key, Long start, Long end) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.zrange(key, start, end);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.zrange(key, start, end);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return Collections.emptySet();
	}

	public Long zrem(final String key, String... values){
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.zrem(key, values);
				return 1L;
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.zrem(key,values);
				return 1L;
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}
	
	public Set<String> zrevrange(String key, Long start, Long end) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.zrevrange(key, start, end);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.zrevrange(key, start, end);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return Collections.emptySet();
	}

	public Set<Tuple> zrangeWithScores(String key, Long start, Long end) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.zrangeWithScores(key, start, end);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.zrangeWithScores(key, start, end);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return Collections.emptySet();
	}

	public Double zscore(String key, String member) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.zscore(key, member);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.zscore(key, member);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return 0.0;
	}

	public Object zincrbyLua(List<String> keys,List<String> args,String lua){
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.eval(lua,keys,args);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.eval(lua,keys,args);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return 0;
	}

	public Double zincrby(String key,String member,double increment){
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.zincrby(key,increment,member);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.zincrby(key,increment,member);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return 0.0;
	}

	public Long zrank(String key,String value){
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.zrank(key,value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.zrank(key,value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return 0L;
	}

	public Long zcard(String key){
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.zcard(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.zcard(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return 0L;
	}

	public Set<String> smembers(String key) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.smembers(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.smembers(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return Collections.emptySet();
	}

	public void del(String key) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.del(key);
			} catch (Exception e) {
				logger.error("redis 删除失败，原因：",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.del(key);
			} catch (Exception e) {
				logger.error("redis 删除失败，原因：",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	}

	/**
	 * 
	 * @desc 存入hash数据类型
	 * @author 
	 * @date 2017年5月25日 上午11:13:27
	 * @param
	 */
	public void hset(String key, String field, String value, int liveTime) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.hset(key, field, value);
				jedisCluster.expire(key, liveTime);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.hset(key, field, value);
				jedis.expire(key, liveTime);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	}

	/**
	 *
	 * @desc 存入hash数据类型
	 * @author 
	 * @date 2017年5月25日 上午11:13:27
	 * @param
	 */
	public void hset(String key, String field, String value) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.hset(key, field, value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.hset(key, field, value);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	}

	/**
	 * 
	 * @desc 获取hash数据
	 * @author 
	 * @date 2017年5月25日 上午11:13:59
	 * @param
	 */
	public String hget(String key, String field) {
		String result = null;
		if("1".equals(isRedisCluster)){
			try {
				result = jedisCluster.hget(key, field);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
				e.printStackTrace();
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				result = jedis.hget(key, field);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
				e.printStackTrace();
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return result;
	}

	public Map<String, String> hgetAll(String key) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.hgetAll(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
				e.printStackTrace();
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.hgetAll(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
				e.printStackTrace();
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return null;
	}

	/**
	 * 
	 * @desc   通过设置key的过期时间为1秒来删除key
	 * @author 
	 * @date   2017年6月15日 上午9:13:02
	 * @param
	 */
	public void delKeyExpire(String key) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.expire(key, 1);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.expire(key, 1);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	}
	/**
	 * 
	 * @desc   通过设置key的过期时间为1秒来删除key(批量)
	 * @author 
	 * @date   2017年6月15日 上午10:14:54
	 * @param
	 */
	public void delKeysExpire(String[] keys) {
		if("1".equals(isRedisCluster)){
			for (String key : keys) {
				try {
					jedisCluster.expire(key, 1);
				} catch (Exception e) {
					logger.error("redis操作失败，原因:",e);
				}
			}
		}else{
			for (String key : keys) {
				Jedis jedis = null;
				try {
					jedis = getJedis();
					jedis.expire(key, 1);
				} catch (Exception e) {
					logger.error("redis操作失败，原因:",e);
				} finally{
					if(jedis != null)jedis.close();
				}
			}
		}
	}

	/**
	 * 
	 * @desc   删除hashmap对应的key
	 * @author 
	 * @date   2017年6月15日 上午9:13:02
	 * @param
	 */
	public void delHashKey(String key, String hKey) {
		if("1".equals(isRedisCluster)){
			try {
				jedisCluster.hdel(key, hKey);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				jedis.hdel(key, hKey);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
	}

	public Object eval(String lua, List<String> keys, List<String> args) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.eval(lua,keys,args);
			} catch (Exception e) {
				logger.error("redis eval，执行错误，原因：",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.eval(lua,keys,args);
			} catch (Exception e) {
				logger.error("redis eval，执行错误，原因：",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return 0;
	}

	/**
	 * value计算加一
	 * @param key
	 */
	public Long incr(String key) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.incr(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return jedis.incr(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return (long) -1;
	}
	
	/**
	 * value计算减一
	 * @param key
	 */
	public Long decr(String key) {
		if("1".equals(isRedisCluster)){
			try {
				Long num = jedisCluster.decr(key);
				return num < 0 ? 0 : num;
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				Long num = jedis.decr(key);
				return num < 0 ? 0 : num;
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return (long) -1;
	}

	/**
	 * value计算加一，设置失效时间
	 * @param key
	 */
	public Long incr(String key, int liveTime) {
		if("1".equals(isRedisCluster)){
			try {
				Long num = jedisCluster.incr(key);
				if(num == 1){
					jedisCluster.expire(key, liveTime);
				}
				return num;
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			}
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				Long num = jedis.incr(key);
				if(num == 1){
					jedis.expire(key, liveTime);
				}
				return num;
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return (long) -1;
	}
	
	/**
	 * 设置初始值
	 * @param key
	 * @param unixTime 失效时间
	 * @return 1：设置成功，默认0：已存在，设置失败
	 */
	public int setnx(String key, String value, long unixTime) {
		if("1".equals(isRedisCluster)){
			try {
				if(jedisCluster.setnx(key , value) == 1){
					jedisCluster.expireAt(key, unixTime);
					return 1;
				}
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} 
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				if(jedis.setnx(key , value) == 1){
					jedis.expireAt(key, unixTime);
					return 1;
				}
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return 0;
	}
	
	/**
	 * 计算incr的数量
	 * @param key
	 */
	public Long bitcount(String key) {
		if("1".equals(isRedisCluster)){
			try {
				return jedisCluster.bitcount(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} 
		}else{
			Jedis jedis = null;
			try {
				jedis = getJedis();
				return  jedis.bitcount(key);
			} catch (Exception e) {
				logger.error("redis操作失败，原因:",e);
			} finally{
				if(jedis != null)jedis.close();
			}
		}
		return (long) 0;
	}
}