redis配置哨兵模式，以及获取数据源

启用主从配置
redis.conf配置

启用哨兵模式
sentinel.conf 配置

获取数据源
pom添加依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.1</version>
</dependency>
<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
</dependency>
<dependency>
	<groupId>org.apache.commons</groupId>
	<artifactId>commons-lang3</artifactId>
	<version>3.8.1</version>
</dependency>
<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>26.0-jre</version>
	<scope>compile</scope>
</dependency>
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.28</version>
</dependency>

yml配置文件

spring:
  redis:
    password: 123456
    sentinel:
      #从节点集合(哨兵IP：端口)以逗号分隔
      nodes: 192.168.1.1:6379,192.168.1.2:6380
      #与Redis环境配置的保持一致
      master: mymaster
    jedis:
      pool:
        #jedis最大分配对象
        maxTotal: 1024
        #jedis最大保存idel状态对象数
        maxIdle: 200
        #jedis池没有对象返回时，最大等待时间
        maxWaitMillis: 10000
        testOnBorrow: true
        testOnReturn: true
        blockWhenExhausted: false
        #Idle时进行连接扫描
        testWhileIdle: true
        #表示idle object evitor两次扫描之间要sleep的毫秒数
        timeBetweenEvictionRunsMillis: 30000
        #表示idle object evitor每次扫描的最多的对象数
        numTestsPerEvictionRun: 10
        #表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义
        minEvictableIdleTimeMillis: 60000

config类

package com.redis.config;

import lombok.Data;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.Assert;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;
import redis.clients.jedis.Protocol;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;


@Configuration
@Data
public class RedisConfig {

    private Logger logger = LoggerFactory.getLogger(RedisConfig.class);

    @Bean
    @Autowired
    public JedisSentinelPool jedisPool(@Qualifier("jedis.pool.config") JedisPoolConfig config,
                                       @Value("${spring.redis.sentinel.master}") String clusterName,
                                       @Value("${spring.redis.sentinel.nodes}") String sentinelNodes,
                                       @Value("${spring.redis.password}") String password) {
        logger.info("缓存服务器的主服务名称：" + clusterName + ", 哨兵服务ip&port:" + sentinelNodes);
        Assert.isTrue(StringUtils.isNotEmpty(clusterName), "主服务名称配置为空");
        Assert.isTrue(StringUtils.isNotEmpty(sentinelNodes), "主从服务地址配置为空");
        Set<String> sentinels = new HashSet<>( 8 );
        String[] sentinelNodeArr = sentinelNodes.split( "," );
        sentinels.addAll( Arrays.asList( sentinelNodeArr ) );

        JedisSentinelPool sentinelJedisPool = new JedisSentinelPool(clusterName, sentinels, config, Protocol.DEFAULT_TIMEOUT, password);

        return sentinelJedisPool;
    }

    @Bean(name = "jedis.pool.config")
    public JedisPoolConfig jedisPoolConfig(@Value("${spring.redis.jedis.pool.maxTotal}") int maxTotal,
                                           @Value("${spring.redis.jedis.pool.maxIdle}") int maxIdle,
                                           @Value("${spring.redis.jedis.pool.maxWaitMillis}") int maxWaitMillis,
                                           @Value("${spring.redis.jedis.pool.testOnBorrow}") boolean testOnBorrow,
                                           @Value("${spring.redis.jedis.pool.testOnReturn}") boolean testOnReturn,
                                           @Value("${spring.redis.jedis.pool.blockWhenExhausted}") boolean blockWhenExhausted,
                                           @Value("${spring.redis.jedis.pool.testWhileIdle}") boolean testWhileIdle,
                                           @Value("${spring.redis.jedis.pool.timeBetweenEvictionRunsMillis}") long timeBetweenEvictionRunsMillis,
                                           @Value("${spring.redis.jedis.pool.numTestsPerEvictionRun}") int numTestsPerEvictionRun,
                                           @Value("${spring.redis.jedis.pool.minEvictableIdleTimeMillis}") long minEvictableIdleTimeMillis) {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxTotal);
        config.setMaxIdle(maxIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        config.setTestOnBorrow(testOnBorrow);
        config.setTestOnReturn(testOnReturn);
        config.setBlockWhenExhausted(blockWhenExhausted);
        config.setTestWhileIdle(testWhileIdle);
        config.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        config.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
        config.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);

        return config;
    }

}

配置客户端

    @Autowired
    private JedisSentinelPool jedisPool;

    private Jedis getJedis() {
        return jedisPool.getResource();
    }