SpringBoot + redis cluster集群搭建

系统管理员 2023-07-05 14:57 77阅读 0赞

SpringBoot + redis cluster集群搭建

  前言：本文针对另一篇Redis集群策略及集群实例（集群节点新增、删除、重新分配slot实战）博文搭建的Java项目用于redis集群完整流程的学习，仅供参考；
本文代码参考与码云开源项目相关资料
1. 环境
（1）.springboot 2.0
（2）.redis 4.0.10
2.相关代码
一，pom.xml文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.2.4.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>spring.boot</groupId>
  12.     <artifactId>demo</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <packaging>jar</packaging>
  15.     <name>jpa</name>
  16.     <description>Demo project for Spring Boot</description>
  18.     <properties>
  19.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  20.         <start-class>org.tdcg.Application</start-class>
  21.         <java.version>1.8</java.version>
  22.     </properties>
  23.     <dependencies>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-thymeleaf</artifactId>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.springframework.boot</groupId>
  34.             <artifactId>spring-boot-starter-web</artifactId>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>com.alibaba</groupId>
  38.             <artifactId>druid</artifactId>
  39.             <version>1.1.6</version>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>mysql</groupId>
  43.             <artifactId>mysql-connector-java</artifactId>
  44.             <scope>runtime</scope>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework.boot</groupId>
  48.             <artifactId>spring-boot-starter-test</artifactId>
  49.         </dependency>
  50.         <dependency>
  51.             <groupId>org.projectlombok</groupId>
  52.             <artifactId>lombok</artifactId>
  53.             <version>1.18.10</version>
  54.         </dependency>
  55.         <!--监控sql日志-->
  56.         <dependency>
  57.             <groupId>org.bgee.log4jdbc-log4j2</groupId>
  58.             <artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
  59.             <version>1.16</version>
  60.         </dependency>
  61.         <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui ->
  62.         <dependency>
  63.             <groupId>io.springfox</groupId>
  64.             <artifactId>springfox-swagger2</artifactId>
  65.             <version>2.6.1</version>
  66.         </dependency>
  67.         <dependency>
  68.             <groupId>io.springfox</groupId>
  69.             <artifactId>springfox-swagger-ui</artifactId>
  70.             <version>2.6.1</version>
  71.         </dependency>
  72.         <!--属性配置支持-->
  73.         <dependency>
  74.             <groupId>org.springframework.boot</groupId>
  75.             <artifactId>spring-boot-configuration-processor</artifactId>
  76.             <optional>true</optional>
  77.         </dependency>
  78.         <!--redis依赖-->
  79.         <!--默认继承lettuce，切换成jedis需要排除依赖-->
  80.         <dependency>
  81.             <groupId>org.springframework.boot</groupId>
  82.             <artifactId>spring-boot-starter-data-redis</artifactId>
  83.             <exclusions>
  84.                 <exclusion>
  85.                     <groupId>io.lettuce</groupId>
  86.                     <artifactId>lettuce-core</artifactId>
  87.                 </exclusion>
  88.             </exclusions>
  89.         </dependency>
  90.         <!--redis 客户端-->
  91.         <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
  92.         <dependency>
  93.             <groupId>redis.clients</groupId>
  94.             <artifactId>jedis</artifactId>
  95.         </dependency>
  96.         <dependency>
  97.             <groupId>com.alibaba</groupId>
  98.             <artifactId>fastjson</artifactId>
  99.             <version>1.2.31</version>
  100.         </dependency>
  101.         <dependency>
  102.             <groupId>org.springframework</groupId>
  103.             <artifactId>spring-context</artifactId>
  104.             <version>5.2.3.RELEASE</version>
  105.         </dependency>
  106.         <dependency>
  107.             <groupId>log4j</groupId>
  108.             <artifactId>log4j</artifactId>
  109.             <version>1.2.17</version>
  110.         </dependency>
  111.         <dependency>
  112.             <groupId>junit</groupId>
  113.             <artifactId>junit</artifactId>
  114.             <version>4.12</version>
  115.             <scope>test</scope>
  116.         </dependency>
  117.     </dependencies>
  118.     <build>
  119.         <plugins>
  120.             <plugin>
  121.                 <groupId>org.springframework.boot</groupId>
  122.                 <artifactId>spring-boot-maven-plugin</artifactId>
  123.             </plugin>
  124.         </plugins>
  125.         <finalName>SpringBootJap</finalName>
  126.     </build>
  127. </project>

