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

绝地灬酷狼 2022-02-03 00:07 917阅读 0赞

项目中因为不是使用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，但是这个版本好像有点低

<dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-redis</artifactId>
    	<version>1.4.7.RELEASE</version>
    </dependency>

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

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

<dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-data-redis</artifactId>
    	<exclusions>
    		<exclusion>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    		</exclusion>
    	    <exclusion>
    		    <groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-redis</artifactId>
    		</exclusion>
    	</exclusions>
    </dependency>
    <dependency>
    	<groupId>redis.clients</groupId>
    	<artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework.data</groupId>
    	<artifactId>spring-data-redis</artifactId>
    	<version>1.8.10.RELEASE</version>
    </dependency>

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<RedisNode> nodes = new HashSet<RedisNode>();
    
    		String[] nodec=nodeCluters.split(",");
    		for(int i=0;i<nodec.length;i++){
    			String hostName=nodec[i].split(":")[0];
    			int port=Integer.parseInt(nodec[i].split(":")[1]);
    			RedisNode node = new RedisNode(hostName, port);
    			nodes.add(node);
    		}
    
    		configuration.setClusterNodes(nodes);
    		configuration.setMaxRedirects(maxRedirects);
    		return configuration;
    	}
    
    	@Bean(name = "jedisConnectionFactory")
    	JedisConnectionFactory jedisConnectionFactory(
    			@Qualifier("redisClusterConfiguration") RedisClusterConfiguration clusterConfig,
    			@Qualifier("jedisPoolConfig") JedisPoolConfig jedisPoolConfig) {
    		JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
    
    		//单机模式
    		if(model == RedisConstant.STANDALONE){
    			jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
    			jedisConnectionFactory.setHostName(hostName);
    			jedisConnectionFactory.setPort(port);
    		} else if(model == RedisConstant.SENTINEL){
    
    			//哨兵模式
    		} else if(model == RedisConstant.CLUSTER){
    			//Cluster模式
    			jedisConnectionFactory = new JedisConnectionFactory(clusterConfig, jedisPoolConfig);
    		}
    		//	判断密码是否存在，存在设置值
    		checkPasswordIfNull(jedisConnectionFactory);
    		return jedisConnectionFactory;
    	}
    
    	@Bean
    	public JedisCluster getJedisCluster(@Qualifier("jedisPoolConfig") JedisPoolConfig jedisPoolConfig) {
    		Set<HostAndPort> nodes = new HashSet<HostAndPort>();
    		String[] nodec=nodeCluters.split(",");
    		for(int i=0;i<nodec.length;i++){
    			String hostName=nodec[i].split(":")[0];
    			int port=Integer.parseInt(nodec[i].split(":")[1]);
    			HostAndPort node = new HostAndPort(hostName, port);
    			nodes.add(node);
    		}
    
    		if (!StringUtils.isBlank(password) && model == RedisConstant.CLUSTER) {
    			return new JedisCluster(nodes, timeOut, timeOut, 5, password, jedisPoolConfig);
    		} else {
    			return new JedisCluster(nodes, timeOut, jedisPoolConfig);
    		}
    	}
    
    	@Bean(name = "redisTemplate")
    	public RedisTemplate<String, Object> getRedisTemplate(
    			@Qualifier("jedisConnectionFactory") JedisConnectionFactory factory) {
    		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
    		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<String, Object> redisTemplate){
    		return new CacheUtils(redisTemplate);
    	}
    
    
    	/**
    	 * 校验password是否为空，不为空设置密码
    	 * @param jedisConnectionFactory
    	 */
    	private void checkPasswordIfNull(JedisConnectionFactory jedisConnectionFactory) {
    		if (!StringUtils.isBlank(password)) {
    			jedisConnectionFactory.setPassword(password);
    		}
    	}
    }