SpringBoot项目接入Redis集群

本文转载自微信公众号「Java极客技术」，作者鸭血粉丝。转载本文请联系Java极客技术公众号。

在成都网站建设、成都网站设计中从网站色彩、结构布局、栏目设置、关键词群组等细微处着手，突出企业的产品/服务/品牌，帮助企业锁定精准用户，提高在线咨询和转化，使成都网站营销成为有效果、有回报的无锡营销推广。创新互联专业成都网站建设十载了，客户满意度97.8%，欢迎成都创新互联客户联系。

Hello 大家好，我是鸭血粉丝，Redis 想必大家一定不会陌生，平常工作中或多或少都会用到，不管是用来存储登录信息还是用来缓存热点数据，对我们来说都是很有帮助的。但是 Redis 的集群估计并不是每个人都会用到，因为很多业务场景或者系统都是一些简单的管理系统，并不会需要用到 Redis 的集群环境。

阿粉之前也是这样，项目中用的的 Redis 是个单机环境，但是最近随着终端量的上升，慢慢的发现单机已经快支撑不住的，所以思考再三决定将 Redis 的环境升级成集群。下面阿粉给大家介绍一下在升级的过程中项目中需要调整的地方，这篇文章不涉及集群的搭建和配置，感兴趣的同学自行搜索。

配置参数

因为这篇文章不介绍 Redis 集群的搭建，这里我们假设已经有了一个 Redis 的集群环境，我们项目中需要调整以下几个部分

修改配置参数，集群的节点和密码配置;
确保引入的 Jedis 版本支持设置密码，spring-data-redis 1.8 以上，SpringBoot 1.5 以上才支持设置密码;
注入 RedisTemplate;
编写工具类;

修改配置参数

 
 
 
  
  
  ############### Redis 集群配置 #########################   
  
  spring.custome.redis.cluster.nodes=172.20.0.1:7001,172.20.0.2:7002,172.20.0.3:7003   
  
  spring.custome.redis.cluster.max-redirects=3   
  
  spring.custome.redis.cluster.max-active=500   
  
  spring.custome.redis.cluster.max-wait=-1   
  
  spring.custome.redis.cluster.max-idle=500   
  
  spring.custome.redis.cluster.min-idle=20   
  
  spring.custome.redis.cluster.timeout=3000   
  
  spring.custome.redis.cluster.password=redis.cluster.password

引入依赖(如果需要)

确保 SpringBoot 的版本大于 1.4.x 如果不是的话，采用如下配置，先排除 SpringBoot 中旧版本 Jedis 和 spring-data-redis，再依赖高版本的 Jedis 和 spring-data-redis。

 
 
 
  
  
     
  
              org.springframework.boot   
  
              spring-boot-starter-data-redis   
  
                 
  
                 
  
                     
  
                      redis.clients   
  
                      jedis   
  
                     
  
                     
  
                      org.springframework.data   
  
                      spring-data-redis   
  
                     
  
                 
  
             
  
             
  
             
  
              redis.clients   
  
              jedis   
  
              2.9.0   
  
             
  
             
  
              org.springframework.data   
  
              spring-data-redis   
  
              1.8.0.RELEASE

注入 RedisTemplate