二，配置文件 application.properties

  1. #datasource#mysql数据库#
  2. spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
  3. spring.datasource.url=jdbc:mysql://127.0.0.1:3306/study-jpa?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
  4. spring.datasource.username = root
  5. spring.datasource.password = 123456
  6. spring.datasource.driverClassName = com.mysql.cj.jdbc.Driver
  7. spring.datasource.max-active=20
  8. spring.datasource.max-idle=8
  9. spring.datasource.min-idle=8
  10. spring.datasource.initial-size=10
  11. # server
  12. server.port: 8081

三，redis配置文件 redis.properties

  1. #代表redis多个节点的ip与端口号，多个节点需要使用“，”隔开。
  2. spring.redis.cluster.nodes=192.168.0.108:8001,192.168.0.108:8002,192.168.0.108:8003,192.168.0.108:8004,192.168.0.108:8005,192.168.0.108:8006
  3. # 最大的要重定向的次数（由于集群中数据存储在多个节点所以，在访问数据时需要通过节点进行转发）
  4. # 连接超时的时间
  5. spring.redis.cluster.timeout=5000
  6. #最大的连接重试次数
  7. spring.redis.cluster.max-attempts=3
  8. #读取数据超时
  9. spring.redis.cluster.soTimeout=3000
  10. spring.redis.cluster.max-redirects=3

三，创建文件夹redis配置，依此创建redis初始化配置RedisConfiguration ，JedisClusterFactory工厂类，自定义缓存接口ICacheManager 以及redis客户端实现类JedisCacheManager

