spring管理redis

Jedis在处理Redis的单机版和集群版时是完全不同的,有可能在开发的时候使用的是单机版,但是当项目上线后使用的则是集群版。这就需要能够方便的在单机版和集群版之间进行切换。我们的做法便是定义一个Jedis接口类,然后新建两个实现类来分别处理单机版和集群版,最后在Spring容器中进行配置管理即可。

       首先在taotao-content-interface工程下新建一个包com.taotao.jedis.service并在该包下新建一个接口类JedisClient,如下图所示。


        JedisClient接口类的代码如下:

[html]  view plain  copy
  1. package com.taotao.jedis.service;  
  2.   
  3. public interface JedisClient {  
  4.     //Redis SET命令用于在Redis键中设置一些字符串值  
  5.     String set(String key, String value);  
  6.     //根据key去查询相应的值  
  7.     String get(String key);  
  8.     //判断key在Redis缓存中是否存在  
  9.     Boolean exists(String key);  
  10.     //设置key的过期时间  
  11.     Long expire(String key, int seconds);  
  12.     //Redis TTL 命令以秒为单位返回 key 的剩余过期时间  
  13.     Long ttl(String key);  
  14.     //Redis Incr 命令将 key 中储存的数字值增一  
  15.     Long incr(String key);  
  16.     /**  
  17.      * Redis Hset 命令用于为哈希表中的字段赋值 。  
  18.      * 如果哈希表不存在,一个新的哈希表被创建并进行 HSET 操作。  
  19.      * 如果字段已经存在于哈希表中,旧值将被覆盖。  
  20.      * @param key  
  21.      * @param field  
  22.      * @param value  
  23.      * @return  
  24.      */  
  25.     Long hset(String key, String field, String value);  
  26.     //Redis Hget 命令用于返回哈希表中指定字段的值。  
  27.     String hget(String key, String field);  
  28.     //Redis Hdel 命令用于删除哈希表 key 中的一个或多个指定字段,不存在的字段将被忽略。  
  29.     Long hdel(String key, String... field);  
  30. }  

     接着我们到taotao-content-service工程下新建一个com.taotao.jedis.service.impl包,并在该包下新建两个JedisClient的实现类,分别是单机版实现类JedisClientPool和集群版实现类JedisClientCluster。单机版实现类如下:

[html]  view plain  copy
  1. package com.taotao.jedis.service.impl;  
  2.   
  3. import org.springframework.beans.factory.annotation.Autowired;  
  4.   
  5. import com.taotao.jedis.service.JedisClient;  
  6.   
  7. import redis.clients.jedis.Jedis;  
  8. import redis.clients.jedis.JedisPool;  
  9.   
  10. public class JedisClientPool implements JedisClient {  
  11.   
  12.     @Autowired  
  13.     private JedisPool jedisPool;  
  14.   
  15.     @Override  
  16.     public String set(String key, String value) {  
  17.         Jedis jedis = jedisPool.getResource();  
  18.         String result = jedis.set(key, value);  
  19.         jedis.close();  
  20.         return result;  
  21.     }  
  22.   
  23.     @Override  
  24.     public String get(String key) {  
  25.         Jedis jedis = jedisPool.getResource();  
  26.         String result = jedis.get(key);  
  27.         jedis.close();  
  28.         return result;  
  29.     }  
  30.   
  31.     @Override  
  32.     public Boolean exists(String key) {  
  33.         Jedis jedis = jedisPool.getResource();  
  34.         Boolean result = jedis.exists(key);  
  35.         jedis.close();  
  36.         return result;  
  37.     }  
  38.   
  39.     @Override  
  40.     public Long expire(String key, int seconds) {  
  41.         Jedis jedis = jedisPool.getResource();  
  42.         Long result = jedis.expire(key, seconds);  
  43.         jedis.close();  
  44.         return result;  
  45.     }  
  46.   
  47.     @Override  
  48.     public Long ttl(String key) {  
  49.         Jedis jedis = jedisPool.getResource();  
  50.         Long result = jedis.ttl(key);  
  51.         jedis.close();  
  52.         return result;  
  53.     }  
  54.   
  55.     @Override  
  56.     public Long incr(String key) {  
  57.         Jedis jedis = jedisPool.getResource();  
  58.         Long result = jedis.incr(key);  
  59.         jedis.close();  
  60.         return result;  
  61.     }  
  62.   
  63.     @Override  
  64.     public Long hset(String key, String field, String value) {  
  65.         Jedis jedis = jedisPool.getResource();  
  66.         Long result = jedis.hset(key, field, value);  
  67.         jedis.close();  
  68.         return result;  
  69.     }  
  70.   
  71.     @Override  
  72.     public String hget(String key, String field) {  
  73.         Jedis jedis = jedisPool.getResource();  
  74.         String result = jedis.hget(key, field);  
  75.         jedis.close();  
  76.         return result;  
  77.     }  
  78.   
  79.     @Override  
  80.     public Long hdel(String key, String... field) {  
  81.         Jedis jedis = jedisPool.getResource();  
  82.         Long result = jedis.hdel(key, field);  
  83.         jedis.close();  
  84.         return result;  
  85.     }  
  86.   
  87. }  

       集群版实现类如下:

