springboot使用Lettuce配置多数据源（单实例-集群-哨兵）

缺乏、安全感 2023-07-25 11:17 3阅读 0赞

在同一个应用中可能会同时用到多个redis数据源，并且这多个redis数据源可能模式还不一样，有单实例、集群、哨兵。

本文章就把这3种模式的redis数据源都集成到一个应用种。

那么就可以应付其他各种情况，例如，2个单实例3个集群4个哨兵等等。

只上干货：

pom

<dependency>
    		   <groupId>org.apache.commons</groupId>
    		   <artifactId>commons-pool2</artifactId>
    		</dependency>
    
            <dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis-reactive</artifactId>
    		</dependency>

yml：

spring:  
      application: 
        name: two
      #默认用集群配置，3主3从共6节点的集群
      redis:
        timeout: 6000ms
        database: 10 
    #    host: localhost #单实例redis用这个配置
    #    password: #单实例redis用这个配置
        port: 6379 #单实例redis用这个配置
        password: Redis@123
        cluster: #集群用这个配置
          nodes:
            - 127.0.0.1:7011
            - 127.0.0.1:7012
            - 127.0.0.1:7013
            - 127.0.0.1:7014
            - 127.0.0.1:7015
            - 127.0.0.1:7016
          max-redirects: 2 #获取失败 最大重定向次数
        lettuce:
          pool: 
            max-active: 1000 #连接池最大连接数（使用负值表示没有限制）
            max-idle: 10 #连接池中的最大空闲连接
            min-idle: 3 #连接池中的最小空闲连接
            max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
      #redis单实例。单实例比较简单，ip，端口，密码，连接池就ok
      redis2:
        timeout: 6000ms
        database: 0 
        host: localhost #单实例redis用这个配置
        password: #单实例redis用这个配置
        port: 6379 #单实例redis用这个配置
        lettuce:
          pool: 
            max-active: 1000 #连接池最大连接数（使用负值表示没有限制）
            max-idle: 10 #连接池中的最大空闲连接
            min-idle: 3 #连接池中的最小空闲连接
            max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
      #redis哨兵.一主2从192.168.10.1:6379,192.168.10.2:6379,192.168.10.3:6379。三哨兵192.168.10.1:26379,192.168.10.2:26379,192.168.10.3:26379
      redis3:
        timeout: 6000ms
        database: 0 
        host: 192.168.10.1 #主节点的master
        password: ha@123 #redis密码
        port: 6379 #主节点的master端口
        lettuce:
          pool: 
            max-active: 1000 #连接池最大连接数（使用负值表示没有限制）
            max-idle: 10 #连接池中的最大空闲连接
            min-idle: 3 #连接池中的最小空闲连接
            max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
        sentinel: 
          master: mymaster 
          nodes: 
            - 192.168.10.1:26379
            - 192.168.10.2:26379
            - 192.168.10.3:26379

java配置：

需要3个读取yml的配置类，分别对应集群redis，单实例redis，哨兵redis。