（一）redis初始化配置RedisConfiguration

  1. package spring.boot.jpa.redis;
  4. import com.google.common.collect.Sets;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.cache.annotation.CachingConfigurerSupport;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.context.annotation.PropertySource;
  11. import java.util.Collections;
  12. import java.util.Set;
  14. /** * @Title: RedisConfiguration * @Description: redis初始化配置 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
  15. @Configuration
  17. @PropertySource("classpath:redis.properties")
  18. public class RedisConfiguration extends CachingConfigurerSupport { 
  20.     @Bean(name = "jedisCluster")
  21.     public JedisClusterFactory jedisCluster(
  22.             @Value("${spring.redis.cluster.nodes}") String host,
  23.             @Value("${spring.redis.cluster.timeout}") int connectionTimeout,
  24.             @Value("${spring.redis.cluster.soTimeout}") int soTimeout) { 
  25.         JedisClusterFactory jedisClusterFactory = new JedisClusterFactory();
  26.         jedisClusterFactory.setConnectionTimeout(connectionTimeout);
  27.        // jedisClusterFactory.setMaxRedirections(maxRedirections);
  28.         jedisClusterFactory.setSoTimeout(soTimeout);
  29.         String[] split = host.split(",");
  30.         Set<String> hosts = Sets.newHashSet();
  31.         Collections.addAll(hosts, split);
  32.         jedisClusterFactory.setJedisClusterNodes(hosts);
  33.         return jedisClusterFactory;
  34.     }
  35. }

（二）JedisClusterFactory工厂类

  1. package spring.boot.jpa.redis;
  2. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  3. import org.springframework.beans.factory.FactoryBean;
  4. import org.springframework.beans.factory.InitializingBean;
  5. import redis.clients.jedis.HostAndPort;
  6. import redis.clients.jedis.JedisCluster;
  7. import java.text.ParseException;
  8. import java.util.HashSet;
  9. import java.util.Set;
  11. /** * @Title: JedisClusterFactory * @Description: 工厂类 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
  12. public class JedisClusterFactory implements FactoryBean<JedisCluster>, InitializingBean { 
  13.     private GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
  14.     private JedisCluster jedisCluster;
  15.     private int connectionTimeout = 2000;
  16.     private int soTimeout = 3000;
  17.     private int maxRedirections = 5;
  18.     private Set<String> jedisClusterNodes;
  19.     @Override
  20.     public void afterPropertiesSet() throws Exception { 
  21.         if (jedisClusterNodes == null || jedisClusterNodes.size() == 0) { 
  22.             throw new NullPointerException("jedisClusterNodes is null.");
  23.         }
  24.         Set<HostAndPort> haps = new HashSet<HostAndPort>();
  25.         for (String node : jedisClusterNodes) { 
  26.             String[] arr = node.split(":");
  27.             if (arr.length != 2) { 
  28.                 throw new ParseException("node address error !",node.length()-1);
  29.             }
  30.             haps.add(new HostAndPort(arr[0], Integer.valueOf(arr[1])));
  31.         }
  32.         jedisCluster = new JedisCluster(haps, connectionTimeout, soTimeout, maxRedirections, genericObjectPoolConfig);
  33.     }
  34.     @Override
  35.     public JedisCluster getObject() throws Exception { 
  36.         return jedisCluster;
  37.     }
  38.     @Override
  39.     public Class<?> getObjectType() { 
  40.         return (this.jedisCluster != null ? this.jedisCluster.getClass() : JedisCluster.class);
  41.     }
  42.     @Override
  43.     public boolean isSingleton() { 
  44.         return true;
  45.     }
  47.     public GenericObjectPoolConfig getGenericObjectPoolConfig() { 
  48.         return genericObjectPoolConfig;
  49.     }
  50.     public void setGenericObjectPoolConfig(GenericObjectPoolConfig genericObjectPoolConfig) { 
  51.         this.genericObjectPoolConfig = genericObjectPoolConfig;
  52.     }
  54.     public JedisCluster getJedisCluster() { 
  55.         return jedisCluster;
  56.     }
  58.     public void setJedisCluster(JedisCluster jedisCluster) { 
  59.         this.jedisCluster = jedisCluster;
  60.     }
  62.     public int getConnectionTimeout() { 
  63.         return connectionTimeout;
  64.     }
  66.     public void setConnectionTimeout(int connectionTimeout) { 
  67.         this.connectionTimeout = connectionTimeout;
  68.     }
  70.     public int getSoTimeout() { 
  71.         return soTimeout;
  72.     }
  74.     public void setSoTimeout(int soTimeout) { 
  75.         this.soTimeout = soTimeout;
  76.     }
  78.     public int getMaxRedirections() { 
  79.         return maxRedirections;
  80.     }
  82.     public void setMaxRedirections(int maxRedirections) { 
  83.         this.maxRedirections = maxRedirections;
  84.     }
  86.     public Set<String> getJedisClusterNodes() { 
  87.         return jedisClusterNodes;
  88.     }
  90.     public void setJedisClusterNodes(Set<String> jedisClusterNodes) { 
  91.         this.jedisClusterNodes = jedisClusterNodes;
  92.     }
  93. }

(三) 自定义缓存操作接口ICacheManager

  1. package spring.boot.jpa.redis;
  3. import java.io.Serializable;
  4. import java.util.List;
  5. import java.util.Map;
  7. /** * @Title: ICacheManager * @Description: 缓存接口，定义方法 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
  8. public interface ICacheManager { 
  10.     /** * 根据缓存key获取值 * * @param cacheKey * @return */
  11.     public Object getCache(Serializable cacheKey);
  13.     /** * 设置缓存数据的key-value，并设置失效时间，单位为秒 * * @param cacheKey * @param objValue * @param expiration * @return */
  14.     public boolean putCache(Serializable cacheKey, Object objValue, int expiration);
  16.     /** * 清除缓存 * * @param cacheKey */
  17.     public Long removeCache(Serializable cacheKey);
  19.     /** * 向指定list集合中添加对象，在list尾部添加对象 * * @param cacheKey * @param objValue * @return */
  20.     public boolean putListCache(Serializable cacheKey, Object objValue);
  22.     /** * 向指定list集合中添加对象，并指定位置坐标 * * @param cacheKey * @param objValue * @param index * @return */
  23.     public boolean putListCache(Serializable cacheKey, Object objValue, int index);
  25.     /** * 根据坐标，返回一段集合 * * @param cacheKey * @param start 起始坐标 头部为0 * @param end 结束坐标 尾部为-1 * @return */
  26.     public List<Object> getListCache(Serializable cacheKey, int start, int end);
  28.     /** * 返回结合 * * @param cacheKey * @return */
  29.     public List<Object> getListCache(Serializable cacheKey);
  31.     /** * 裁剪list集合 * * @param cacheKey * @param start 起始坐标 * @param end 结束坐标 * @return */
  32.     public boolean trimListCache(Serializable cacheKey, int start, int end);
  34.     /** * 添加map集合 * * @param cacheKey * @param map * @return */
  35.     public boolean putMapCache(Serializable cacheKey, Map<Object, Object> map);
  37.     /** * 删除map中的键值 * * @param cacheKey * @param mapKey * @return */
  38.     public boolean deleteMapCache(Serializable cacheKey, Serializable mapKey);
  41.     /** * 获取map中的值 * * @param cacheKey * @param mapKey * @return */
  42.     public Object getMapValueCache(Serializable cacheKey, Serializable mapKey);
  43. }

