SpringBoot RedisConfig配置standalone、cluster、sentinel模式

• 一、简介
• 二、代码
• • 2.1 依赖
  • 2.2 YML配置文件
  • 2.3 RedisConfig

使用RedisConfig配置类的方式进行Redis standalone（单节点）、cluster（主从集群）、sentinel（哨兵集群）的灵活配置。

 
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            org.apache.commons
            commons-pool2
        
        
        
            redis.clients
            jedis
            3.6.3
        

        
            org.projectlombok
            lombok
            1.16.10
        
        
        
            commons-io
            commons-io
            2.4
        
        
        
            commons-lang
            commons-lang
            2.6
        

application.yml

spring:
  profiles:
    active: standalone
#    active: cluster
#    active: sentinel

application-cluster.yml

server:
  port: 8080
  servlet:
    context-path: /testRedis
spring:
  application:
    name: TestRedis
  redis:
    database: 0
    lettuce:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0
    # Redis Cluster 集群配置
    cluster:
      nodes:
        - 192.168.184.58:7000
        - 192.168.184.58:7001
        - 192.168.184.58:7002
        - 192.168.184.59:7000
        - 192.168.184.59:7001
        - 192.168.184.59:7002
      max-redirects: 3
    password: 
    timeout: 5000
# Redis连接池配置
jedis:
  pool:
    config:
      maxTotal: 100
      maxWaitMillis: 5000
      maxIdle: 10

application-sentinel.yml

server:
  port: 8080
  servlet:
    context-path: /testRedis
spring:
  application:
    name: TestRedis
  redis:
    sentinel:
      master:
      nodes:
    password:

application-standalone.yml

server:
  port: 8080
  servlet:
    context-path: /testRedis
spring:
  application:
    name: TestRedis
  redis:
    host: localhost
    lettuce:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0
    port: 7000
    password: 123456
# Redis连接池配置
jedis:
  pool:
    config:
      maxTotal: 200
      maxWaitMillis: 5000
      maxIdle: 100

package com.haobai.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.*;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import redis.clients.jedis.JedisPoolConfig;

import java.util.ArrayList;
import java.util.List;


@Slf4j
@Configuration
public class RedisConfig {

    
    @Bean(name = "RedisConnectionFactory")
    public RedisConnectionFactory connectionFactory(RedisProperties properties){
        //Jedis连接工厂 JedisConnectionFactory是RedisConnectionFactory子类
        JedisConnectionFactory factory;
        //RedisSentinelConfiguration 是 RedisConfiguration 的子类
        RedisSentinelConfiguration sentinelConfig = getSentinelConfiguration(properties);
        RedisClusterConfiguration clusterConfiguration = getClusterConfiguration(properties);
        if (sentinelConfig != null) {
            log.info("Redis Sentinel 集群配置...");
            factory = new JedisConnectionFactory(sentinelConfig);
        } else if (clusterConfiguration != null) {
            log.info("Redis Cluster 集群配置...");
            factory = new JedisConnectionFactory(clusterConfiguration);
        } else {
            log.info("Redis Standalone单节点配置...");
            RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
            redisStandaloneConfiguration.setHostName(properties.getHost());
            redisStandaloneConfiguration.setPort(properties.getPort());
            redisStandaloneConfiguration.setPassword(properties.getPassword());
            factory = new JedisConnectionFactory(redisStandaloneConfiguration);
        }

        return factory;
    }

    
    private RedisClusterConfiguration getClusterConfiguration(RedisProperties properties) {
        RedisProperties.Cluster cluster = properties.getCluster();

        if (cluster != null) {
            RedisClusterConfiguration config = new RedisClusterConfiguration(cluster.getNodes());
            if (properties.getPassword() != null){
                config.setPassword(properties.getPassword());
            }
            if (cluster.getMaxRedirects() != null) {
                config.setMaxRedirects(cluster.getMaxRedirects());
            }
            return config;
        }
        return null;
    }

    
    private RedisSentinelConfiguration getSentinelConfiguration(RedisProperties properties) {
        RedisProperties.Sentinel sentinel = properties.getSentinel();
        if (sentinel != null) {
            RedisSentinelConfiguration config = new RedisSentinelConfiguration();
            config.master(sentinel.getMaster());
            config.setSentinels(createSentinels(sentinel));
            if (properties.getPassword() != null){
                config.setPassword(properties.getPassword());
            }
            return config;
        }
        return null;
    }

    
    private static List createSentinels(RedisProperties.Sentinel sentinel) {
        List nodes = new ArrayList<>();
//        for (String node : StringUtils.commaDelimitedListToStringArray(sentinel.getNodes())) {
        for (String node : sentinel.getNodes()) {
            String[] parts = StringUtils.split(node, ":");
            Assert.state(parts.length == 2, "redis哨兵地址配置不合法！");
            nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1])));
        }
        return nodes;
    }

    @Bean(name = "RedisTemplate")
    public RedisTemplate redisTemplate(@Qualifier("RedisConnectionFactory") RedisConnectionFactory redisConnectionFactory) {


        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);


        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new StringRedisSerializer());

        return template;
    }
    @Bean(name = "StringRedisTemplate")
    public StringRedisTemplate StringRedisTemplate(@Qualifier("RedisConnectionFactory") RedisConnectionFactory redisConnectionFactory) {

        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate(redisConnectionFactory);

        return stringRedisTemplate;
    }

    
    @Bean(name = "JedisPoolConfig")
    public JedisPoolConfig jedisPoolConfig(@Value("${jedis.pool.config.maxTotal:100}") int maxTotal,
                                           @Value("${jedis.pool.config.maxWaitMillis:5000}") int maxWaitMillis,
                                           @Value("${jedis.pool.config.maxIdle:10}") int maxIdle) {
        log.info("Redis连接池配置...");
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxTotal);
        config.setMaxIdle(maxIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        return config;
    }

}