Redis初探（7）——Jedis操纵集群

男娘i 2022-05-27 01:42 346阅读 0赞

在Redis初探（2）——Jedis的使用中，我们已经学会了Jedis操纵单机Redis的简单使用，本章将继续深入，介绍Jedis对集群的操纵。

一、Jedis连接单机

在开始介绍Jedis连接集群之前，先简单回顾下连接单机的使用。

1.1 简单使用

  1. @Test
  2. public void testJedis() {
  3.     // 1.获得连接对象。参数为redis所在的服务器地址及端口号
  4.     Jedis jedis = new Jedis("192.168.30.155", 6379);
  6.     // 2.获得数据
  7.     String age = jedis.get("age");
  8.     System.out.println(age);
  10.     jedis.close();
  12. }

1.2 使用连接池

  1. @Test
  2. public void testJedisPool() {
  3.     //1. 创建Jedis连接池配置（包含许多配置，这里只配置了3个）
  4.     JedisPoolConfig poolConfig = new JedisPoolConfig();
  5.     // 设置最小和最大闲置个数
  6.     poolConfig.setMinIdle(5);
  7.     poolConfig.setMaxIdle(10);
  8.     // 设置连接池最大个数
  9.     poolConfig.setMaxTotal(30);
  11.     //2. 创建Jedis连接池
  12.     JedisPool pool = new JedisPool(poolConfig,"192.168.30.155", 6379);
  14.     //3. 从连接池中获取Jedis对象
  15.     Jedis jedis = pool.getResource();
  17.     //4.操纵数据
  18.     jedis.set("sex", "male");
  19.     System.out.println(jedis.get("sex"));
  21.     //5.关闭资源
  22.     jedis.close();
  23.     pool.close();
  24. }

二、Jedis连接集群

Jedis连接集群也是十分简单，首先创建一个HostAndPort的集合，里面存放着集群中的每一个节点，然后创建JedisCluster对象，直接操纵该对象即可。

JedisCluster在项目中单例存在即可。第三步的关闭可省略（因为单例存在，如果关掉了，即整个项目要结束了）。

  1. @Test
  2. public void testJedisCluster() throws IOException {
  3.     // 1.创建一个JedisCluster对象。第一个参数nodes是一个set类型，set中包含若干个HostAndPort对象
  4.     Set<HostAndPort> nodes = new HashSet<>();
  5.     nodes.add(new HostAndPort("192.168.30.155", 7001));
  6.     nodes.add(new HostAndPort("192.168.30.155", 7002));
  7.     nodes.add(new HostAndPort("192.168.30.155", 7003));
  8.     nodes.add(new HostAndPort("192.168.30.155", 7004));
  9.     nodes.add(new HostAndPort("192.168.30.155", 7005));
  10.     nodes.add(new HostAndPort("192.168.30.155", 7006));
  11.     JedisCluster cluster = new JedisCluster(nodes);
  12.     // 2.直接使用JedisCluster对象操作redis，单例存在即可。
  13.     cluster.set("test", "123");
  14.     System.out.println(cluster.get("test"));
  15.     // 3.关闭JedisCluster对象。
  16.     cluster.close();
  17. }

三、Jedis的实际应用

在实际项目中，测试环境一般使用单机版，生产环境使用集群版。为了避免代码的不必要改动，我们使用策略模式，面向接口开发。

3.1 JedisClient接口

定义一个JedisClient的接口，里面封装了常用的一些方法，主要是对String类型和Hash类型的操作，可以根据实际情况进行修改。

  1. import java.util.List;
  3. public interface JedisClient {
  4.     String set(String key, String value);
  5.     String get(String key);
  6.     Boolean exists(String key);
  7.     Long expire(String key, int seconds);
  8.     Long ttl(String key);
  9.     Long incr(String key);
  10.     Long hset(String key, String field, String value);
  11.     String hget(String key, String field);
  12.     Long hdel(String key, String... field);
  13.     Boolean hexists(String key, String field);
  14.     List<String> hvals(String key);
  15.     Long del(String key);
  16. }