注入 RedisTemplate 我们需要三个组件，分别是JedisConnectionFactory 、RedisClusterConfiguration、JedisPoolConfig，下面是注入RedisTempalte 的代码。先根据配置创建 JedisConnectFactory 同时需要配置 RedisClusterConfiguration、JedisPoolConfig，最后将JedisConnectionFactory 返回用于创建RedisTemplate

 
 
 
  
  
  import com.fasterxml.jackson.annotation.JsonAutoDetect;   
  
  import com.fasterxml.jackson.annotation.PropertyAccessor;   
  
  import com.fasterxml.jackson.databind.ObjectMapper;   
  
  import org.apache.commons.pool2.impl.GenericObjectPoolConfig;   
  
  import org.springframework.beans.factory.annotation.Value;   
  
  import org.springframework.context.annotation.Bean;   
  
  import org.springframework.context.annotation.Primary;   
  
  import org.springframework.data.redis.connection.RedisClusterConfiguration;   
  
  import org.springframework.data.redis.connection.RedisNode;   
  
  import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;   
  
  import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;   
  
  import org.springframework.data.redis.core.RedisTemplate;   
  
  import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;   
  
  import org.springframework.data.redis.serializer.StringRedisSerializer;   
  
     
  
  import java.time.Duration;   
  
  import java.util.ArrayList;   
  
  import java.util.List;   
  
     
  
  public class RedisClusterConfig {   
  
     
  
      @Bean(name = "redisTemplate")   
  
      @Primary   
  
      public RedisTemplate redisClusterTemplate(@Value("${spring.custome.redis.cluster.nodes}") String host,   
  
                                       @Value("${spring.custome.redis.cluster.password}") String password,   
  
                                       @Value("${spring.custome.redis.cluster.timeout}") long timeout,   
  
                                       @Value("${spring.custome.redis.cluster.max-redirects}") int maxRedirect,   
  
                                       @Value("${spring.custome.redis.cluster.max-active}") int maxActive,   
  
                                       @Value("${spring.custome.redis.cluster.max-wait}") int maxWait,   
  
                                       @Value("${spring.custome.redis.cluster.max-idle}") int maxIdle,   
  
                                       @Value("${spring.custome.redis.cluster.min-idle}") int minIdle) {   
  
     
  
          JedisConnectionFactory connectionFactory =  jedisClusterConnectionFactory(host, password,   
  
                  timeout, maxRedirect, maxActive, maxWait, maxIdle, minIdle);   
  
          return createRedisClusterTemplate(connectionFactory);   
  
      }   
  
     
  
      private JedisConnectionFactory jedisClusterConnectionFactory(String host, String password,   
  
                                                                     long timeout, int maxRedirect, int maxActive, int maxWait, int maxIdle, int minIdle) {   
  
          RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();   
  
          List nodeList = new ArrayList<>();   
  
          String[] cNodes = host.split(",");   
  
          //分割出集群节点   
  
          for (String node : cNodes) {   
  
              String[] hp = node.split(":");   
  
              nodeList.add(new RedisNode(hp[0], Integer.parseInt(hp[1])));   
  
          }   
  
          redisClusterConfiguration.setClusterNodes(nodeList);   
  
          redisClusterConfiguration.setPassword(password);   
  
          redisClusterConfiguration.setMaxRedirects(maxRedirect);   
  
     
  
          // 连接池通用配置   
  
          GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();   
  
          genericObjectPoolConfig.setMaxIdle(maxIdle);   
  
          genericObjectPoolConfig.setMaxTotal(maxActive);   
  
          genericObjectPoolConfig.setMinIdle(minIdle);   
  
          genericObjectPoolConfig.setMaxWaitMillis(maxWait);   
  
          genericObjectPoolConfig.setTestWhileIdle(true);   
  
          genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(300000);   
  
     
  
          JedisClientConfiguration.DefaultJedisClientConfigurationBuilder builder = (JedisClientConfiguration.DefaultJedisClientConfigurationBuilder) JedisClientConfiguration   
  
                  .builder();   
  
          builder.connectTimeout(Duration.ofSeconds(timeout));   
  
          builder.usePooling();   
  
          builder.poolConfig(genericObjectPoolConfig);   
  
          JedisConnectionFactory connectionFactory = new JedisConnectionFactory(redisClusterConfiguration, builder.build());   
  
          // 连接池初始化   
  
          connectionFactory.afterPropertiesSet();   
  
     
  
          return connectionFactory;   
  
      }   
  
     
  
      private RedisTemplate createRedisClusterTemplate(JedisConnectionFactory redisConnectionFactory) {   
  
          RedisTemplate redisTemplate = new RedisTemplate<>();   
  
          redisTemplate.setConnectionFactory(redisConnectionFactory);   
  
     
  
          Jackson2JsonRedisSerializer