[html]  view plain  copy
  1. package com.taotao.jedis.service.impl;  
  2.   
  3. import org.springframework.beans.factory.annotation.Autowired;  
  4.   
  5. import com.taotao.jedis.service.JedisClient;  
  6.   
  7. import redis.clients.jedis.JedisCluster;  
  8.   
  9. public class JedisClientCluster implements JedisClient {  
  10.   
  11.     @Autowired  
  12.     private JedisCluster jedisCluster;  
  13.   
  14.     @Override  
  15.     public String set(String key, String value) {  
  16.         return jedisCluster.set(key, value);  
  17.     }  
  18.   
  19.     @Override  
  20.     public String get(String key) {  
  21.         return jedisCluster.get(key);  
  22.     }  
  23.   
  24.     @Override  
  25.     public Boolean exists(String key) {  
  26.         return jedisCluster.exists(key);  
  27.     }  
  28.   
  29.     @Override  
  30.     public Long expire(String key, int seconds) {  
  31.         return jedisCluster.expire(key, seconds);  
  32.     }  
  33.   
  34.     @Override  
  35.     public Long ttl(String key) {  
  36.         return jedisCluster.ttl(key);  
  37.     }  
  38.   
  39.     @Override  
  40.     public Long incr(String key) {  
  41.         return jedisCluster.incr(key);  
  42.     }  
  43.   
  44.     @Override  
  45.     public Long hset(String key, String field, String value) {  
  46.         return jedisCluster.hset(key, field, value);  
  47.     }  
  48.   
  49.     @Override  
  50.     public String hget(String key, String field) {  
  51.         return jedisCluster.hget(key, field);  
  52.     }  
  53.   
  54.     @Override  
  55.     public Long hdel(String key, String... field) {  
  56.         return jedisCluster.hdel(key, field);  
  57.     }  
  58.   
  59. }  

      我们先来测试单机版如何使用,我们在单机版实现类JedisClientPool当中可以看到使用注入的方式注入JedisPool,要注入,Spring容器当中便要管理这个Bean,因此我们在taotao-content-service工程的src/main/resources/spring目录下新建一个applicationContext-jedis.xml配置文件来专门管理Jedis客户端的使用,内容如下( 注意:下面的配置文件中关于开启注解的配置是为了在测试类中测试代码而添加的,因为使用测试类测试的话,不会加载其它配置文件,因此没有开启注解,因此需要这句配置,测试完后记得要删掉这个配置。还有就是单机版配置的端口6999是我在redis.conf中配置的,之所以没用默认的6379是因为redis集群使用了该端口 )。

[html]  view plain  copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:p="http://www.springframework.org/schema/p"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  6.     xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"  
  7.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  8.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd  
  9.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd  
  10.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd  
  11.     http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd  
  12.     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">  
  13.       
  14.     <!-- 开启注解 -->  
  15.     <context:annotation-config/>  
  16.       
  17.     <!-- redis单机版 -->  
  18.     <bean id="jedisPool" class="redis.clients.jedis.JedisPool">  
  19.         <constructor-arg name="host" value="192.168.156.21"/>  
  20.         <constructor-arg name="port" value="6999"/>  
  21.     </bean>  
  22.     <bean id="jedisClientPool" class="com.taotao.jedis.service.impl.JedisClientPool"></bean>  
  23. </beans>  

       针对applicationContext-jedis.xml配置文件的内容有一点需要说明一下,我们看看下图,applicationContext-service.xml文件配置的扫描包的范围是com.taotao.content.service, 那么如果我们不指定要扫描com.taotao.jedis.service包的话,能不能把JedisPool注入进来呢?答案是可以的 ,因为下图中<context:component-scan base-package="com.taotao.content.service"/>这句配置不仅指定了一个包扫描范围,还有一个功能就是开启注解(也就是同时具备两个功能),开启注解后写到Spring容器中的Bean都可以被外界成功注入。

       下面我们新建一个测试类来进行测试,发现单机版没用问题,如下图所示。


        代码如下:

