使用jedis连接单机和集群redis的两种方式

2017-04-22 14:46

https://my.oschina.net/u/2263956/blog/799016

  

摘要:  Redis服务器的部署方式可分为单机和集群的方式,使用Jedis的对应访问接口也相应不用。如何使用Jedis操作两种不同部署方式的Redis数据,以及在web工程里如何快速的切换两种不同的访问方式,是本文要介绍的主要内容。

       Redis服务器的部署方式可分为单机和集群的方式,使用Jedis的对应访问接口也相应不用。如何使用Jedis操作两种不同部署方式的Redis数据,以及在web工程里如何快速的切换两种不同的访问方式,是本文要介绍的主要内容。

        本示例使用的相关框架版本如下:

         Jedis:jedis-2.8.1

         spring:spring 4.0.8

涉及的主要类图如下:

 

 

 

 

 

 

 

 

 

 

 

 

 

 

       JedisClient与JedisClsterClient都实现了IJedisClinet接口,接口里定义了操作redis的各种方法,这两个Client实现类分别对应着单机和集群两种访问方式。RedisOperate类是供其它类调用的Redis操作类,它持有IJedisClient接口的实现类对象,这个对象由spring注入,具体使用哪种连接方式取决于注入的IJedisClient的实现类类型。这里使用的是策略模式。

       JedisClusterFactory实现了org.springframework.beans.factory.FactoryBean和org.springframework.beans.factory.InitializingBean接口,用于为JedisClusterClient提供redis.clients.jedis.JedisCluster操作类。JedisClient的操作类是redis.clients.jedis.Jedis,从redis.clients.jedis.JedisPool类中获取。

Spring的配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"
 default-lazy-init="true">

 <description>Jedis Configuration</description>

 <!-- 加载配置属性文件 -->
 <context:property-placeholder ignore-unresolvable="true" location="classpath:jeeplus.properties" />
 <!-- redis 单机连接方案 -->
 <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
 <property name="maxIdle" value="300" /> <!-- 最大能够保持idel状态的对象数 -->
 <property name="maxTotal" value="60000" /> <!-- 最大分配的对象数 -->
 <property name="testOnBorrow" value="true" /> <!-- 当调用borrow Object方法时,是否进行有效性检查 -->
 </bean>

 <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
 <constructor-arg index="0" ref="jedisPoolConfig" />
 <constructor-arg index="1" value="${redis.host}" />
 <constructor-arg index="2" value="${redis.port}" type="int" />
 </bean>
 <!-- redis 集群连接方案 -->
 <bean name="genericObjectPoolConfig" class="org.apache.commons.pool2.impl.GenericObjectPoolConfig">
 <property name="maxWaitMillis" value="-1" />
 <property name="maxTotal" value="8" />
 <property name="minIdle" value="0" />
 <property name="maxIdle" value="8" />
 </bean>
 <bean id="jedisCluster" class="com.jeeplus.common.redis.JedisClusterFactory">
 <property name="connectionTimeout" value="3000" />
 <property name="soTimeout" value="3000" />
 <property name="maxRedirections" value="5" />
 <property name="genericObjectPoolConfig" ref="genericObjectPoolConfig" />
 <property name="jedisClusterNodes">
 <set>
 <value>127.0.0.1:7000</value>
 <value>127.0.0.1:7001</value>
 <value>127.0.0.1:7002</value>
 </set>
 </property>
 </bean>
 <!-- 真正的redis操作类,具体连接方式由jedisClient的ref属性决定
 可选项为jedisClusterClient、jedisClient
 -->
 <bean name="redisOperate" class="com.jeeplus.common.redis.RedisOperate">
 <property name="jedisClient" ref="jedisClusterClient" />
 </bean>
</beans>

在进行单机、集群切换时,只需要修改<property name="jedisClient" ref="jedisClusterClient" />  配置即可。

 

下面看看代码:

 IJedisClient

public interface IJedisClient {

	/**
 * 获取缓存
 * @param key 键
 * @return 值
 */

	public String get(String key);

	/**
 * 获取缓存
 * @param key 键
 * @return 值
 */
	public Object getObject(String key);

	/**
 * 设置缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public String set(String key, String value, int cacheSeconds);

	/**
 * 设置缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public String setObject(String key, Object value, int cacheSeconds);

	/**
 * 获取List缓存
 * @param key 键
 * @return 值
 */
	public List<String> getList(String key);

	/**
 * 获取List缓存
 * @param key 键
 * @return 值
 */
	public List<Object> getObjectList(String key);

