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

最新推荐文章于 2024-03-22 09:25:27 发布
最新推荐文章于 2024-03-22 09:25:27 发布
阅读量1.6w 收藏 9
点赞数 1
分类专栏： java redis
java 同时被 2 个专栏收录
76 篇文章 0 订阅
订阅专栏
redis
10 篇文章 0 订阅
订阅专栏

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
标签：  jedis redis 策略模式
jimmywu911 
 高级程序员   昌平
粉丝  4
 
博文  7
 
码字总数  8055
评论  (2)
Ctrl+Enter 
   
jimmywu911
jimmywu911
有朋友问到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;
  }

jimmywu911
jimmywu911
/**
* 转换为字节数组
*  @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;
  }
}

土豆大人
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Jedis单机版和集群版连接工具
09-11
包含三个类JedisClient.java； JedisClientCluster.java ；JedisClientPool.java，不用自己手动写连接池，调用类中的函数，传入相关参数即可完成连接Redis
Jedis和Jedis连接池的基本使用和配置
wenxuanyue的博客
05-28 832
（一）获取Jedis Jedis是基于java语言的redis_cli maven依赖： <!-- Redis的redis客户端 https://mvnrepository.com/artifact/redis.clients/jedis --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <ve
Jedis连接Redis三种方式
厚积薄发
07-05 4582
1、单机模式 private String addr="192.168.1.1"; private String port="6236"; private String key="key"; private Jedis jedis=new Jedis(addr,port);//Jedis获取到的Redis数据在jedis里,jedis.set("a","b");//更改key为a的值jedis...
Jedis、RedisTemplate、Redisson 详解和实例
最新发布
深圳市多克创新科技有限公司
03-22 5114
Jedis、RedisTemplate、Redisson 核心功能解析
Jedis连接方式
金溪的博客
11-24 631
使用Jedis连接Redis服务有三种方式：Jedis/JedisPool, SharedJedis/SharedJedisPool, JedisCluster，分别对应了服务器的不同部署方式。 1.Jedis，JedisPool 这种方式针对单个Redis服务器建立连接，Jedis是单个连接，JedisPool即Jedis连接池，为了优化连接性能而生。 2.使用SharedJedis,Sh...
Redis学习笔记（二）
sd4422739的博客
11-18 535
一、通过Jedis客户端连接Redis缓存步骤： 1、添加jar包： pom坐标： dependency>      groupId>redis.clientsgroupId>      artifactId>jedisartifactId>      version>2.7.0version> dependency> jar包如下： commons-pool2-2.3.ja
在Spring Boot微服务集成JedisCluster操作Redis集群
zhangbeizhen18的博客
06-08 4641
记录：448 场景：在Spring Boot微服务使用JedisCluster操作Redis集群的缓存和队列等数据类型。
Jedis 连接Redis 集群
weixin_44521511的博客
11-01 3773
1. Jedis实现了连接Redis集群的操作，但是操作Redis集群的API是JedisCluster，和单机版api不一致 （Jedis）； 2. 创建JedisCluster需要一个Set集合，Set集合的每一个元素是HostAndPort； JedisCluster实际上可以根据一个节点的IP和端口号自动发现集群中的其它节点； 代码: package com.etoak; import redis.clients.jedis.HostAndPort; import redis.client
jedis连接redis集群
qq_37705525的博客
03-20 4041
jedis连接redis集群
非关系型数据库之Redis【Jedis客户端+Jedis连接集群】
捌椒的博客
07-26 1867
Redis不仅是使用命令来操作，现在基本上主流的语言都有客户端支持，比如java、C、C#、C++、php、Node.js、Go等。在官方网站里列一些Java的客户端，有Jedis、Redisson、Jredis、JDBC-Redis、等其中官方推荐使用Jedis和Redisson。在企业中用的最多的就是Jedis。......
redis集群
LYX_WIN
06-08 1113
Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库。它通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：字符串类型String散列类型 hashmap列表类型 list集合类型有序集合类型。sortedset。
redis jedis 单机、集群、分片存储连接操作redis
08-21
单机版：该类主要完成redis基础功能，若redis为单机版时，该方式即可。 但若连接redis集群时，该方式只能获取指定库的键值，表现形式为 取数据不完整。 集群版:redis集群连接. 分片存储：redis分片存储，该方式...
Redis单机、主从、哨兵Jave-Jedis连接代码
10-11
Redis单机、主从、哨兵Jave-Jedis连接代码 博文地址：https://blog.csdn.net/scm_2008/article/details/127231800
redis入门存储数据类型及集群搭建，以及java使用jedis操作redis,使用redis做缓存
07-22
redis入门： 1、Redis服务器搭建 2、向业务逻辑中添加缓存。 3、使用redis做缓存 4、缓存同步
jedis-2.9.0 最新版Redis客户端CSDN下载
01-08
jedis-2.9.0.jar jedis-2.9.0-javadoc.jar jedis-2.9.0-sources.jar
redis单机和集群的切换
胡泽宽-廊坊师范学院信息技术提高班-十三期
06-28 2115
在redis单机中用的是JedisCluster。在redis集群中用的是JedisPool。一般来说在开发环境中用单机就可以，而生产的时候就要切换到集群中了。 那么要需要两套代码吗？当然不是我们可以使用策略模式。 创建一个jedisclient接口 public interface JedisClient { String set(Stri...
Redis入门第三讲——在Java程序中通过Jedis连接Redis
李阿昀的博客
07-25 1116
Jedis介绍 Redis不仅是使用命令来操作，现在基本上主流的语言都有客户端支持，比如Java、C、C#、C++、php、Node.js、Go等。在官方网站里罗列了一些Java的客户端，有Jedis、Redisson、Jredis、JDBC-Redis等等，其中官方推荐使用Jedis和Redisson，在企业中用的最多的就是Jedis，所以下面我们就重点学习下Jedis。 Jedis同样也是托管...
用Jedis获取redis连接(集群和非集群状态下)
热门推荐
koushr的博客
03-22 2万+
第一：非集群状态下 非集群状态下用Jedis获取redis连接，得到Jedis对象即可，一共有两种： 1.利用Jedis构造器，仅限用于测试，在实际项目中肯定是用JedisPool。   Jedis(String host);   Jedis(String host , int port); 2.利用JedisPool 主要是利用Jedis jedis=jedisPool.getR
java使用jedis连接redis和redis集群
我秃了，也变强了。
05-21 897
java使用jedis连接redis和redis集群

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值