springboot配置两套redis 集群，并且需要用sentinel连接问题处理

由于公司项目功能优化需要新增一套redis 集群处理数据，那项目就要配置另一套redis 集群。
本来想找度娘解决的，谁知度娘没有相关资料，所以只能自己看了一下源码。
一般来说，直接配置文件就可以了，

spring
	redis:
	    sentinel:
	      master: master
	      nodes: 127.0.0.1:26379
	    password: 111111111
	    timeout: 20000

spring 会自动匹配并且处理。

现在新增一套，那配置不知道应该怎么写，
只能新增一个redisconfig配置类，把sentinel集群放进去，道理大家都懂，但具体是那个类，那只能看源码了

先看JedisConnectionFactory
可以看到有3种Configuration可以配置：RedisStandaloneConfiguration，RedisSentinelConfiguration，RedisClusterConfiguration。
大概意思大家看字面信息就知道了
RedisSentinelConfiguration就是我们需要用到的，重写一下JedisConnectionFactory ，然后在
RedisTemplate设置一下就可以了

@Bean("jedisHybrisConnectionFactory")
	public JedisConnectionFactory jedisHybrisConnectionFactory() {
		List<String> nodeList = Lists.newArrayList("127.0.0.1:26379");
		List<RedisNode> nodes = new ArrayList<>();
		for (String node : nodeList) {
			String[] parts = StringUtils.split(node, ":");
			nodes.add(new RedisNode(parts[0], Integer.parseInt(parts[1])));
		}
		RedisSentinelConfiguration redisSentinelConfiguration =
				new RedisSentinelConfiguration();
		redisSentinelConfiguration.setMaster("master");
		redisSentinelConfiguration.setDatabase(0);
		redisSentinelConfiguration.setPassword(RedisPassword.of("111111"));
		redisSentinelConfiguration.setSentinels(nodes);
		return new JedisConnectionFactory(redisSentinelConfiguration);
	}

其中节点的配置RedisNode是参考了源码的写法
RedisConnectionConfiguration 的createSentinels方法

private List<RedisNode> createSentinels(RedisProperties.Sentinel sentinel) {
		List<RedisNode> nodes = new ArrayList<>();
		for (String node : sentinel.getNodes()) {
			try {
				String[] parts = StringUtils.split(node, ":");
				Assert.state(parts.length == 2, "Must be defined as 'host:port'");
				nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1])));
			}
			catch (RuntimeException ex) {
				throw new IllegalStateException(
						"Invalid redis sentinel " + "property '" + node + "'", ex);
			}
		}
		return nodes;
	}

完整配置类

package com.chimelong.cldmp.commons.config;

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.core.JsonGenerator.Feature;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.google.common.collect.Lists;
import org.springframework.beans.factory.annotation.Qualifier;
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.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

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

@Configuration
public class RedisHybrisConfig {


	@Bean
	public GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer(Jackson2ObjectMapperBuilder builder) {
		ObjectMapper objectMapper = builder.build();
		objectMapper.configure(Feature.WRITE_BIGDECIMAL_AS_PLAIN, true);
		objectMapper.registerModules(new JavaTimeModule(), new Jdk8Module(), new SimpleModule());
		objectMapper.setTimeZone(TimeZone.getDefault());
		objectMapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);
		objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
		objectMapper.configure(SerializationFeature.WRITE_DATES_WITH_ZONE_ID, true);
		objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, true);
		objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
		objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
		objectMapper.setSerializationInclusion(Include.NON_NULL);
		objectMapper.enableDefaultTyping(DefaultTyping.NON_FINAL, As.PROPERTY);
		return new GenericJackson2JsonRedisSerializer(objectMapper);
	}

	@Bean("jedisHybrisConnectionFactory")
	public JedisConnectionFactory jedisHybrisConnectionFactory() {
		List<String> nodeList = Lists.newArrayList("127.0.0.1:26379");
		List<RedisNode> nodes = new ArrayList<>();
		for (String node : nodeList) {
			String[] parts = StringUtils.split(node, ":");
			nodes.add(new RedisNode(parts[0], Integer.parseInt(parts[1])));
		}
		RedisSentinelConfiguration redisSentinelConfiguration =
				new RedisSentinelConfiguration();
		redisSentinelConfiguration.setMaster("master");
		redisSentinelConfiguration.setDatabase(0);
		redisSentinelConfiguration.setPassword(RedisPassword.of("111111111"));
		redisSentinelConfiguration.setSentinels(nodes);
		return new JedisConnectionFactory(redisSentinelConfiguration);
	}

	@Bean("redisDmpTemplate")
	public RedisTemplate<String, Object> redisDmpTemplate(@Qualifier("jedisHybrisConnectionFactory") RedisConnectionFactory connectionFactory, GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer) {
		RedisTemplate<String, Object> redisDmpTemplate= new RedisTemplate<>();
		redisDmpTemplate.setKeySerializer(new StringRedisSerializer());
		redisDmpTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
		redisDmpTemplate.setHashKeySerializer(new StringRedisSerializer());
		redisDmpTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
		redisDmpTemplate.setConnectionFactory(connectionFactory);
		redisDmpTemplate.afterPropertiesSet();
		return redisDmpTemplate;
	}

}

应该很少人会遇到这种情况，毕竟这种业务场景很少的，希望能帮助到有缘人咯。