	/**
 * 设置List缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public long setList(String key, List<String> value, int cacheSeconds);

	/**
 * 设置List缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public long setObjectList(String key, List<Object> value, int cacheSeconds);

	/**
 * 向List缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public long listAdd(String key, String... value);

	/**
 * 向List缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public long listObjectAdd(String key, Object... value);

	/**
 * 获取缓存
 * @param key 键
 * @return 值
 */
	public Set<String> getSet(String key);

	/**
 * 获取缓存
 * @param key 键
 * @return 值
 */
	public Set<Object> getObjectSet(String key);

	/**
 * 设置Set缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public long setSet(String key, Set<String> value, int cacheSeconds);

	/**
 * 设置Set缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public long setObjectSet(String key, Set<Object> value, int cacheSeconds);

	/**
 * 向Set缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public long setSetAdd(String key, String... value);

	/**
 * 向Set缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public long setSetObjectAdd(String key, Object... value);

	/**
 * 获取Map缓存
 * @param key 键
 * @return 值
 */
	public Map<String, String> getMap(String key);

	/**
 * 获取Map缓存
 * @param key 键
 * @return 值
 */
	public Map<String, Object> getObjectMap(String key);

	/**
 * 设置Map缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public String setMap(String key, Map<String, String> value, int cacheSeconds);

	/**
 * 设置Map缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public String setObjectMap(String key, Map<String, Object> value,
 int cacheSeconds);

	/**
 * 向Map缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public String mapPut(String key, Map<String, String> value);

	/**
 * 向Map缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public String mapObjectPut(String key, Map<String, Object> value);

	/**
 * 移除Map缓存中的值
 * @param key 键
 * @param value 值
 * @return
 */
	public long mapRemove(String key, String mapKey);

	/**
 * 移除Map缓存中的值
 * @param key 键
 * @param value 值
 * @return
 */
	public long mapObjectRemove(String key, String mapKey);

	/**
 * 判断Map缓存中的Key是否存在
 * @param key 键
 * @param value 值
 * @return
 */
	public boolean mapExists(String key, String mapKey);

	/**
 * 判断Map缓存中的Key是否存在
 * @param key 键
 * @param value 值
 * @return
 */
	public boolean mapObjectExists(String key, String mapKey);

	/**
 * 删除缓存
 * @param key 键
 * @return
 */
	public long del(String key);

	/**
 * 删除缓存
 * @param key 键
 * @return
 */
	public long delObject(String key);

	/**
 * 缓存是否存在
 * @param key 键
 * @return
 */
	public boolean exists(String key);

	/**
 * 缓存是否存在
 * @param key 键
 * @return
 */
	public boolean existsObject(String key);

}

JedisClient

/**
 * 单机方式redis连接客户端
 * @author jimmywu
 *
 */
@Service
public class JedisClient implements IJedisClient {

	private static Logger logger = LoggerFactory.getLogger(JedisClient.class);
	
	private  JedisPool jedisPool = SpringContextHolder.getBean(JedisPool.class);

	public static final String KEY_PREFIX = Global.getConfig("redis.keyPrefix");
	
	/**
 * 获取缓存
 * @param key 键
 * @return 值
 */
	
