redis rpm 默认安装目录 redis默认路径

转载

mob64ca14095513 2023-08-24 18:03:19

文章标签 redis rpm 默认安装目录 spring ide xml 文章分类 Redis 数据库

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

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

redis rpm 默认安装目录 redis默认路径_spring

JedisClient接口类的代码如下：

[html]  
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] 
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 = jedisPool.getResource();  
18. result = jedis.set(key, value);  
19.         jedis.close();  
20.         return result;  
21.     }  
22.   
23.     @Override  
24.     public String get(String key) {  
25. jedis = jedisPool.getResource();  
26. result = jedis.get(key);  
27.         jedis.close();  
28.         return result;  
29.     }  
30.   
31.     @Override  
32.     public Boolean exists(String key) {  
33. jedis = jedisPool.getResource();  
34. result = jedis.exists(key);  
35.         jedis.close();  
36.         return result;  
37.     }  
38.   
39.     @Override  
40.     public Long expire(String key, int seconds) {  
41. jedis = jedisPool.getResource();  
42. result = jedis.expire(key, seconds);  
43.         jedis.close();  
44.         return result;  
45.     }  
46.   
47.     @Override  
48.     public Long ttl(String key) {  
49. jedis = jedisPool.getResource();  
50. result = jedis.ttl(key);  
51.         jedis.close();  
52.         return result;  
53.     }  
54.   
55.     @Override  
56.     public Long incr(String key) {  
57. jedis = jedisPool.getResource();  
58. 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 = jedisPool.getResource();  
66. 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 = jedisPool.getResource();  
74. 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 = jedisPool.getResource();  
82. result = jedis.hdel(key, field);  
83.         jedis.close();  
84.         return result;  
85.     }  
86.   
87. }

集群版实现类如下：

[html] 
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] 
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:///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:///schema/dubbo http:///schema/dubbo/dubbo.xsd  
12. >  
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都可以被外界成功注入。

redis rpm 默认安装目录 redis默认路径_ide_02

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

redis rpm 默认安装目录 redis默认路径_redis rpm 默认安装目录_03

代码如下：

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

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

[html] 
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:///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:///schema/dubbo http:///schema/dubbo/dubbo.xsd  
12. >  
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>

添加完集群配置后，我们测试方法不用做任何修改，再运行一下，如下图所示，运行正常。

redis rpm 默认安装目录 redis默认路径_redis rpm 默认安装目录_04

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

[html] 
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>

最后记得把applicationContext-jedis.xml文件中用于测试的开启注解的配置<context:annotation-config/>去掉，因为在applicationContext-service.xml文件中已经开启过注解了，系统运行会把所有的配置文件都加载进来，因此只需一处开启注解就可以了。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。