RedisTempalte 同时连接redis的集群模式和哨兵模式

1、maven 依赖包

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>1.5.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>1.5.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>1.5.3.RELEASE</version>
        </dependency>

2、配置文件

    可以修改配置文件支持多个集群和哨兵，暂时一个集群一个哨兵

spring:
  redis:
    sentinel:
      master: sentinel-127.0.0.1-6383
      nodes: 127.0.0.1:6389,127.0.0.1:6384
      password:
      database: 0
      timeout: 2000
    cluster:
      nodes: 127.0.0.1:6388,127.0.0.1:6379
      max-redirects: 3
      password:
      database: 0
      timeout: 2000
    pool:
      max-total: 8
      max-idle: 8
      min-idle: 0
      max-wait: -1
      max-active: 8

3、读取的配置文件

BaseRedisConfig.java

        /**
	 * nodes
	 */
	private String nodes;
	/**
	 * 密码
	 */
	private String password;
	/**
	 * 超时时间
	 */
	private int timeout;
	/**
	 * 数据库,默认是0
	 */
	private int database;

RedisClusterConfig.java

@Data
@Configuration
@ConfigurationProperties(prefix = "spring.redis.cluster")
public class RedisClusterConfig extends BaseRedisConfig {
	/**
	 * maxRedirects
	 */
	private String maxRedirects;

}

RedisConfig.java

@Data
@Configuration
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConfig {

	/**
	 * 哨兵的配置
	 */
	private RedisSentinelConfig sentinel;
	/**
	 * 集群的配置信息
	 */
	private RedisClusterConfig cluster;
	/**
	 * 连接池
	 */
	private RedisPoolConfig pool;

}

RedisPoolConfig.java

@Data
@Configuration
@ConfigurationProperties(prefix = "spring.redis.pool")
public class RedisPoolConfig {
	/**
	 * maxIdle
	 */
	private int maxIdle = 8;
	/**
	 * minIdle
	 */
	private int minIdle = 8;
	/**
	 * maxWait
	 */
	private int maxWait = -1;
	/**
	 * maxActive
	 */
	private int maxActive = 8;

}

RedisSentinelConfig.java

@Data
@Configuration
@ConfigurationProperties(prefix = "spring.redis.sentinel")
public class RedisSentinelConfig extends BaseRedisConfig {
	/**
	 * master
	 */
	private String master;

}

Redis.java

public class Redis {

	/**
	 * 连接工厂类
	 *
	 * @param connectionFactory 连接工厂类
	 * @param redisConfig       redis基本配置信息
	 * @return 返回 连接工厂类
	 */
	protected JedisConnectionFactory buildConnectionFactory(JedisConnectionFactory connectionFactory, RedisConfig redisConfig) {
		connectionFactory.setUsePool(true);
		connectionFactory.afterPropertiesSet();
		connectionFactory.setPoolConfig(jedisPoolConfig(redisConfig.getPool()));
		return connectionFactory;
	}


	/**
	 * 构建 连接模板
	 *
	 * @param redisConnectionFactory redis 连接工厂
	 * @return 返回 连接模板
	 */
	protected StringRedisTemplate buildRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
		StringRedisTemplate redisTemplate = new StringRedisTemplate();
		redisTemplate.setConnectionFactory(redisConnectionFactory);

		return redisTemplate;
	}


	/**
	 * redis 序列化的方式，避免数据异常
	 *
	 * @return 序列化的方式
	 */
	private StringRedisSerializer stringRedisSerializer() {
		return new StringRedisSerializer();
	}


	/**
	 * 连接池的配置信息
	 *
	 * @param redisPoolConfig 连接池
	 * @return 返回 连接池的配置信息
	 */
	private JedisPoolConfig jedisPoolConfig(RedisPoolConfig redisPoolConfig) {
		JedisPoolConfig poolConfig = new JedisPoolConfig();
		poolConfig.setMaxTotal(redisPoolConfig.getMaxActive());
		poolConfig.setMinIdle(redisPoolConfig.getMinIdle());
		poolConfig.setMaxIdle(redisPoolConfig.getMaxIdle());
		poolConfig.setMaxWaitMillis(redisPoolConfig.getMaxWait());
		return poolConfig;
	}


}

RedisCluster.java

@Configuration
public class RedisCluster extends Redis {