package com.example.two.config.redis;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    import lombok.Data;
    
    /**
     * 映射redis的集群配置
     * yml:
    
      #默认用集群配置，3主3从共6节点的集群
    spring: 
      redis:
        timeout: 6000ms
        database: 10 
        port: 6379 #单实例redis用这个配置
        password: Redis@123
        cluster: #集群用这个配置
          nodes:
            - 127.0.0.1:7011
            - 127.0.0.1:7012
            - 127.0.0.1:7013
            - 127.0.0.1:7014
            - 127.0.0.1:7015
            - 127.0.0.1:7016
          max-redirects: 2 #获取失败 最大重定向次数
        lettuce:
          pool: 
            max-active: 1000 #连接池最大连接数（使用负值表示没有限制）
            max-idle: 10 #连接池中的最大空闲连接
            min-idle: 3 #连接池中的最小空闲连接
            max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制） 
            
     * @author lsy
     *
     */
    //@Data
    @ConfigurationProperties(prefix="spring.redis.cluster")
    public class RedisConfigOne {
    
        @Value("${spring.redis.host:127.0.0.1}")
        private String host;
        @Value("${spring.redis.port:6379}")
        private int port;
        @Value("${spring.redis.password:redis123}")
        private String password;
        @Value("${spring.redis.timeout:6000}")
        private int timeout;
        @Value("${spring.redis.database:0}")
        private int database;
        
        //pool映射
        @Value("${spring.redis.lettuce.pool.max-active}")
        private int maxActive;
        @Value("${spring.redis.lettuce.pool.max-idle}")
        private int maxIdle;
        @Value("${spring.redis.lettuce.pool.min-idle}")
        private int minIdle;
        @Value("${spring.redis.lettuce.pool.max-wait}")
        private int maxWait;
        
        //cluster映射
        List<String> nodes;//@ConfigurationProperties(prefix="spring.redis.cluster")映射
        
        @Value("${spring.redis.cluster.max-redirects:3}")
        private int maxRedirects;
    
        
        
        
        
    	public String getHost() {
    		return host;
    	}
    
    	public void setHost(String host) {
    		this.host = host;
    	}
    
    	public int getPort() {
    		return port;
    	}
    
    	public void setPort(int port) {
    		this.port = port;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	public int getTimeout() {
    		return timeout;
    	}
    
    	public void setTimeout(int timeout) {
    		this.timeout = timeout;
    	}
    
    	public int getDatabase() {
    		return database;
    	}
    
    	public void setDatabase(int database) {
    		this.database = database;
    	}
    
    	public int getMaxActive() {
    		return maxActive;
    	}
    
    	public void setMaxActive(int maxActive) {
    		this.maxActive = maxActive;
    	}
    
    	public int getMaxIdle() {
    		return maxIdle;
    	}
    
    	public void setMaxIdle(int maxIdle) {
    		this.maxIdle = maxIdle;
    	}
    
    	public int getMinIdle() {
    		return minIdle;
    	}
    
    	public void setMinIdle(int minIdle) {
    		this.minIdle = minIdle;
    	}
    
    	
    
    	public List<String> getNodes() {
    		return nodes;
    	}
    
    	public void setNodes(List<String> nodes) {
    		this.nodes = nodes;
    	}
    
    	public int getMaxWait() {
    		return maxWait;
    	}
    
    	public void setMaxWait(int maxWait) {
    		this.maxWait = maxWait;
    	}
    
    	public int getMaxRedirects() {
    		return maxRedirects;
    	}
    
    	public void setMaxRedirects(int maxRedirects) {
    		this.maxRedirects = maxRedirects;
    	}
    
        
        
    }

package com.example.two.config.redis;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    import lombok.Data;
    
    /**
     * 映射redis的单实例配置配置
     * yml:
    
       #redis单实例。单实例比较简单，ip，端口，密码，连接池就ok
    spring: 
      redis2:
        timeout: 6000ms
        database: 0 
        host: localhost #单实例redis用这个配置
        password: #单实例redis用这个配置
        port: 6379 #单实例redis用这个配置
        lettuce:
          pool: 
            max-active: 1000 #连接池最大连接数（使用负值表示没有限制）
            max-idle: 10 #连接池中的最大空闲连接
            min-idle: 3 #连接池中的最小空闲连接
            max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
     
     * @author lsy
     *
     */
    //@Data
    @ConfigurationProperties(prefix="spring.redis2.cluster")
    public class RedisConfigTwo {
    
    
        @Value("${spring.redis2.host:127.0.0.1}")
        private String host;
        @Value("${spring.redis2.port:6379}")
        private int port;
        @Value("${spring.redis2.password:redis123}")
        private String password;
        @Value("${spring.redis2.timeout:6000}")
        private int timeout;
        @Value("${spring.redis2.database:0}")
        private int database;
        
        //pool映射
        @Value("${spring.redis2.lettuce.pool.max-active}")
        private int maxActive;
        @Value("${spring.redis2.lettuce.pool.max-idle}")
        private int maxIdle;
        @Value("${spring.redis2.lettuce.pool.min-idle}")
        private int minIdle;
        @Value("${spring.redis2.lettuce.pool.max-wait}")
        private long maxWait;
        
        
        
        
    	public String getHost() {
    		return host;
    	}
    	public void setHost(String host) {
    		this.host = host;
    	}
    	public int getPort() {
    		return port;
    	}
    	public void setPort(int port) {
    		this.port = port;
    	}
    	public String getPassword() {
    		return password;
    	}
    	public void setPassword(String password) {
    		this.password = password;
    	}
    	public int getTimeout() {
    		return timeout;
    	}
    	public void setTimeout(int timeout) {
    		this.timeout = timeout;
    	}
    	public int getDatabase() {
    		return database;
    	}
    	public void setDatabase(int database) {
    		this.database = database;
    	}
    	public int getMaxActive() {
    		return maxActive;
    	}
    	public void setMaxActive(int maxActive) {
    		this.maxActive = maxActive;
    	}
    	public int getMaxIdle() {
    		return maxIdle;
    	}
    	public void setMaxIdle(int maxIdle) {
    		this.maxIdle = maxIdle;
    	}
    	public int getMinIdle() {
    		return minIdle;
    	}
    	public void setMinIdle(int minIdle) {
    		this.minIdle = minIdle;
    	}
    	public long getMaxWait() {
    		return maxWait;
    	}
    	public void setMaxWait(long maxWait) {
    		this.maxWait = maxWait;
    	}
        
        
        
    }

package com.example.two.config.redis;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    import lombok.Data;
    
    /**
     * 映射redis的哨兵配置配置
     * yml:
     
      #redis哨兵.一主2从192.168.10.1:6379,192.168.10.2:6379,192.168.10.3:6379。三哨兵192.168.10.1:26379,192.168.10.2:26379,192.168.10.3:26379
    spring:  
      redis3:
        timeout: 6000ms
        database: 0 
        host: 192.168.10.1 #主节点的master
        password: ha@123 #redis密码
        port: 6379 #主节点的master端口
        lettuce:
          pool: 
            max-active: 1000 #连接池最大连接数（使用负值表示没有限制）
            max-idle: 10 #连接池中的最大空闲连接
            min-idle: 3 #连接池中的最小空闲连接
            max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
        sentinel: 
          master: mymaster 
          nodes: 
            - 192.168.10.1:26379
            - 192.168.10.2:26379
            - 192.168.10.3:26379
          
     * 
     * @author lsy
     *
     */
    //@Data
    @ConfigurationProperties(prefix="spring.redis3.sentinel")
    public class RedisConfigThree {
    
        @Value("${spring.redis3.host:127.0.0.1}")
        private String host;
        @Value("${spring.redis3.port:6379}")
        private int port;
        @Value("${spring.redis3.password:redis123}")
        private String password;
        @Value("${spring.redis3.timeout:6000}")
        private int timeout;
        @Value("${spring.redis3.database:0}")
        private int database;
        
        //pool映射
        @Value("${spring.redis3.lettuce.pool.max-active}")
        private int maxActive;
        @Value("${spring.redis3.lettuce.pool.max-idle}")
        private int maxIdle;
        @Value("${spring.redis3.lettuce.pool.min-idle}")
        private int minIdle;
        @Value("${spring.redis3.lettuce.pool.max-wait}")
        private long maxWait;
        
        //setinel映射
        List<String> nodes;//@ConfigurationProperties(prefix="spring.redis3.sentinel")映射
        
        @Value("${spring.redis3.sentinel.master:mymaster}")
        private String master;
    
        
        
        
    	public String getHost() {
    		return host;
    	}
    
    	public void setHost(String host) {
    		this.host = host;
    	}
    
    	public int getPort() {
    		return port;
    	}
    
    	public void setPort(int port) {
    		this.port = port;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	public int getTimeout() {
    		return timeout;
    	}
    
    	public void setTimeout(int timeout) {
    		this.timeout = timeout;
    	}
    
    	public int getDatabase() {
    		return database;
    	}
    
    	public void setDatabase(int database) {
    		this.database = database;
    	}
    
    	public int getMaxActive() {
    		return maxActive;
    	}
    
    	public void setMaxActive(int maxActive) {
    		this.maxActive = maxActive;
    	}
    
    	public int getMaxIdle() {
    		return maxIdle;
    	}
    
    	public void setMaxIdle(int maxIdle) {
    		this.maxIdle = maxIdle;
    	}
    
    	public int getMinIdle() {
    		return minIdle;
    	}
    
    	public void setMinIdle(int minIdle) {
    		this.minIdle = minIdle;
    	}
    
    	public long getMaxWait() {
    		return maxWait;
    	}
    
    	public void setMaxWait(long maxWait) {
    		this.maxWait = maxWait;
    	}
    
    	public List<String> getNodes() {
    		return nodes;
    	}
    
    	public void setNodes(List<String> nodes) {
    		this.nodes = nodes;
    	}
    
    	public String getMaster() {
    		return master;
    	}
    
    	public void setMaster(String master) {
    		this.master = master;
    	}
        
        
    }

最后是总配置

package com.example.two.config.redis;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.data.redis.connection.RedisClusterConfiguration;
    import org.springframework.data.redis.connection.RedisNode;
    import org.springframework.data.redis.connection.RedisPassword;
    import org.springframework.data.redis.connection.RedisSentinelConfiguration;
    import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
    import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
    import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * redis多数据源配置类
     * 我用了3个数据源，分别是集群，单实例，哨兵。
     * 在工程中同时使用。如果你的数据源是多个，按照这里的例子，再配N套就行。
     * 
     * 第一个是集群，
     * 第二个是单实例
     * 第三个是哨兵。
     * 
     * @author lsy
     *
     */
    @Configuration
    public class RedisConfig {
    
    	@Autowired
    	RedisConfigOne redisConfigOne;//集群的配置，读取yml文件
    	
    	@Autowired
    	RedisConfigTwo redisConfigTwo;//单实例的配置，读取yml文件
    	
    	@Autowired
    	RedisConfigThree redisConfigThree;//哨兵的配置，读取yml文件
    	
    	/************集群的配置--start*******************/
    	//读取pool配置
    	@Bean
        public GenericObjectPoolConfig redisPool() {
    		GenericObjectPoolConfig config = new GenericObjectPoolConfig();
    		config.setMinIdle(redisConfigOne.getMaxIdle());
    		config.setMaxIdle(redisConfigOne.getMaxIdle());
    		config.setMaxTotal(redisConfigOne.getMaxActive());
    		config.setMaxWaitMillis(redisConfigOne.getMaxWait());
            return config;
        }
    	@Bean
        public RedisClusterConfiguration redisConfig() {//集群配置类
    		RedisClusterConfiguration redisConfig = new RedisClusterConfiguration(redisConfigOne.getNodes());
    		redisConfig.setMaxRedirects(redisConfigOne.getMaxRedirects());
    		redisConfig.setPassword(RedisPassword.of(redisConfigOne.getPassword()));
            return redisConfig;
        }
    	@Bean("factory")
        @Primary
        public LettuceConnectionFactory factory(@Qualifier("redisPool") GenericObjectPoolConfig config, 
        		@Qualifier("redisConfig") RedisClusterConfiguration redisConfig) {//注意传入的对象名和类型RedisClusterConfiguration
            LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(config).build();
            return new LettuceConnectionFactory(redisConfig, clientConfiguration);
        }
    	
    	/**
    	 * 集群redis数据源
    	 * 
    	 * @param connectionFactory
    	 * @return
    	 */
    	@Bean("redisTemplate")
        @Primary
        public RedisTemplate<String, Object> redisTemplate(@Qualifier("factory")LettuceConnectionFactory connectionFactory) {//注意传入的对象名
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(connectionFactory);
    
            //设置序列化器
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
            
            redisTemplate.setKeySerializer(stringRedisSerializer);
            redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
            redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
            redisTemplate.afterPropertiesSet();
            
            return redisTemplate;
        }
    	/************集群的配置--end*******************/
    	
    	
        /************单实例的配置--start*******************/
    	//读取pool配置
    	@Bean
        public GenericObjectPoolConfig redisPool2() {
    		GenericObjectPoolConfig config = new GenericObjectPoolConfig();
    		config.setMinIdle(redisConfigTwo.getMaxIdle());
    		config.setMaxIdle(redisConfigTwo.getMaxIdle());
    		config.setMaxTotal(redisConfigTwo.getMaxActive());
    		config.setMaxWaitMillis(redisConfigTwo.getMaxWait());
            return config;
        }
    	
    	@Bean
        public RedisStandaloneConfiguration redisConfig2() {
    		RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration(redisConfigTwo.getHost(),redisConfigTwo.getPort());
    		redisConfig.setPassword(RedisPassword.of(redisConfigTwo.getPassword()));
    		return redisConfig;
        }
    	
    	@Bean("factory2")
        public LettuceConnectionFactory factory2(@Qualifier("redisPool2") GenericObjectPoolConfig config, 
        		@Qualifier("redisConfig2") RedisStandaloneConfiguration redisConfig) {//注意传入的对象名和类型RedisStandaloneConfiguration
            LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(config).build();
            return new LettuceConnectionFactory(redisConfig, clientConfiguration);
        }
    	
    	
    	/**
    	 * 单实例redis数据源
    	 * 
    	 * @param connectionFactory
    	 * @return
    	 */
    	@Bean("redisTemplate2")
        public RedisTemplate<String, Object> redisTemplate2(@Qualifier("factory2")LettuceConnectionFactory connectionFactory) {//注意传入的对象名
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(connectionFactory);
    
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
    
            //设置序列化器
            redisTemplate.setKeySerializer(stringRedisSerializer);
            redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
            redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
            redisTemplate.afterPropertiesSet();
            
            return redisTemplate;
        }
    	/************单实例的配置--end*******************/
    	
    	
    	
        /************哨兵的配置--start*******************/
    	//读取pool配置
    	@Bean
        public GenericObjectPoolConfig redisPool3() {
    		GenericObjectPoolConfig config = new GenericObjectPoolConfig();
    		config.setMinIdle(redisConfigThree.getMaxIdle());
    		config.setMaxIdle(redisConfigThree.getMaxIdle());
    		config.setMaxTotal(redisConfigThree.getMaxActive());
    		config.setMaxWaitMillis(redisConfigThree.getMaxWait());
            return config;
        }
    	@Bean
        public RedisSentinelConfiguration redisConfig3() {//哨兵的节点要写代码组装到配置对象中
    		RedisSentinelConfiguration redisConfig = new RedisSentinelConfiguration();
    		redisConfig.sentinel(redisConfigThree.getHost(), redisConfigThree.getPort());
    		redisConfig.setMaster(redisConfigThree.getMaster());
    		redisConfig.setPassword(RedisPassword.of(redisConfigThree.getPassword()));
    		if(redisConfigThree.getNodes()!=null) {
    			List<RedisNode> sentinelNode=new ArrayList<RedisNode>();
    			for(String sen : redisConfigThree.getNodes()) {
    				String[] arr = sen.split(":");
    				sentinelNode.add(new RedisNode(arr[0],Integer.parseInt(arr[1])));
    			}
    			redisConfig.setSentinels(sentinelNode);
    		}
    		return redisConfig;
        }
    	@Bean("factory3")
        public LettuceConnectionFactory factory3(@Qualifier("redisPool3") GenericObjectPoolConfig config, 
        		@Qualifier("redisConfig3") RedisSentinelConfiguration redisConfig) {//注意传入的对象名和类型RedisSentinelConfiguration
            LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(config).build();
            return new LettuceConnectionFactory(redisConfig, clientConfiguration);
        }
    	
    	/**
    	 * 哨兵redis数据源
    	 * 
    	 * @param connectionFactory
    	 * @return
    	 */
    	@Bean("redisTemplate3")
        public RedisTemplate<String, Object> redisTemplate3(@Qualifier("factory3")LettuceConnectionFactory connectionFactory) {//注意传入的对象名
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(connectionFactory);
    
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
    
            //设置序列化器
            redisTemplate.setKeySerializer(stringRedisSerializer);
            redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
            redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
            redisTemplate.afterPropertiesSet();
            
            return redisTemplate;
        }
    	/************哨兵的配置--end*******************/
    }

这样多数据源就配好了。按照这个例子可以进行其他各种多数据源的配置。