SpringBoot2.x 整合Redis 哨兵模式

SpringBoot2.0 默认使用Lettuce作为Redis客户端，在使用Lettuce时，需要额外引入commons-pool2包。创建一个SpringBoot2.x 项目之后，引入commons-pool2包。

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.6.2</version>
    </dependency>

配置Redis和Lettuce

spring:
    host: 127.0.0.1
    port: 6380
    password: test
    timeout: 6000
    lettuce:
      pool:
        # 连接池最大连接数
        max-active: 64
        # 连接池最大空闲连接
        max-idle: 32
        # 连接池最小空闲连接
        min-idle: 16
        # 最大阻塞时间
        max-wait: 3000
    sentinel:
      master: master-redis
      nodes: 127.0.0.1:26379,127.0.0.1:26380,127.0.0.1:26381

Spring容器启动时，由于spring-boot-autoconfigure包中spring.factories文件中的配置，会自动装配RedisAutoConfiguration类。
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration\

RedisAutoConfiguration类源码比较简单，只是在自动注入时，先将Redis配置注入RedisProperties类，再实例化LettuceConnectionConfiguration类，最后在Miss RedisTemplate时创建两个RedisTemplate实例。

@Configuration(
    proxyBeanMethods = false
)
//spring-boot-starter-redis中已引入
@ConditionalOnClass({RedisOperations.class})
//将配置注入Properties类
@EnableConfigurationProperties({RedisProperties.class})
//默认仅创建LettuceConnectionConfiguration Bean，Jedis缺少包
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

在没有自定义Redis连接池时，创建RedisConnectionFactory

	@Bean
	@ConditionalOnMissingBean(RedisConnectionFactory.class)
	LettuceConnectionFactory redisConnectionFactory(
			ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
			ClientResources clientResources) throws UnknownHostException {
		LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(builderCustomizers, clientResources,
				getProperties().getLettuce().getPool());
		return createLettuceConnectionFactory(clientConfig);
	}

LettuceClient装配时，readFrom默认为空，若需要配置读写分离，则需要将其重写设置为readFrom = REPLICA_PREFERRED，表明读取从从库中操作。

	private LettuceClientConfiguration getLettuceClientConfiguration(
			ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
			ClientResources clientResources, Pool pool) {
		LettuceClientConfigurationBuilder builder = createBuilder(pool);
		applyProperties(builder);
		if (StringUtils.hasText(getProperties().getUrl())) {
			customizeConfigurationFromUrl(builder);
		}
		builder.clientOptions(initializeClientOptionsBuilder().timeoutOptions(TimeoutOptions.enabled()).build());
		builder.clientResources(clientResources);
		builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
		return builder.build();
	}

根据配置决定为Standalone、Sentinel、Cluster模式

	private LettuceConnectionFactory createLettuceConnectionFactory(LettuceClientConfiguration clientConfiguration) {
		if (getSentinelConfig() != null) {
			return new LettuceConnectionFactory(getSentinelConfig(), clientConfiguration);
		}
		if (getClusterConfiguration() != null) {
			return new LettuceConnectionFactory(getClusterConfiguration(), clientConfiguration);
		}
		return new LettuceConnectionFactory(getStandaloneConfig(), clientConfiguration);
	}