	/**
	 * 集群的节点地址信息
	 */
	@Autowired
	private RedisConfig redisConfig;

	/**
	 * 集群的bean
	 *
	 * @return 返回获取集群信息的模板
	 */
	@Bean(name = "redisClusterTemplate")
	@Primary
	public StringRedisTemplate redisClusterTemplate() {
		JedisConnectionFactory connectionFactory = new JedisConnectionFactory(this.redisClusterConfiguration());
		RedisClusterConfig redisClusterConfig = this.redisConfig.getCluster();
		connectionFactory.setTimeout(redisClusterConfig.getTimeout());
		connectionFactory.setDatabase(redisClusterConfig.getDatabase());
		connectionFactory.setPassword(redisClusterConfig.getPassword());
		return super.buildRedisTemplate(buildConnectionFactory(connectionFactory, redisConfig));
	}


	// -------- 私有方法 --------

	/**
	 * redis集群的配置信息
	 *
	 * @return 返回 redis集群的配置信息
	 */
	private RedisClusterConfiguration redisClusterConfiguration() {
		String[] nodes = redisConfig.getCluster().getNodes().split(",");
		Set<String> setNodes = new HashSet<>();
		for (String node : nodes) {
			setNodes.add(node.trim());
		}
		RedisClusterConfiguration configuration = new RedisClusterConfiguration(setNodes);
		return configuration;
	}


}

RedisSentinel.java

@Configuration
public class RedisSentinel extends Redis {

	/**
	 * 哨兵模式的节点地址信息
	 */
	@Autowired
	private RedisConfig redisConfig;

	/**
	 * 哨兵模式的配置模板
	 *
	 * @return 返回 哨兵模式的配置模板
	 */
	@Bean(name = "redisSentinelTemplate")
	@Primary
	public StringRedisTemplate redisSentinelTemplate() {
		JedisConnectionFactory connectionFactory = new JedisConnectionFactory(this.redisSentinelConfiguration());
		RedisSentinelConfig redisSentinelConfig = this.redisConfig.getSentinel();
		connectionFactory.setTimeout(redisSentinelConfig.getTimeout());
		connectionFactory.setDatabase(redisSentinelConfig.getDatabase());
		connectionFactory.setPassword(redisSentinelConfig.getPassword());
		return super.buildRedisTemplate(buildConnectionFactory(connectionFactory, redisConfig));
	}


	// -------- 私有方法 --------

	/**
	 * redis 哨兵的配置信息
	 *
	 * @return 返回 redis 哨兵的配置信息
	 */
	private RedisSentinelConfiguration redisSentinelConfiguration() {
		RedisSentinelConfig redisSentinelConfig = this.redisConfig.getSentinel();
		String[] nodes = redisSentinelConfig.getNodes().split(",");
		Set<String> setNodes = new HashSet<>();
		for (String n : nodes) {
			setNodes.add(n.trim());
		}
		RedisSentinelConfiguration configuration = new RedisSentinelConfiguration(redisSentinelConfig.getMaster(), setNodes);
		return configuration;
	}


}

4、测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class RedisCompare {

	/**
	 * redisSentinelTemplate
	 */
	@Resource(name = "redisSentinelTemplate")
	private StringRedisTemplate redisSentinelTemplate;
	/**
	 * redisClusterTemplate
	 */
	@Resource(name = "redisClusterTemplate")
	private StringRedisTemplate redisClusterTemplate;
	/**
	 * redisCluster
	 */
	@Autowired
	private RedisCluster redisCluster;
	/**
	 * redisSentinel
	 */
	@Autowired
	private RedisSentinel redisSentinel;

	@Test
	public void test() {
		ValueOperations<String, String> redisSentinelOps = redisSentinelTemplate.opsForValue();
		Long key = redisSentinelOps.size("key");
		System.out.println(key);

		ValueOperations<String, String> redisClusterOps = redisClusterTemplate.opsForValue();
		key = redisClusterOps.size("key");
		System.out.println(key);


		redisSentinelOps = redisCluster.redisClusterTemplate().opsForValue();
		key = redisSentinelOps.size("key");
		System.out.println(key);

		redisClusterOps = redisSentinel.redisSentinelTemplate().opsForValue();
		key = redisClusterOps.size("key");
		System.out.println(key);
	}


}

5、结果

5
0
0
5