[html]  view plain  copy
  1. @Test  
  2. public void testJedisClientPool(){  
  3.     //初始化Spring容器  
  4.     ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-jedis.xml");  
  5.     //从容器中获取JedisClient对象  
  6.     JedisClient jedisClient = ctx.getBean(JedisClient.class);  
  7.     //使用JedisClient操作Redis  
  8.     jedisClient.set("jedisClient", "mytest");  
  9.     String result = jedisClient.get("jedisClient");  
  10.     System.out.println(result);  
  11. }  

       测试完了单机版,现在我们来测试集群版,在配置文件中注释掉单机版配置,添加集群版配置,如下所示。

[html]  view plain  copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:p="http://www.springframework.org/schema/p"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  6.     xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"  
  7.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  8.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd  
  9.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd  
  10.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd  
  11.     http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd  
  12.     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">  
  13.       
  14.     <!-- 开启注解 -->  
  15.     <context:annotation-config/>  
  16.       
  17.     <!-- redis单机版 -->  
  18.     <!-- <bean id="jedisPool" class="redis.clients.jedis.JedisPool">  
  19.         <constructor-arg name="host" value="192.168.156.21"/>  
  20.         <constructor-arg name="port" value="6999"/>  
  21.     </bean>  
  22.     <bean id="jedisClientPool" class="com.taotao.jedis.service.impl.JedisClientPool"></bean> -->  
  23.       
  24.     <!-- redis集群版 -->  
  25.     <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">  
  26.         <constructor-arg>  
  27.             <set>  
  28.                 <bean class="redis.clients.jedis.HostAndPort">  
  29.                     <constructor-arg name="host" value="192.168.156.15"/>  
  30.                     <constructor-arg name="port" value="6379"/>  
  31.                 </bean>  
  32.                 <bean class="redis.clients.jedis.HostAndPort">  
  33.                     <constructor-arg name="host" value="192.168.156.16"/>  
  34.                     <constructor-arg name="port" value="6379"/>  
  35.                 </bean>  
  36.                 <bean class="redis.clients.jedis.HostAndPort">  
  37.                     <constructor-arg name="host" value="192.168.156.17"/>  
  38.                     <constructor-arg name="port" value="6379"/>  
  39.                 </bean>  
  40.                 <bean class="redis.clients.jedis.HostAndPort">  
  41.                     <constructor-arg name="host" value="192.168.156.18"/>  
  42.                     <constructor-arg name="port" value="6379"/>  
  43.                 </bean>  
  44.                 <bean class="redis.clients.jedis.HostAndPort">  
  45.                     <constructor-arg name="host" value="192.168.156.19"/>  
  46.                     <constructor-arg name="port" value="6379"/>  
  47.                 </bean>  
  48.                 <bean class="redis.clients.jedis.HostAndPort">  
  49.                     <constructor-arg name="host" value="192.168.156.20"/>  
  50.                     <constructor-arg name="port" value="6379"/>  
  51.                 </bean>  
  52.             </set>  
  53.         </constructor-arg>  
  54.     </bean>  
  55.     <bean id="jedisClientCluster" class="com.taotao.jedis.service.impl.JedisClientCluster"></bean>  
  56. </beans>  
  
        添加完集群配置后,我们测试方法不用做任何修改,再运行一下,如下图所示,运行正常。


      我们再到集群中任何一个节点去检查一下,比如我在192.168.156.17这个节点上使用客户端连接集群,使用命令get jedisClient来获取它的值,发现jedisClien被保存到了槽号为13154的上面,该槽号在192.168.156.18上,如下所示,说明确实保存到集群当中了。

[html]  view plain  copy
  1. [root@redis3 bin]# ./redis-cli -h 192.168.156.17 -p 6379 -c  
  2. 192.168.156.17:6379> get jedisClient  
  3. -> Redirected to slot [13154] located at 192.168.156.18:6379  
  4. "mytest"  
  5. 192.168.156.18:6379>   

      这样,以后我们只需修改Spring配置文件便可轻松在单机版和集群版进行切换。最后记得把applicationContext-jedis.xml文件中用于测试的开启注解的配置<context:annotation-config/>去掉,因为在applicationContext-service.xml文件中已经开启过注解了,系统运行会把所有的配置文件都加载进来,因此只需一处开启注解就可以了。

相关文章
相关标签/搜索