依赖

  1.         <dependency>
  2.             <groupId>org.projectlombok</groupId>
  3.             <artifactId>lombok</artifactId>
  4.             <version>1.18.12</version>
  5.         </dependency>
  6.         <!--redis 客户端-->
  7.         <dependency>
  8.             <groupId>redis.clients</groupId>
  9.             <artifactId>jedis</artifactId>
  10.         </dependency>
  11.         <!--自定义序列化-->
  12.         <dependency>
  13.             <groupId>com.fasterxml.jackson.core</groupId>
  14.             <artifactId>jackson-databind</artifactId>
  15.         </dependency>
  16.         <!--属性配置支持-->
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-configuration-processor</artifactId>
  20.             <optional>true</optional>
  21.         </dependency>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-data-redis</artifactId>
  26.         </dependency>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-test</artifactId>
  31.             <scope>test</scope>
  32.             <exclusions>
  33.                 <exclusion>
  34.                     <groupId>org.junit.vintage</groupId>
  35.                     <artifactId>junit-vintage-engine</artifactId>
  36.                 </exclusion>
  37.             </exclusions>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>junit</groupId>
  41.             <artifactId>junit</artifactId>
  42.             <version>4.12</version>
  43.             <scope>test</scope>
  44.         </dependency>

application.yml

  1. spring:
  2.   application:
  3.     name: spring-boot-redis-cluster
  4.   redis:
  5.     cluster:
  6.       nodes: *:7001,*:7002,*:7003,*:7004,*:7005,*:7006
  7.       max-redirects: 6
  8. redis:
  9.   timeout: 10000 #客户端超时时间单位是毫秒 默认是2000
  10.   maxIdle: 300 #最大空闲数
  11.   maxTotal: 1000 #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
  12.   maxWaitMillis: 1000 #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
  13.   minEvictableIdleTimeMillis: 300000 #连接的最小空闲时间 默认1800000毫秒(30分钟)
  14.   numTestsPerEvictionRun: 1024 #每次释放连接的最大数目,默认3
  15.   timeBetweenEvictionRunsMillis: 30000 #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
  16.   testOnBorrow: true #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
  17.   testWhileIdle: true #在空闲时检查有效性, 默认false
  18.   password: 123456 #密码

