java 连接redis 4中模式 单机 主从 哨兵 集群

import cn.hutool.core.util.StrUtil;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.*;
import org.redisson.spring.data.connection.RedissonConnectionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;

@Configuration
public class RedissonConfig {

  @Value("${spring.data.redis.mode:single}")
  private String mode;

  @Value("${spring.data.redis.host:localhost}")
  private String host;

  @Value("${spring.data.redis.port:6379}")
  private Integer port;

  @Value("${spring.data.redis.password:}")
  private String password;

  @Value("${spring.data.redis.database:0}")
  private Integer database;

  @Value("${spring.data.redis.timeout:10000}")
  private int timeout;

  @Value("${spring.data.redis.connection:100}")
  private int connectionPoolSize;

  @Value("${spring.data.redis.idle-timeout:10000}")
  private int idleTimeout;

  @Value("${spring.data.redis.master-name:mymaster-test}")
  private String masterName;

  @Value("${spring.data.redis.readmode:SLAVE}")
  private String readMode;

  @Value("${spring.data.redis.slaveHost:}")
  private String slaveHost;

  @Value("${spring.data.redis.ping-connection-interval:10000}")
  private int pingConnectionInterval;

  @Value("${spring.data.redis.transportMode:NIO}")
  private String transportMode;

  private static String redisPre = "redis://";

  @Bean(name = "redisTemplate")
  @Primary
  public RedisTemplate<?, ?> redisTemplate() {
    RedisTemplate<?, ?> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(redissonConnectionFactory());

    //setup key serieler rule
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setKeySerializer(new StringRedisSerializer());

    return redisTemplate;
  }

  private RedisConnectionFactory redissonConnectionFactory() {
    return new RedissonConnectionFactory(redissonClient());
  }


  @Bean
  public RedissonClient redissonClient() {
    Config config = new Config();
    config.setTransportMode(TransportMode.valueOf(transportMode));
    BaseConfig<?> baseConfig;
    if ("cluster".equals(mode)) {
      ClusterServersConfig clusterServersConfig = config.useClusterServers();
      clusterServersConfig.setNodeAddresses(hostConvertRedisHost(host));
      clusterServersConfig.setScanInterval(2000);
      baseConfig = clusterServersConfig;
    } else if ("sentinel".equals(mode)) {
      SentinelServersConfig sentinelServersConfig = config.useSentinelServers();
      sentinelServersConfig.setSentinelAddresses(hostConvertRedisHost(host));
      sentinelServersConfig.setMasterName(masterName);
      sentinelServersConfig.setDatabase(database);
      sentinelServersConfig.setMasterConnectionPoolSize(connectionPoolSize);
      sentinelServersConfig.setSlaveConnectionPoolSize(connectionPoolSize);
      sentinelServersConfig.setReadMode(ReadMode.valueOf(readMode));
      baseConfig = sentinelServersConfig;
    } else if("master".equals(mode)){
      MasterSlaveServersConfig masterSlaveServersConfig = config.useMasterSlaveServers();
      masterSlaveServersConfig.setDatabase(database);
      masterSlaveServersConfig.setMasterAddress(formatAddress(host, port));
      masterSlaveServersConfig.setSlaveAddresses(Set.copyOf(hostConvertRedisHost(slaveHost)));
      masterSlaveServersConfig.setMasterConnectionPoolSize(connectionPoolSize);
      masterSlaveServersConfig.setSlaveConnectionPoolSize(connectionPoolSize);
      masterSlaveServersConfig.setReadMode(ReadMode.valueOf(readMode));
      baseConfig = masterSlaveServersConfig;
    }else {
      SingleServerConfig singleServerConfig = config.useSingleServer();
      singleServerConfig.setAddress(formatAddress(host, port));
      singleServerConfig.setDatabase(database);
      baseConfig = singleServerConfig;
    }
    if (!password.isBlank()) {
      baseConfig.setPassword(password);
    }
    baseConfig.setTimeout(timeout);
    baseConfig.setPingConnectionInterval(pingConnectionInterval);
    baseConfig.setIdleConnectionTimeout(idleTimeout);
    return Redisson.create(config);
  }

  private static String formatAddress(String host, int port) {
    return redisPre + host + ":" + port;
  }

  private List<String> hostConvertRedisHost(String host){
    if(StrUtil.isBlank(host)){
      return Collections.emptyList();
    }
    String[] singleHosts = host.split(";");
    List<String> hostList = new ArrayList<>(singleHosts.length);
    for (String singleHost : singleHosts) {
      String address = formatAddress(singleHost, port);
      hostList.add(address);
    }
    return hostList;
  }
}