（四）redis客户端实现类JedisCacheManager

  1. package spring.boot.jpa.redis.impl;
  3. import com.alibaba.druid.util.StringUtils;
  4. import org.springframework.stereotype.Service;
  5. import redis.clients.jedis.JedisCluster;
  6. import spring.boot.jpa.redis.ICacheManager;
  7. import spring.boot.jpa.redis.SerializingUtil;
  9. import javax.annotation.Resource;
  10. import java.io.Serializable;
  11. import java.util.ArrayList;
  12. import java.util.HashMap;
  13. import java.util.List;
  14. import java.util.Map;
  15. import java.util.Map.Entry;
  17. /** * @Title: JedisCacheManager * @Description: 接口实现 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
  18. @Service("iCacheManager")
  19. public class JedisCacheManager implements ICacheManager { 
  21.     private static final String JEDIS_SET_RETURN_OK = "OK";
  23.     @Resource
  24.     private JedisCluster jedisCluster;
  26.     @Override
  27.     public Object getCache(Serializable cacheKey) { 
  28.         return SerializingUtil.deserialize((byte[]) jedisCluster.get(SerializingUtil.serialize(cacheKey)));
  29.     }
  31.     @Override
  32.     public boolean putCache(Serializable cacheKey, Object objValue, int expiration) { 
  33.         String result = jedisCluster.setex(SerializingUtil.serialize(cacheKey), expiration, SerializingUtil.serialize(objValue));
  34.         if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) { 
  35.             return true;
  36.         }
  37.         return false;
  38.     }
  40.     @Override
  41.     public Long removeCache(Serializable cacheKey) { 
  42.         return jedisCluster.del(SerializingUtil.serialize(cacheKey));
  43.     }
  45.     @Override
  46.     public boolean putListCache(Serializable cacheKey, Object objValue) { 
  47.         Long num = jedisCluster.rpush(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(objValue));
  48.         if (num > 0) { 
  49.             return true;
  50.         }
  51.         return false;
  52.     }
  54.     @Override
  55.     public boolean putListCache(Serializable cacheKey, Object objValue, int index) { 
  56.         String result = jedisCluster.lset(SerializingUtil.serialize(cacheKey), index, SerializingUtil.serialize(objValue));
  57.         if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) { 
  58.             return true;
  59.         }
  60.         return false;
  61.     }
  63.     @Override
  64.     public List<Object> getListCache(Serializable cacheKey, int start, int end) { 
  65.         List<byte[]> list = jedisCluster.lrange(SerializingUtil.serialize(cacheKey), start, end);
  66.         if (null != list && list.size() > 0) { 
  67.             List<Object> objList = new ArrayList<Object>();
  68.             for (byte[] b : list) { 
  69.                 objList.add(SerializingUtil.deserialize(b));
  70.             }
  71.             return objList;
  72.         }
  73.         return null;
  74.     }
  76.     @Override
  77.     public List<Object> getListCache(Serializable cacheKey) { 
  78.         return getListCache(cacheKey, 0, -1);
  79.     }
  81.     @Override
  82.     public boolean trimListCache(Serializable cacheKey, int start, int end) { 
  83.         String result = jedisCluster.ltrim(SerializingUtil.serialize(cacheKey), start, end);
  84.         if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) { 
  85.             return true;
  86.         }
  87.         return false;
  88.     }
  90.     @Override
  91.     public boolean putMapCache(Serializable cacheKey, Map<Object, Object> map) { 
  92.         if (null != map && !map.isEmpty()) { 
  93.             Map<byte[], byte[]> byteMap = new HashMap<byte[], byte[]>();
  94.             for (Entry<Object, Object> entry : map.entrySet()) { 
  95.                 byteMap.put(SerializingUtil.serialize(entry.getKey()), SerializingUtil.serialize(entry.getValue()));
  96.             }
  97.             String result = jedisCluster.hmset(SerializingUtil.serialize(cacheKey), byteMap);
  98.             if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) { 
  99.                 return true;
  100.             }
  101.             return true;
  102.         }
  103.         return false;
  104.     }
  106.     @Override
  107.     public boolean deleteMapCache(Serializable cacheKey, Serializable mapKey) { 
  108.         Long result = jedisCluster.hdel(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(mapKey));
  109.         if (result > 0) { 
  110.             return true;
  111.         }
  112.         return false;
  113.     }
  116.     @Override
  117.     public Object getMapValueCache(Serializable cacheKey, Serializable mapKey) { 
  118.         List<byte[]> list = jedisCluster.hmget(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(mapKey));
  119.         if (null != list && list.size() > 0) { 
  120.             return SerializingUtil.deserialize(list.get(0));
  121.         }
  122.         return null;
  123.     }
  125. }

(五) 序列化工具类

  1. package spring.boot.jpa.redis;
  2. import org.apache.log4j.Logger;
  3. import org.springframework.cache.CacheManager;
  4. import java.io.*;
  5. /** * @Title: SerializingUtil * @Package: org.tdcg.util * @Description: 序列化工具类，负责byte[]和Object之间的相互转换. * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
  6. public class SerializingUtil { 
  8.     private static final Logger logger = Logger.getLogger(CacheManager.class);
  10.     /** * 功能简述: 对实体Bean进行序列化操作. * * @param source 待转换的实体 * @return 转换之后的字节数组 * @throws Exception */
  11.     public static byte[] serialize(Object source) { 
  12.         ByteArrayOutputStream byteOut = null;
  13.         ObjectOutputStream ObjOut = null;
  14.         try { 
  15.             byteOut = new ByteArrayOutputStream();
  16.             ObjOut = new ObjectOutputStream(byteOut);
  17.             ObjOut.writeObject(source);
  18.             ObjOut.flush();
  19.         } catch (IOException e) { 
  20.             logger.error(source.getClass().getName() + " serialized error !", e);
  21.         } finally { 
  22.             try { 
  23.                 if (null != ObjOut) { 
  24.                     ObjOut.close();
  25.                 }
  26.             } catch (IOException e) { 
  27.                 ObjOut = null;
  28.             }
  29.         }
  30.         return byteOut.toByteArray();
  31.     }
  33.     /** * 功能简述: 将字节数组反序列化为实体Bean. * * @param source 需要进行反序列化的字节数组 * @return 反序列化后的实体Bean * @throws Exception */
  34.     public static Object deserialize(byte[] source) { 
  35.         ObjectInputStream ObjIn = null;
  36.         Object retVal = null;
  37.         try { 
  38.             ByteArrayInputStream byteIn = new ByteArrayInputStream(source);
  39.             ObjIn = new ObjectInputStream(byteIn);
  40.             retVal = ObjIn.readObject();
  41.         } catch (Exception e) { 
  42.             logger.error("deserialized error !", e);
  43.         } finally { 
  44.             try { 
  45.                 if (null != ObjIn) { 
  46.                     ObjIn.close();
  47.                 }
  48.             } catch (IOException e) { 
  49.                 ObjIn = null;
  50.             }
  51.         }
  52.         return retVal;
  53.     }
  54. }