	public String get(String key) {
		String value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				value = jedis.get(key);
				value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
				logger.debug("get {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("get {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	/**
 * 获取缓存
 * @param key 键
 * @return 值
 */
	public Object getObject(String key) {
		Object value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				value = toObject(jedis.get(getBytesKey(key)));
				logger.debug("getObject {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObject {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	/**
 * 设置缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public String set(String key, String value, int cacheSeconds) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.set(key, value);
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("set {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("set {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 设置缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public String setObject(String key, Object value, int cacheSeconds) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.set(getBytesKey(key), toBytes(value));
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setObject {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObject {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 获取List缓存
 * @param key 键
 * @return 值
 */
	public List<String> getList(String key) {
		List<String> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				value = jedis.lrange(key, 0, -1);
				logger.debug("getList {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getList {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	/**
 * 获取List缓存
 * @param key 键
 * @return 值
 */
	public List<Object> getObjectList(String key) {
		List<Object> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				List<byte[]> list = jedis.lrange(getBytesKey(key), 0, -1);
				value = Lists.newArrayList();
				for (byte[] bs : list){
					value.add(toObject(bs));
				}
				logger.debug("getObjectList {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectList {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	/**
 * 设置List缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public long setList(String key, List<String> value, int cacheSeconds) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				jedis.del(key);
			}
			result = jedis.rpush(key, (String[])value.toArray());
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setList {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setList {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 设置List缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public long setObjectList(String key, List<Object> value, int cacheSeconds) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				jedis.del(key);
			}
			List<byte[]> list = Lists.newArrayList();
			for (Object o : value){
				list.add(toBytes(o));
			}
			result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setObjectList {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectList {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 向List缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public long listAdd(String key, String... value) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.rpush(key, value);
			logger.debug("listAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("listAdd {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 向List缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public long listObjectAdd(String key, Object... value) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			List<byte[]> list = Lists.newArrayList();
			for (Object o : value){
				list.add(toBytes(o));
			}
			result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
			logger.debug("listObjectAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("listObjectAdd {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	/**
 * 获取缓存
 * @param key 键
 * @return 值
 */
	public Set<String> getSet(String key) {
		Set<String> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				value = jedis.smembers(key);
				logger.debug("getSet {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getSet {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	/**
 * 获取缓存
 * @param key 键
 * @return 值
 */
	public Set<Object> getObjectSet(String key) {
		Set<Object> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				value = Sets.newHashSet();
				Set<byte[]> set = jedis.smembers(getBytesKey(key));
				for (byte[] bs : set){
					value.add(toObject(bs));
				}
				logger.debug("getObjectSet {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectSet {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	/**
 * 设置Set缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public long setSet(String key, Set<String> value, int cacheSeconds) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				jedis.del(key);
			}
			result = jedis.sadd(key, (String[])value.toArray());
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setSet {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSet {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 设置Set缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				jedis.del(key);
			}
			Set<byte[]> set = Sets.newHashSet();
			for (Object o : value){
				set.add(toBytes(o));
			}
			result = jedis.sadd(getBytesKey(key), (byte[][])set.toArray());
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setObjectSet {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectSet {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 向Set缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public long setSetAdd(String key, String... value) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.sadd(key, value);
			logger.debug("setSetAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSetAdd {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	/**
 * 向Set缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public long setSetObjectAdd(String key, Object... value) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			Set<byte[]> set = Sets.newHashSet();
			for (Object o : value){
				set.add(toBytes(o));
			}
			result = jedis.rpush(getBytesKey(key), (byte[][])set.toArray());
			logger.debug("setSetObjectAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSetObjectAdd {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 获取Map缓存
 * @param key 键
 * @return 值
 */
	public Map<String, String> getMap(String key) {
		Map<String, String> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				value = jedis.hgetAll(key);
				logger.debug("getMap {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getMap {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	/**
 * 获取Map缓存
 * @param key 键
 * @return 值
 */
	public Map<String, Object> getObjectMap(String key) {
		Map<String, Object> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				value = Maps.newHashMap();
				Map<byte[], byte[]> map = jedis.hgetAll(getBytesKey(key));
				for (Map.Entry<byte[], byte[]> e : map.entrySet()){
					value.put(StringUtils.toString(e.getKey()), toObject(e.getValue()));
				}
				logger.debug("getObjectMap {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectMap {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	/**
 * 设置Map缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public String setMap(String key, Map<String, String> value, int cacheSeconds) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				jedis.del(key);
			}
			result = jedis.hmset(key, value);
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setMap {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setMap {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 设置Map缓存
 * @param key 键
 * @param value 值
 * @param cacheSeconds 超时时间,0为不超时
 * @return
 */
	public String setObjectMap(String key, Map<String, Object> value, int cacheSeconds) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				jedis.del(key);
			}
			Map<byte[], byte[]> map = Maps.newHashMap();
			for (Map.Entry<String, Object> e : value.entrySet()){
				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
			}
			result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setObjectMap {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectMap {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 向Map缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public String mapPut(String key, Map<String, String> value) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hmset(key, value);
			logger.debug("mapPut {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("mapPut {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 向Map缓存中添加值
 * @param key 键
 * @param value 值
 * @return
 */
	public String mapObjectPut(String key, Map<String, Object> value) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			Map<byte[], byte[]> map = Maps.newHashMap();
			for (Map.Entry<String, Object> e : value.entrySet()){
				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
			}
			result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
			logger.debug("mapObjectPut {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("mapObjectPut {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 移除Map缓存中的值
 * @param key 键
 * @param value 值
 * @return
 */
	public long mapRemove(String key, String mapKey) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hdel(key, mapKey);
			logger.debug("mapRemove {} {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapRemove {} {}", key, mapKey, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 移除Map缓存中的值
 * @param key 键
 * @param value 值
 * @return
 */
	public long mapObjectRemove(String key, String mapKey) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hdel(getBytesKey(key), getBytesKey(mapKey));
			logger.debug("mapObjectRemove {} {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapObjectRemove {} {}", key, mapKey, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 判断Map缓存中的Key是否存在
 * @param key 键
 * @param value 值
 * @return
 */
	public boolean mapExists(String key, String mapKey) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hexists(key, mapKey);
			logger.debug("mapExists {} {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapExists {} {}", key, mapKey, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 判断Map缓存中的Key是否存在
 * @param key 键
 * @param value 值
 * @return
 */
	public boolean mapObjectExists(String key, String mapKey) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hexists(getBytesKey(key), getBytesKey(mapKey));
			logger.debug("mapObjectExists {} {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapObjectExists {} {}", key, mapKey, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 删除缓存
 * @param key 键
 * @return
 */
	public long del(String key) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)){
				result = jedis.del(key);
				logger.debug("del {}", key);
			}else{
				logger.debug("del {} not exists", key);
			}
		} catch (Exception e) {
			logger.warn("del {}", key, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	/**
 * 删除缓存
 * @param key 键
 * @return
 */
	public long delObject(String key) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))){
				result = jedis.del(getBytesKey(key));
				logger.debug("delObject {}", key);
			}else{
				logger.debug("delObject {} not exists", key);
			}
		} catch (Exception e) {
			logger.warn("delObject {}", key, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 缓存是否存在
 * @param key 键
 * @return
 */
	public boolean exists(String key) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.exists(key);
			logger.debug("exists {}", key);
		} catch (Exception e) {
			logger.warn("exists {}", key, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}
	
	/**
 * 缓存是否存在
 * @param key 键
 * @return
 */
	public boolean existsObject(String key) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.exists(getBytesKey(key));
			logger.debug("existsObject {}", key);
		} catch (Exception e) {
			logger.warn("existsObject {}", key, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	/**
 * 获取资源
 * @return
 * @throws JedisException
 */
	public Jedis getResource() throws JedisException {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
// logger.debug("getResource.", jedis);
		} catch (JedisException e) {
			logger.warn("getResource.", e);
			returnBrokenResource(jedis);
			throw e;
		}
		return jedis;
	}

	/**
 * 归还资源
 * @param jedis
 * @param isBroken
 */
	public void returnBrokenResource(Jedis jedis) {
		if (jedis != null) {
			jedisPool.returnBrokenResource(jedis);
		}
	}
	
	/**
 * 释放资源
 * @param jedis
 * @param isBroken
 */
	public void returnResource(Jedis jedis) {
		if (jedis != null) {
			jedisPool.returnResource(jedis);
		}
	}

	/**
 * 获取byte[]类型Key
 * @param key
 * @return
 */
	public static byte[] getBytesKey(Object object){
		if(object instanceof String){
    		return StringUtils.getBytes((String)object);
    	}else{
    		return ObjectUtils.serialize(object);
    	}
	}
	
	/**
 * Object转换byte[]类型
 * @param key
 * @return
 */
	public static byte[] toBytes(Object object){
    	return ObjectUtils.serialize(object);
	}

	/**
 * byte[]型转换Object
 * @param key
 * @return
 */
	public static Object toObject(byte[] bytes){
		return ObjectUtils.unserialize(bytes);
	}

}

JedisClusterClient

/**
 * 集群方式redis客户端操作
 * @author jimmywu
 *
 */
@Service
public class JedisClusterClient implements IJedisClient {

	private   Logger logger = LoggerFactory.getLogger(JedisClusterClient.class);
	

	@Autowired
	private  JedisCluster jedisCluster ;
// public final String KEY_PREFIX = Global.getConfig("redis.keyPrefix");
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#get(java.lang.String)
 */
	
	@Override
 public String get(String key) {
		String value = null;
		try {
			if (jedisCluster.exists(key)) {
				value = jedisCluster.get(key);
				value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
				logger.debug("get {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("get {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#getObject(java.lang.String)
 */
	@Override
 public Object getObject(String key) {
		Object value = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				value = toObject(jedisCluster.get(getBytesKey(key)));
				logger.debug("getObject {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObject {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
// try {
// jedisCluster.close();
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
		}
		return value;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#set(java.lang.String, java.lang.String, int)
 */
	@Override
 public String set(String key, String value, int cacheSeconds) {
		String result = null;
	
		try {
		
			result = jedisCluster.set(key, value);
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("set {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("set {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setObject(java.lang.String, java.lang.Object, int)
 */
	@Override
 public String setObject(String key, Object value, int cacheSeconds) {
		String result = null;
		
		try {
			result = jedisCluster.set(getBytesKey(key), toBytes(value));
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setObject {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObject {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#getList(java.lang.String)
 */
	@Override
 public List<String> getList(String key) {
		List<String> value = null;
		try {
			if (jedisCluster.exists(key)) {
				value = jedisCluster.lrange(key, 0, -1);
				logger.debug("getList {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getList {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#getObjectList(java.lang.String)
 */
	@Override
 public List<Object> getObjectList(String key) {
		List<Object> value = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				List<byte[]> list = jedisCluster.lrange(getBytesKey(key), 0, -1);
				value = Lists.newArrayList();
				for (byte[] bs : list){
					value.add(toObject(bs));
				}
				logger.debug("getObjectList {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectList {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setList(java.lang.String, java.util.List, int)
 */
	@Override
 public long setList(String key, List<String> value, int cacheSeconds) {
		long result = 0;
		try {
			if (jedisCluster.exists(key)) {
				jedisCluster.del(key);
			}
			result = jedisCluster.rpush(key, (String[])value.toArray());
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setList {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setList {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setObjectList(java.lang.String, java.util.List, int)
 */
	@Override
 public long setObjectList(String key, List<Object> value, int cacheSeconds) {
		long result = 0;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				jedisCluster.del(key);
			}
			List<byte[]> list = Lists.newArrayList();
			for (Object o : value){
				list.add(toBytes(o));
			}
			result = jedisCluster.rpush(getBytesKey(key), (byte[][])list.toArray());
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setObjectList {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectList {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#listAdd(java.lang.String, java.lang.String)
 */
	@Override
 public long listAdd(String key, String... value) {
		long result = 0;
		try {
			result = jedisCluster.rpush(key, value);
			logger.debug("listAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("listAdd {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#listObjectAdd(java.lang.String, java.lang.Object)
 */
	@Override
 public long listObjectAdd(String key, Object... value) {
		long result = 0;
		try {
			List<byte[]> list = Lists.newArrayList();
			for (Object o : value){
				list.add(toBytes(o));
			}
			result = jedisCluster.rpush(getBytesKey(key), (byte[][])list.toArray());
			logger.debug("listObjectAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("listObjectAdd {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}

	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#getSet(java.lang.String)
 */
	@Override
 public Set<String> getSet(String key) {
		Set<String> value = null;
		try {
			if (jedisCluster.exists(key)) {
				value = jedisCluster.smembers(key);
				logger.debug("getSet {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getSet {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#getObjectSet(java.lang.String)
 */
	@Override
 public Set<Object> getObjectSet(String key) {
		Set<Object> value = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				value = Sets.newHashSet();
				Set<byte[]> set = jedisCluster.smembers(getBytesKey(key));
				for (byte[] bs : set){
					value.add(toObject(bs));
				}
				logger.debug("getObjectSet {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectSet {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setSet(java.lang.String, java.util.Set, int)
 */
	@Override
 public long setSet(String key, Set<String> value, int cacheSeconds) {
		long result = 0;
		try {
			if (jedisCluster.exists(key)) {
				jedisCluster.del(key);
			}
			result = jedisCluster.sadd(key, (String[])value.toArray());
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setSet {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSet {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setObjectSet(java.lang.String, java.util.Set, int)
 */
	@Override
 public long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
		long result = 0;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				jedisCluster.del(key);
			}
			Set<byte[]> set = Sets.newHashSet();
			for (Object o : value){
				set.add(toBytes(o));
			}
			result = jedisCluster.sadd(getBytesKey(key), (byte[][])set.toArray());
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setObjectSet {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectSet {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setSetAdd(java.lang.String, java.lang.String)
 */
	@Override
 public long setSetAdd(String key, String... value) {
		long result = 0;
		try {
			result = jedisCluster.sadd(key, value);
			logger.debug("setSetAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSetAdd {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}

	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setSetObjectAdd(java.lang.String, java.lang.Object)
 */
	@Override
 public long setSetObjectAdd(String key, Object... value) {
		long result = 0;
		try {
			Set<byte[]> set = Sets.newHashSet();
			for (Object o : value){
				set.add(toBytes(o));
			}
			result = jedisCluster.rpush(getBytesKey(key), (byte[][])set.toArray());
			logger.debug("setSetObjectAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSetObjectAdd {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#getMap(java.lang.String)
 */
	@Override
	public Map<String, String> getMap(String key) {
		Map<String, String> value = null;
		try {
			if (jedisCluster.exists(key)) {
				value = jedisCluster.hgetAll(key);
				logger.debug("getMap {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getMap {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#getObjectMap(java.lang.String)
 */
	@Override
	public Map<String, Object> getObjectMap(String key) {
		Map<String, Object> value = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				value = Maps.newHashMap();
				Map<byte[], byte[]> map = jedisCluster.hgetAll(getBytesKey(key));
				for (Map.Entry<byte[], byte[]> e : map.entrySet()){
					value.put(StringUtils.toString(e.getKey()), toObject(e.getValue()));
				}
				logger.debug("getObjectMap {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectMap {} = {}", key, value, e);
		} finally {
		}
		return value;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setMap(java.lang.String, java.util.Map, int)
 */
	@Override
 public String setMap(String key, Map<String, String> value, int cacheSeconds) {
		String result = null;
		try {
			if (jedisCluster.exists(key)) {
				jedisCluster.del(key);
			}
			result = jedisCluster.hmset(key, value);
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setMap {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setMap {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#setObjectMap(java.lang.String, java.util.Map, int)
 */
	@Override
 public String setObjectMap(String key, Map<String, Object> value, int cacheSeconds) {
		String result = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				jedisCluster.del(key);
			}
			Map<byte[], byte[]> map = Maps.newHashMap();
			for (Map.Entry<String, Object> e : value.entrySet()){
				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
			}
			result = jedisCluster.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setObjectMap {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectMap {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#mapPut(java.lang.String, java.util.Map)
 */
	@Override
 public String mapPut(String key, Map<String, String> value) {
		String result = null;
		try {
			result = jedisCluster.hmset(key, value);
			logger.debug("mapPut {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("mapPut {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#mapObjectPut(java.lang.String, java.util.Map)
 */
	@Override
 public String mapObjectPut(String key, Map<String, Object> value) {
		String result = null;
		try {
			Map<byte[], byte[]> map = Maps.newHashMap();
			for (Map.Entry<String, Object> e : value.entrySet()){
				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
			}
			result = jedisCluster.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
			logger.debug("mapObjectPut {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("mapObjectPut {} = {}", key, value, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#mapRemove(java.lang.String, java.lang.String)
 */
	@Override
 public long mapRemove(String key, String mapKey) {
		long result = 0;
		try {
			result = jedisCluster.hdel(key, mapKey);
			logger.debug("mapRemove {} {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapRemove {} {}", key, mapKey, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#mapObjectRemove(java.lang.String, java.lang.String)
 */
	@Override
 public long mapObjectRemove(String key, String mapKey) {
		long result = 0;
		try {
			result = jedisCluster.hdel(getBytesKey(key), getBytesKey(mapKey));
			logger.debug("mapObjectRemove {} {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapObjectRemove {} {}", key, mapKey, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#mapExists(java.lang.String, java.lang.String)
 */
	@Override
 public boolean mapExists(String key, String mapKey) {
		boolean result = false;
		try {
			result = jedisCluster.hexists(key, mapKey);
			logger.debug("mapExists {} {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapExists {} {}", key, mapKey, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#mapObjectExists(java.lang.String, java.lang.String)
 */
	@Override
 public boolean mapObjectExists(String key, String mapKey) {
		boolean result = false;
		try {
			result = jedisCluster.hexists(getBytesKey(key), getBytesKey(mapKey));
			logger.debug("mapObjectExists {} {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapObjectExists {} {}", key, mapKey, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#del(java.lang.String)
 */
	@Override
 public long del(String key) {
		long result = 0;
		try {
			if (jedisCluster.exists(key)){
				result = jedisCluster.del(key);
				logger.debug("del {}", key);
			}else{
				logger.debug("del {} not exists", key);
			}
		} catch (Exception e) {
			logger.warn("del {}", key, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}

	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#delObject(java.lang.String)
 */
	@Override
 public long delObject(String key) {
		long result = 0;
		try {
			if (jedisCluster.exists(getBytesKey(key))){
				result = jedisCluster.del(getBytesKey(key));
				logger.debug("delObject {}", key);
			}else{
				logger.debug("delObject {} not exists", key);
			}
		} catch (Exception e) {
			logger.warn("delObject {}", key, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#exists(java.lang.String)
 */
	@Override
 public boolean exists(String key) {
		boolean result = false;
		try {
			result = jedisCluster.exists(key);
			logger.debug("exists {}", key);
		} catch (Exception e) {
			logger.warn("exists {}", key, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
 * @see com.jeeplus.common.redis.IJedisClient#existsObject(java.lang.String)
 */
	@Override
 public boolean existsObject(String key) {
		boolean result = false;
		try {
			result = jedisCluster.exists(getBytesKey(key));
			logger.debug("existsObject {}", key);
		} catch (Exception e) {
			logger.warn("existsObject {}", key, e);
		} finally {
// returnResource(jedis);
		}
		return result;
	}

	
	/**
 * 获取byte[]类型Key
 * @param key
 * @return
 */
	public static byte[] getBytesKey(Object object){
		if(object instanceof String){
    		return StringUtils.getBytes((String)object);
    	}else{
    		return ObjectUtils.serialize(object);
    	}
	}
	
	/**
 * Object转换byte[]类型
 * @param key
 * @return
 */
	public static byte[] toBytes(Object object){
    	return ObjectUtils.serialize(object);
	}

	/**
 * byte[]型转换Object
 * @param key
 * @return
 */
	public static Object toObject(byte[] bytes){
		return ObjectUtils.unserialize(bytes);
	}

}

JedisClusterFactory 

/**
 *
 * @author jimmywu
 *
 */
public class JedisClusterFactory implements FactoryBean<JedisCluster>,
 InitializingBean {
	//连接池参数 spring 注入
	private GenericObjectPoolConfig genericObjectPoolConfig;
	//
	private JedisCluster jedisCluster;
	private int connectionTimeout = 2000;
	private int soTimeout = 3000;
	private int maxRedirections = 5;
	//redis结点列表 spring注入
	private Set<String> jedisClusterNodes;

	@Override
	public void afterPropertiesSet() throws Exception {
		   //判断地址是否为空
          if(jedisClusterNodes == null || jedisClusterNodes.size() == 0){
        	  throw new NullPointerException("jedisClusterNodes is null.");
          }
          //构造结点
          Set<HostAndPort> haps = new HashSet<HostAndPort>();
          for(String node:jedisClusterNodes){
        	  String[] arr = node.split(":");
        	  if(arr.length != 2){
        		  throw new ParseException("node address error!", node.length()-1);
        	  }
        	  haps.add(new HostAndPort(arr[0],Integer.valueOf(arr[1])));
          }
          
          jedisCluster = new JedisCluster(haps, connectionTimeout, soTimeout, maxRedirections, genericObjectPoolConfig);
	}

	@Override
	public JedisCluster getObject() throws Exception {
		return jedisCluster;
	}

	@Override
	public Class<?> getObjectType() {
		return (this.jedisCluster != null ? this.jedisCluster.getClass()
				: JedisCluster.class);
	}

	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return true;
	}

	public GenericObjectPoolConfig getGenericObjectPoolConfig() {
		return genericObjectPoolConfig;
	}

	public void setGenericObjectPoolConfig(
 GenericObjectPoolConfig genericObjectPoolConfig) {
		this.genericObjectPoolConfig = genericObjectPoolConfig;
	}

	public JedisCluster getJedisCluster() {
		return jedisCluster;
	}

	public void setJedisCluster(JedisCluster jedisCluster) {
		this.jedisCluster = jedisCluster;
	}

	public int getConnectionTimeout() {
		return connectionTimeout;
	}

	public void setConnectionTimeout(int connectionTimeout) {
		this.connectionTimeout = connectionTimeout;
	}

	public int getSoTimeout() {
		return soTimeout;
	}

	public void setSoTimeout(int soTimeout) {
		this.soTimeout = soTimeout;
	}

	public int getMaxRedirections() {
		return maxRedirections;
	}

	public void setMaxRedirections(int maxRedirections) {
		this.maxRedirections = maxRedirections;
	}

	public Set<String> getJedisClusterNodes() {
		return jedisClusterNodes;
	}

	public void setJedisClusterNodes(Set<String> jedisClusterNodes) {
		this.jedisClusterNodes = jedisClusterNodes;
	}

}

RedisOperate

/**
 * 操作redis时真正使用的类
 * 具体连接方式由spring注入的客户端类型决定
 * @author jimmywu
 *
 */
public class RedisOperate implements IJedisClient {
	IJedisClient jedisClient;
	public IJedisClient getJedisClient() {
		return jedisClient;
	}

	public void setJedisClient(IJedisClient jedisClient) {
		this.jedisClient = jedisClient;
	}

	@Override
	public String get(String key) {
		return jedisClient.get(key);
	}

	@Override
	public Object getObject(String key) {
		return jedisClient.getObject(key);
	}

	@Override
	public String set(String key, String value, int cacheSeconds) {
		return jedisClient.set(key, value, cacheSeconds);
	}

	@Override
	public String setObject(String key, Object value, int cacheSeconds) {
		return jedisClient.setObject(key, value, cacheSeconds);
	}

	@Override
	public List<String> getList(String key) {
		return jedisClient.getList(key);
	}

	@Override
	public List<Object> getObjectList(String key) {
		return jedisClient.getObjectList(key);
	}

	@Override
	public long setList(String key, List<String> value, int cacheSeconds) {
		return jedisClient.setList(key, value, cacheSeconds);
	}

	@Override
	public long setObjectList(String key, List<Object> value, int cacheSeconds) {
		return jedisClient.setObjectList(key, value, cacheSeconds);
	}

	@Override
	public long listAdd(String key, String... value) {
		return jedisClient.listAdd(key, value);
	}

	@Override
	public long listObjectAdd(String key, Object... value) {
		return jedisClient.listObjectAdd(key, value);
	}

	@Override
	public Set<String> getSet(String key) {
		return jedisClient.getSet(key);
	}

	@Override
	public Set<Object> getObjectSet(String key) {
		return jedisClient.getObjectSet(key);
	}

	@Override
	public long setSet(String key, Set<String> value, int cacheSeconds) {
		return jedisClient.setSet(key, value, cacheSeconds);
	}

	@Override
	public long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
		return jedisClient.setObjectSet(key, value, cacheSeconds);
	}

	@Override
	public long setSetAdd(String key, String... value) {
		return jedisClient.setSetAdd(key, value);
	}

	@Override
	public long setSetObjectAdd(String key, Object... value) {
		return jedisClient.setSetObjectAdd(key, value);
	}

	@Override
	public Map<String, String> getMap(String key) {
		return jedisClient.getMap(key);
	}

	@Override
	public Map<String, Object> getObjectMap(String key) {
		return jedisClient.getObjectMap(key);
	}

	@Override
	public String setMap(String key, Map<String, String> value, int cacheSeconds) {
		return jedisClient.setMap(key, value, cacheSeconds);
	}

	@Override
	public String setObjectMap(String key, Map<String, Object> value,
 int cacheSeconds) {
		// TODO Auto-generated method stub
		return jedisClient.setObjectMap(key, value, cacheSeconds);
	}

	@Override
	public String mapPut(String key, Map<String, String> value) {
		// TODO Auto-generated method stub
		return jedisClient.mapPut(key, value);
	}

	@Override
	public String mapObjectPut(String key, Map<String, Object> value) {
		// TODO Auto-generated method stub
		return jedisClient.mapObjectPut(key, value);
	}

	@Override
	public long mapRemove(String key, String mapKey) {
		// TODO Auto-generated method stub
		return jedisClient.mapRemove(key, mapKey);
	}

	@Override
	public long mapObjectRemove(String key, String mapKey) {
		return jedisClient.mapObjectRemove(key, mapKey);
	}

	@Override
	public boolean mapExists(String key, String mapKey) {
		return jedisClient.mapExists(key, mapKey);
	}

	@Override
	public boolean mapObjectExists(String key, String mapKey) {
		return jedisClient.mapObjectExists(key, mapKey);
	}

	@Override
	public long del(String key) {
		return jedisClient.del(key);
	}

	@Override
	public long delObject(String key) {
		return jedisClient.delObject(key);
	}

	@Override
	public boolean exists(String key) {
		return jedisClient.exists(key);
	}

	@Override
	public boolean existsObject(String key) {
		return jedisClient.existsObject(key);
	}

}

 

© 著作权归作者所有
  • 分类:redis 
  • 字数:5579
  • + 关注
     高级程序员   昌平
    粉丝  4
     
    博文  7
     
    码字总数  8055
    评论  (2)
    Ctrl+Enter  发表评论
       
    1楼 2016/12/18 22:34
    有朋友问到StringUtils ObjectUtils里那几个方法,确实是单独实现的,也贴出来吧。
    /**
       * 序列化对象
       *  @param object
       *  @return 
       */
      public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
          if (object != null){
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            return baos.toByteArray();
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
        return null;
      }

      /**
       * 反序列化对象
       *  @param bytes
       *  @return 
       */
      public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
          if (bytes != null && bytes.length > 0){
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
        return null;
      }

    2楼 2016/12/18 22:35
    /**
    * 转换为字节数组
    @param str
    @return 
    */
    public static String toString(byte[] bytes){
      try {
          return new String(bytes, CHARSET_NAME);
        } catch (UnsupportedEncodingException e) {
          return EMPTY;
        }
    }

    /**
    * 转换为字节数组
    @param str
    @return 
    */
    public static byte[] getBytes(String str){
      if (str != null){
        try {
            return str.getBytes(CHARSET_NAME);
          } catch (UnsupportedEncodingException e) {
            return null;
          }
      }else{
        return null;
      }
    }