3.2 单机实现类

  1. import java.util.List;
  3. import redis.clients.jedis.Jedis;
  4. import redis.clients.jedis.JedisPool;
  6. public class JedisClientPool implements JedisClient { 
  8.     private JedisPool jedisPool;
  10.     public JedisPool getJedisPool() {
  11.         return jedisPool;
  12.     }
  14.     public void setJedisPool(JedisPool jedisPool) {
  15.         this.jedisPool = jedisPool;
  16.     }
  18.     @Override
  19.     public String set(String key, String value) {
  20.         Jedis jedis = jedisPool.getResource();
  21.         String result = jedis.set(key, value);
  22.         jedis.close();
  23.         return result;
  24.     }
  26.     @Override
  27.     public String get(String key) {
  28.         Jedis jedis = jedisPool.getResource();
  29.         String result = jedis.get(key);
  30.         jedis.close();
  31.         return result;
  32.     }
  34.     @Override
  35.     public Boolean exists(String key) {
  36.         Jedis jedis = jedisPool.getResource();
  37.         Boolean result = jedis.exists(key);
  38.         jedis.close();
  39.         return result;
  40.     }
  42.     @Override
  43.     public Long expire(String key, int seconds) {
  44.         Jedis jedis = jedisPool.getResource();
  45.         Long result = jedis.expire(key, seconds);
  46.         jedis.close();
  47.         return result;
  48.     }
  50.     @Override
  51.     public Long ttl(String key) {
  52.         Jedis jedis = jedisPool.getResource();
  53.         Long result = jedis.ttl(key);
  54.         jedis.close();
  55.         return result;
  56.     }
  58.     @Override
  59.     public Long incr(String key) {
  60.         Jedis jedis = jedisPool.getResource();
  61.         Long result = jedis.incr(key);
  62.         jedis.close();
  63.         return result;
  64.     }
  66.     @Override
  67.     public Long hset(String key, String field, String value) {
  68.         Jedis jedis = jedisPool.getResource();
  69.         Long result = jedis.hset(key, field, value);
  70.         jedis.close();
  71.         return result;
  72.     }
  74.     @Override
  75.     public String hget(String key, String field) {
  76.         Jedis jedis = jedisPool.getResource();
  77.         String result = jedis.hget(key, field);
  78.         jedis.close();
  79.         return result;
  80.     }
  82.     @Override
  83.     public Long hdel(String key, String... field) {
  84.         Jedis jedis = jedisPool.getResource();
  85.         Long result = jedis.hdel(key, field);
  86.         jedis.close();
  87.         return result;
  88.     }
  90.     @Override
  91.     public Boolean hexists(String key, String field) {
  92.         Jedis jedis = jedisPool.getResource();
  93.         Boolean result = jedis.hexists(key, field);
  94.         jedis.close();
  95.         return result;
  96.     }
  98.     @Override
  99.     public List<String> hvals(String key) {
  100.         Jedis jedis = jedisPool.getResource();
  101.         List<String> result = jedis.hvals(key);
  102.         jedis.close();
  103.         return result;
  104.     }
  106.     @Override
  107.     public Long del(String key) {
  108.         Jedis jedis = jedisPool.getResource();
  109.         Long result = jedis.del(key);
  110.         jedis.close();
  111.         return result;
  112.     }
  114. }

3.3 集群实现类

  1. import java.util.List;
  3. import redis.clients.jedis.JedisCluster;
  5. public class JedisClientCluster implements JedisClient { 
  7.     private JedisCluster jedisCluster;
  9.     public JedisCluster getJedisCluster() {
  10.         return jedisCluster;
  11.     }
  13.     public void setJedisCluster(JedisCluster jedisCluster) {
  14.         this.jedisCluster = jedisCluster;
  15.     }
  17.     @Override
  18.     public String set(String key, String value) {
  19.         return jedisCluster.set(key, value);
  20.     }
  22.     @Override
  23.     public String get(String key) {
  24.         return jedisCluster.get(key);
  25.     }
  27.     @Override
  28.     public Boolean exists(String key) {
  29.         return jedisCluster.exists(key);
  30.     }
  32.     @Override
  33.     public Long expire(String key, int seconds) {
  34.         return jedisCluster.expire(key, seconds);
  35.     }
  37.     @Override
  38.     public Long ttl(String key) {
  39.         return jedisCluster.ttl(key);
  40.     }
  42.     @Override
  43.     public Long incr(String key) {
  44.         return jedisCluster.incr(key);
  45.     }
  47.     @Override
  48.     public Long hset(String key, String field, String value) {
  49.         return jedisCluster.hset(key, field, value);
  50.     }
  52.     @Override
  53.     public String hget(String key, String field) {
  54.         return jedisCluster.hget(key, field);
  55.     }
  57.     @Override
  58.     public Long hdel(String key, String... field) {
  59.         return jedisCluster.hdel(key, field);
  60.     }
  62.     @Override
  63.     public Boolean hexists(String key, String field) {
  64.         return jedisCluster.hexists(key, field);
  65.     }
  67.     @Override
  68.     public List<String> hvals(String key) {
  69.         return jedisCluster.hvals(key);
  70.     }
  72.     @Override
  73.     public Long del(String key) {
  74.         return jedisCluster.del(key);
  75.     }
  77. }

3.4 实战演示