RedisCluster配置类

  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import lombok.Data;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.connection.RedisClusterConfiguration;
  9. import org.springframework.data.redis.connection.RedisNode;
  10. import org.springframework.data.redis.connection.RedisPassword;
  11. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  14. import org.springframework.data.redis.serializer.StringRedisSerializer;
  15. import redis.clients.jedis.JedisPoolConfig;
  16. import java.util.HashSet;
  17. import java.util.Set;
  19. /**
  20.  * @author liuhui
  21.  * @title: RedisConfig
  22.  * @projectName study
  23.  * @description: redis 配置类
  24.  * @date 2021/4/2811:29
  25.  */
  26. @Configuration
  27. @Data
  28. public class RedisClusterConfig {
  29.     @Value("${spring.redis.cluster.nodes}")
  30.     private String clusterNodes;
  31.     @Value("${spring.redis.cluster.max-redirects}")
  32.     private int maxRedirects;
  33.     @Value("${redis.password}")
  34.     private String password;
  35.     @Value("${redis.timeout}")
  36.     private int timeout;
  37.     @Value("${redis.maxIdle}")
  38.     private int maxIdle;
  39.     @Value("${redis.maxTotal}")
  40.     private int maxTotal;
  41.     @Value("${redis.maxWaitMillis}")
  42.     private int maxWaitMillis;
  43.     @Value("${redis.minEvictableIdleTimeMillis}")
  44.     private int minEvictableIdleTimeMillis;
  45.     @Value("${redis.numTestsPerEvictionRun}")
  46.     private int numTestsPerEvictionRun;
  47.     @Value("${redis.timeBetweenEvictionRunsMillis}")
  48.     private int timeBetweenEvictionRunsMillis;
  49.     @Value("${redis.testOnBorrow}")
  50.     private boolean testOnBorrow;
  51.     @Value("${redis.testWhileIdle}")
  52.     private boolean testWhileIdle;
  55.     /**
  56.      * Redis连接池的配置
  57.      *
  58.      * @return JedisPoolConfig
  59.      */
  60.     @Bean
  61.     public JedisPoolConfig getJedisPoolConfig() {
  62.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  63.         // 最大空闲数
  64.         jedisPoolConfig.setMaxIdle(maxIdle);
  65.         // 连接池的最大数据库连接数
  66.         jedisPoolConfig.setMaxTotal(maxTotal);
  67.         // 最大建立连接等待时间
  68.         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
  69.         // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
  70.         jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
  71.         // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
  72.         jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
  73.         // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
  74.         jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
  75.         // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
  76.         jedisPoolConfig.setTestOnBorrow(testOnBorrow);
  77.         // 在空闲时检查有效性, 默认false
  78.         jedisPoolConfig.setTestWhileIdle(testWhileIdle);
  79.         return jedisPoolConfig;
  80.     }
  83.     /**
  84.      * Redis集群的配置
  85.      *
  86.      * @return RedisClusterConfiguration
  87.      */
  88.     @Bean
  89.     public RedisClusterConfiguration redisClusterConfiguration() {
  90.         RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
  91.         // Set<RedisNode> clusterNodes
  92.         System.out.println(clusterNodes);
  93.         String[] serverArray = clusterNodes.split(",");
  94.         Set<RedisNode> nodes = new HashSet<RedisNode>();
  95.         for (String ipPort : serverArray) {
  96.             String[] ipAndPort = ipPort.split(":");
  97.             nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
  98.         }
  99.         redisClusterConfiguration.setClusterNodes(nodes);
  100.         redisClusterConfiguration.setMaxRedirects(maxRedirects);
  101.         redisClusterConfiguration.setPassword(RedisPassword.of(password));
  102.         return redisClusterConfiguration;
  103.     }
  105.     /**
  106.      * redis连接工厂类
  107.      *
  108.      * @return JedisConnectionFactory
  109.      */
  110.     @Bean
  111.     public JedisConnectionFactory jedisConnectionFactory() {
  112.         // 集群模式
  113.         JedisConnectionFactory factory = new JedisConnectionFactory(redisClusterConfiguration(), getJedisPoolConfig());
  114.         return factory;
  115.     }
  118.     /**
  119.      * 实例化 RedisTemplate 对象
  120.      *
  121.      * @return RedisTemplate<String, Object>
  122.      */
  123.     @Bean
  124.     public RedisTemplate<String, Object> redisTemplate() {
  125.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  126.         // Template初始化
  127.         initDomainRedisTemplate(redisTemplate);
  128.         return redisTemplate;
  129.     }
  131.     /**
  132.      * 设置数据存入 redis 的序列化方式 使用默认的序列化会导致key乱码
  133.      */
  134.     private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
  135.         // 开启redis数据库事务的支持
  136.         redisTemplate.setEnableTransactionSupport(true);
  137.         redisTemplate.setConnectionFactory(jedisConnectionFactory());
  139.         // 如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to
  140.         // String！
  141.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  142.         redisTemplate.setKeySerializer(stringRedisSerializer);
  143.         // hash的key也采用String的序列化方式
  144.         redisTemplate.setHashKeySerializer(stringRedisSerializer);
  146.         // jackson序列化对象设置
  147.         Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(
  148.                 Object.class);
  149.         ObjectMapper om = new ObjectMapper();
  150.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  151.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  152.         jackson2JsonRedisSerializer.setObjectMapper(om);
  154.         // value序列化方式采用jackson
  155.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  156.         // hash的value序列化方式采用jackson
  157.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  159.         redisTemplate.afterPropertiesSet();
  160.     }
  161. }