(五) 测试类

  1. package spring.boot.jpa;
  4. import com.google.common.collect.Maps;
  5. import org.junit.FixMethodOrder;
  6. import org.junit.Test;
  7. import org.junit.runner.RunWith;
  8. import org.junit.runners.MethodSorters;
  9. import org.springframework.boot.test.context.SpringBootTest;
  10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  11. import spring.boot.jpa.entity.User;
  12. import spring.boot.jpa.redis.impl.JedisCacheManager;
  14. import javax.annotation.Resource;
  15. import java.util.List;
  16. import java.util.Map;
  19. /** * @Title: JedisCacheManagerTest * @Description: 测试类，测试方法有顺序要求 * 添加@FixMethodOrder(MethodSorters.NAME_ASCENDING) 以使执行方法按名称顺序执行 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
  20. //Junit4运行环境
  21. @RunWith(SpringJUnit4ClassRunner.class)
  22. //单元测试时需要执行的SpringBoot启动类（根据需要引入执行）
  23. @SpringBootTest(classes={ JpaApplication.class})// 指定启动类
  24. @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  25. //如果是Web项目，Junit需要模拟ServletContext获取web等配置
  26. //@WebAppConfiguration
  27. public class JedisCacheManagerTest { 
  29.     private final int expiration = 3600;
  31.     @Resource
  32.     private JedisCacheManager jedisCacheManager;
  34.     @Test
  35.     public void testAPutCache() throws Exception { 
  36.         boolean test = jedisCacheManager.putCache("test", "welocme redis cluster! created by tdcg!", expiration);
  37.         assert(test);
  38.     }
  39.     @Test
  40.     public void testBGetCache() throws Exception { 
  41.         Object test = jedisCacheManager.getCache("test");
  42.         System.out.println(test);
  43.         assert(test.equals("welocme redis cluster! created by tdcg!"));
  44.     }
  45.     @Test
  46.     public void testCRemoveCache() throws Exception { 
  47.         Long test = jedisCacheManager.removeCache("test");
  48.         assert(test == 1L);
  49.     }
  50.  }

至此redis集群代码层面基本实现，仅供参考，欢迎指教！！！！！！

发表评论

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

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

相关阅读

    相关 redis-cluster集群搭建

    今天简单介绍一下redis-cluster集群搭建。 redis 最开始的时候，为了实现高可用，使用的主从模式，主从的模式的缺点是，一旦主挂了，没有办法自动的将“从 ”切换为“

    谁践踏了优雅谁践踏了优雅/ 0 赞/ 90 阅读