（1）首先准备一个配置文件cfg.properties，在配置文件中加入关于redis的信息：

  1. # redis单机
  2. redis.standalone.host=192.168.30.155
  3. redis.standalone.port=6379
  4. #redis集群
  5. redis.cluster.01.host=192.168.30.155
  6. redis.cluster.01.port=7001
  7. redis.cluster.02.host=192.168.30.155
  8. redis.cluster.02.port=7002
  9. redis.cluster.03.host=192.168.30.155
  10. redis.cluster.03.port=7003
  11. redis.cluster.04.host=192.168.30.155
  12. redis.cluster.04.port=7004
  13. redis.cluster.05.host=192.168.30.155
  14. redis.cluster.05.port=7005
  15. redis.cluster.06.host=192.168.30.155
  16. redis.cluster.06.port=7006

（2）准备Spring关于redis的配置文件applicationContext-redis.xml：

需要注意的是，单机和集群同时只能放开一个，另一个必须注释掉。因为我们取Bean是取接口，即JedisClient，这两个都是JedisClient的实现类。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  4.     <!-- 注意：单机和集群同时只能放开一个 -->
  6.     <!-- 加载配置文件 -->
  7.     <context:property-placeholder location="classpath:cfg.properties"/>
  9.     <!-- 配置Redis单机 -->
  10.     <bean id="jedisClientPool" class="jit.wxs.common.jedis.JedisClientPool">
  11.         <property name="jedisPool" ref="jedisPool"/>
  12.     </bean>
  13.     <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
  14.         <constructor-arg name="host" value="${redis.standalone.host}"/>
  15.         <constructor-arg name="port" value="${redis.standalone.port}"/>
  16.     </bean>
  18.     <!-- 配置Redis集群 -->
  19.     <bean id="jedisClientCluster" class="jit.wxs.common.jedis.JedisClientCluster">
  20.         <property name="jedisCluster" ref="jedisCluster"/>
  21.     </bean>
  22.     <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">
  23.         <constructor-arg>
  24.             <set>
  25.                 <bean class="redis.clients.jedis.HostAndPort">
  26.                     <constructor-arg name="host" value="${redis.cluster.01.host}"/>
  27.                     <constructor-arg name="port" value="${redis.cluster.01.port}"/>
  28.                 </bean>
  29.                 <bean class="redis.clients.jedis.HostAndPort">
  30.                     <constructor-arg name="host" value="${redis.cluster.02.host}"/>
  31.                     <constructor-arg name="port" value="${redis.cluster.02.port}"/>
  32.                 </bean>
  33.                 <bean class="redis.clients.jedis.HostAndPort">
  34.                     <constructor-arg name="host" value="${redis.cluster.03.host}"/>
  35.                     <constructor-arg name="port" value="${redis.cluster.03.port}"/>
  36.                 </bean>
  37.                 <bean class="redis.clients.jedis.HostAndPort">
  38.                     <constructor-arg name="host" value="${redis.cluster.04.host}"/>
  39.                     <constructor-arg name="port" value="${redis.cluster.04.port}"/>
  40.                 </bean>
  41.                 <bean class="redis.clients.jedis.HostAndPort">
  42.                     <constructor-arg name="host" value="${redis.cluster.05.host}"/>
  43.                     <constructor-arg name="port" value="${redis.cluster.05.port}"/>
  44.                 </bean>
  45.                 <bean class="redis.clients.jedis.HostAndPort">
  46.                     <constructor-arg name="host" value="${redis.cluster.06.host}"/>
  47.                     <constructor-arg name="port" value="${redis.cluster.06.port}"/>
  48.                 </bean>
  49.             </set>
  50.         </constructor-arg>
  51.     </bean>
  52. </beans>

（3）编写测试方法

  1. @Test
  2. public void test() {
  3.     ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext-redis.xml");
  4.     JedisClient jedisClient = ac.getBean(JedisClient.class);
  6.     jedisClient.set("author", "jitwxs");
  7.     String result = jedisClient.get("author");
  8.     System.out.println(result);
  9. }

因为我们是面向接口开发，因此当我们切换单机和集群时，这段代码不需要任何修改，只需要修改配置文件即可。

发表评论

表情：
评论列表 （有 0 条评论，346人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Jedis 初探

    Jedis是java操作redis的jar包 先说一下如何连接redis 比如在linux操作系统上的话，进入目录，输入 "./redis cli"即可登录。 如果设置了

    水深无声水深无声/ 0 赞/ 269 阅读

    相关 Redis初探（6）——Redis集群

    之前我们所学习的都是 Redis 的单机版，我们知道 Redis 之所以读取速度快是因为它是存储在内存中的。内存的容量是有限的，单台 Redis 会碰到性能瓶颈，这就需要使用

    小咪咪小咪咪/ 0 赞/ 268 阅读