springboot + redis集群和单机切换（密码）自定义配置文件

项目中因为不是使用springRedis的配置，而是采用自定义的配置redis.pool，而且需要进行单机和集群的切换，中间出现了一些jar包冲突的问题，导致部分功能不能使用，还是记录一下，这个找了好久

1、配置文件如下，可能和现行的配置不同，使用model进行区分，当然代码有判断

redis:
  pool:
    maxTotal: 120 # 最大连接数
    maxIdle: 30 # 最大空闲实例的个数
    minIdle: 3 #最小空闲实例个数
    numTestsPerEvictionRun: 1024 # 每个逐出器运行期间要检查的最大对象数
    timeBetweenEvictionRunsMillis: 30000 # 释放扫描的扫描间隔
    minEvictableIdleTimeMillis: 1800000 # 连接的最小空闲时间
    softMinEvictableIdleTimeMillis: 10000 # 连接控歘按时间多久后释放，当空闲时间>该值且空闲连接>最大空闲连接数时直接释放
    maxWaitMillis: 1500 # 获得链接时的最大等待毫秒数，小于0：阻塞不确定时间，默认-1
    testOnBorrow: true # 在获得链接的时候检查有效性，默认false
    testWhileIdle: true # 在空闲时检查有效性，默认false
    blockWhenExhausted: false # 连接耗尽时是否阻塞，false报异常，true阻塞超时,默认true
    timeOut: 10000 # jedis超时时间
  maxRedirects: 5 # RedisClusterConfiguration配置
  nodeCluters: 192.168.98.105:7000,192.168.98.105:7001,192.168.98.105:7002,192.168.98.105:7003,192.168.98.105:7004,192.168.98.105:7005
  hostName: localhost
  password: 43b6f9b82c71c13063a523c0dcbc6db8fc0ac8a0
  port: 6379
  model: 3 #redis的模式1 表示单机，2 表示sentinel， 3表示cluster

2、pom文件

原来使用的pom是1.4.7，但是这个版本好像有点低

	org.springframework.boot
	spring-boot-starter-redis
	1.4.7.RELEASE

这个版本在jedisConnectionFactory设置密码处好像不太兼容

因此需要处理jar的版本冲突问题（敲黑板啦`````这个才是重点），需要排除依赖

	org.springframework.boot
	spring-boot-starter-data-redis
	
		
			redis.clients
			jedis
		
	    
		    org.springframework.data
			spring-data-redis
		
	


	redis.clients
	jedis
    2.9.0


	org.springframework.data
	spring-data-redis
	1.8.10.RELEASE

3、一下为具体的config，因为有个工具类需要注入，所以会有CacheUtil，然后里面进行了redis的序列化，据说默认是jdk的序列化方式

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yss.ms.constant.RedisConstant;
import com.yss.ms.util.CacheUtils;
import org.apache.commons.lang3.StringUtils;
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.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

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


@Configuration
public class RedisClusterConfig {

	@Value("${redis.nodeCluters}")
	private String nodeCluters;

	@Value("${redis.hostName}")
	private String hostName;
	@Value("${redis.port}")
	private int port;
	@Value("${redis.password}")
	private String password;
	@Value("${redis.model}")
	private int model;


	@Value("${redis.maxRedirects}")
	private int maxRedirects;
	@Value("${redis.pool.blockWhenExhausted}")
	private boolean blockWhenExhausted;
	@Value("${redis.pool.maxTotal}")
	private int maxTotal;
	@Value("${redis.pool.maxIdle}")
	private int maxIdle;
	@Value("${redis.pool.minIdle}")
	private int minIdle;
	@Value("${redis.pool.numTestsPerEvictionRun}")
	private int numTestsPerEvictionRun;
	@Value("${redis.pool.timeBetweenEvictionRunsMillis}")
	private int timeBetweenEvictionRunsMillis;
	@Value("${redis.pool.minEvictableIdleTimeMillis}")
	private int minEvictableIdleTimeMillis;
	@Value("${redis.pool.softMinEvictableIdleTimeMillis}")
	private int softMinEvictableIdleTimeMillis;
	@Value("${redis.pool.maxWaitMillis}")
	private int maxWaitMillis;
	@Value("${redis.pool.timeOut}")
	private int timeOut;

	@Bean(name = "jedisPoolConfig")
    JedisPoolConfig jedisPoolConfig() {
		JedisPoolConfig pool = new JedisPoolConfig();
		pool.setMaxIdle(maxIdle);
		pool.setMinIdle(minIdle);
		pool.setBlockWhenExhausted(blockWhenExhausted);
		pool.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
		pool.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
		pool.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
		pool.setSoftMinEvictableIdleTimeMillis(softMinEvictableIdleTimeMillis);

		pool.setMaxTotal(maxTotal);
		pool.setMaxWaitMillis(maxWaitMillis);
		return pool;
	}

	@Bean(name = "redisClusterConfiguration")
	public RedisClusterConfiguration getRedisClusterConfiguration() {
		RedisClusterConfiguration configuration = new RedisClusterConfiguration();
		Set nodes = new HashSet();

		String[] nodec=nodeCluters.split(",");
		for(int i=0;i nodes = new HashSet();
		String[] nodec=nodeCluters.split(",");
		for(int i=0;i getRedisTemplate(
			@Qualifier("jedisConnectionFactory") JedisConnectionFactory factory) {
		RedisTemplate redisTemplate = new RedisTemplate();
		redisTemplate.setConnectionFactory(factory);
		// 使用Jackson2JsonRedisSerialize 替换默认序列化
		@SuppressWarnings({ "rawtypes", "unchecked" })
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

		ObjectMapper objectMapper = new ObjectMapper();
		objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

		jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

		// 设置value的序列化规则和 key的序列化规则
		redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
		redisTemplate.setKeySerializer(new StringRedisSerializer());

		redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
		redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

		redisTemplate.setDefaultSerializer(jackson2JsonRedisSerializer);
		redisTemplate.setEnableDefaultSerializer(true);
		redisTemplate.afterPropertiesSet();
		return redisTemplate;
	}

	@Bean
	public CacheUtils cacheUtils(RedisTemplate redisTemplate){
		return new CacheUtils(redisTemplate);
	}


	/**
	 * 校验password是否为空，不为空设置密码
	 * @param jedisConnectionFactory
	 */
	private void checkPasswordIfNull(JedisConnectionFactory jedisConnectionFactory) {
		if (!StringUtils.isBlank(password)) {
			jedisConnectionFactory.setPassword(password);
		}
	}
}