springboot redis如何使用lettuce配置多數據源

這篇文章將為大家詳細講解有關springboot redis如何使用lettuce配置多數據源，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

springboot是什么

springboot一種全新的編程規范，其設計目的是用來簡化新Spring應用的初始搭建以及開發過程，SpringBoot也是一個服務于框架的框架，服務范圍是簡化配置文件。

目前項目上需要連接兩個redis數據源，一個redis數據源是單機模式，一個redis數據源是分片集群模式，這里將具體配置列一下。

項目用的springboot版本為

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

一、在yml中配置redis數據源信息

redis:
    cluster:
      nodes: 127.0.0.1:9001
    lettuce:
      #連接池配置
      pool:
        #連接池最大連接數
        max-active: 20
        #連接池最大等待時間，負數表示不做限制
        max-wait: -1
        #最大空閑連接
        max-idle: 9
        #最小空閑連接
        min-idle: 0
    timeout: 500000
  redis2:
    host: 127.0.0.1
    port: 6385
    lettuce:
      pool:
        max-active: 20
        max-idle: 8
        max-wait: -1
        min-idle: 0
    timeout: 500000

（這里的redis都沒有配置密碼）

二、添加redis配置類

package com.cq.config;
 
import cn.hutool.core.convert.Convert;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
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.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
 
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
 
/**
 * @author cccccloud on 2020/11/16 17:16
 */
@Configuration
public class RedisConfig {
 
    @Autowired
    private Environment environment;
 
    @Value("${spring.redis2.host}")
    private String host;
    @Value("${spring.redis2.port}")
    private String port;
    @Value("${spring.redis2.lettuce.pool.max-active}")
    private String max_active;
    @Value("${spring.redis2.lettuce.pool.max-idle}")
    private String max_idle;
    @Value("${spring.redis2.lettuce.pool.max-wait}")
    private String max_wait;
    @Value("${spring.redis2.lettuce.pool.min-idle}")
    private String min_idle;
 
    /**
     * 配置lettuce連接池
     *
     * @return
     */
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.redis.cluster.lettuce.pool")
    public GenericObjectPoolConfig redisPool() {
        return new GenericObjectPoolConfig();
    }
 
    /**
     * 配置第一個數據源的
     *
     * @return
     */
    @Bean("redisClusterConfig")
    @Primary
    public RedisClusterConfiguration redisClusterConfig() {
 
        Map<String, Object> source = new HashMap<>(8);
        source.put("spring.redis.cluster.nodes", environment.getProperty("spring.redis.cluster.nodes"));
        RedisClusterConfiguration redisClusterConfiguration;
        redisClusterConfiguration = new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source));
        redisClusterConfiguration.setPassword(environment.getProperty("spring.redis.password"));
        return redisClusterConfiguration;
 
    }
 
    /**
     * 配置第一個數據源的連接工廠
     * 這里注意：需要添加@Primary 指定bean的名稱，目的是為了創建兩個不同名稱的LettuceConnectionFactory
     *
     * @param redisPool
     * @param redisClusterConfig
     * @return
     */
    @Bean("lettuceConnectionFactory")
    @Primary
    public LettuceConnectionFactory lettuceConnectionFactory(GenericObjectPoolConfig redisPool, @Qualifier("redisClusterConfig") RedisClusterConfiguration redisClusterConfig) {
        LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(redisPool).build();
        return new LettuceConnectionFactory(redisClusterConfig, clientConfiguration);
    }
 
    /**
     * 配置第一個數據源的RedisTemplate
     * 注意：這里指定使用名稱=factory 的 RedisConnectionFactory
     * 并且標識第一個數據源是默認數據源 @Primary
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean("redisTemplate")
    @Primary
    public RedisTemplate redisTemplate(@Qualifier("lettuceConnectionFactory") RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
 
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(stringRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(stringRedisSerializer);
        template.afterPropertiesSet();
 
        return template;
    }
 
    @Bean
    public GenericObjectPoolConfig redisPool2() {
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        config.setMinIdle(Convert.toInt(min_idle));
        config.setMaxIdle(Convert.toInt(max_idle));
        config.setMaxTotal(Convert.toInt(max_active));
        config.setMaxWaitMillis(Convert.toInt(max_wait));
        return config;
    }
 
    @Bean
    public RedisStandaloneConfiguration redisConfig2() {
        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration(host,Convert.toInt(port));
        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("redisTemplateSingle")
    public RedisTemplate<String, Object> redisTemplateSingle(@Qualifier("factory2")LettuceConnectionFactory connectionFactory) {//注意傳入的對象名
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
 
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setValueSerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        redisTemplate.setHashValueSerializer(redisSerializer);
        return redisTemplate;
    }
}

三、使用redis

使用單實例redis

/**
     * redis 單節點
     */
    @Resource(name = "redisTemplateSingle")
    private RedisTemplate redisTemplateSingle;

使用redis集群

/**
     * redis 集群
     */
    @Resource(name = "redisTemplate")
    private RedisTemplate redisTemplate;

關于“springboot redis如何使用lettuce配置多數據源”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。