SoFunction
Updated on 2025-04-12

How to configure multiple Redis data sources (non-clustered) in Springboot

background

Recently, I encountered a scenario with multiple redis sources online, and a project requires integrating two redis.

At this time, use some data transmission and conversion tools, such as filebeat, logstash, kafka-connect, etc., which may be a good method, but due to historical reasons, you still need to integrate it yourself in the project. Just start to do it without saying much!

Introduce dependencies

The following is the pom file dependency configuration:

        <!-- springbootOfficial integrationredisrely, Use the version according to your own commonspringbootThe version comes -->
        <dependency>
            <groupId></groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.</version>
        </dependency>
        
        <!-- fastjsonrely -->
        <dependency>
            <groupId></groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.32</version>
        </dependency>
        
        <!-- Object Conversion Tool -->
        <dependency>
            <groupId></groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

Add Redis environment

Add redis configuration:

spring:
  # redis-1
  redis:
    database: 0
    # redis server address    host: 192.168.2.3
    # Redis Server Connection Port    port: 6379
    lettuce:
      pool:
        # Maximum number of connections in the connection pool (using negative values ​​to indicate no limit) Default 8        max-active: 8
        # Maximum blocking waiting time for connection pool (using negative values ​​to indicate no limit) Default -1        max-wait: -1
        # Maximum idle connection in connection pool Default 8        max-idle: 8
        # Minimum idle connection in connection pool Default 0        min-idle: 0
    # Redis server connection password (default is empty)    password: 123456
    timeout: 800
  # redis-2
  redis-live:
    database: 0
    host: 192.168.2.8
    port: 6379
    lettuce:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0
    password: 234567
    timeout: 800

Redis configuration

Next, I write the redis configuration class, and use different serialization methods according to needs when assembling different RedisTemplates, and introduce them as needed when using them. Here is my injection configuration:

import ;
import ;
import ;
import ;
import ;
import .;
import .;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import .Jackson2JsonRedisSerializer;
import ;

import ;

@Configuration
@EnableCaching
public class RedisTemplateConfig {

    /**
      * live data source
      */
    @Value("${}")
    private String redisLiveHost;

    @Value("${}")
    private int redisLivePort;

    @Value("${}")
    private String redisLivePass;

    @Value("${}")
    private int redisLiveDb;


    /**
      * Public configuration
      */
    @Value("${}")
    private long timeout;

    @Value("${-idle}")
    private int minIdle;

    @Value("${-idle}")
    private int maxIdle;

    @Value("${-active}")
    private int maxActive;

    @Value("${-wait}")
    private int maxWait;

    /**
      * Assembly RedisTemplate
      */
//    @Bean(name = "redisTemplate")
//    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//        return createRedisTemplate(redisConnectionFactory);
//    }

    @Bean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        // The serialization of key uses StringRedisSerializer        (new StringRedisSerializer());
        (new StringRedisSerializer());
        (redisConnectionFactory);
        return template;
    }


    /**
      * Assembly StringRedisTemplate
      */
    @Bean(name = "stringRedisTemplate")
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return createStringRedisTemplate(redisConnectionFactory);
    }

    /**
      * Assembly live data source
      */
    @Bean(name = "liveStringRedisTemplate")
    public StringRedisTemplate liveStringRedisTemplate() {
        return createStringRedisTemplate(redisLiveHost, redisLivePort, redisLivePass, redisLiveDb);
    }

    /**
      * Create RedisTemplate
      */
    public RedisTemplate<Object, Object> createRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        ObjectMapper objectMapper = new ObjectMapper();
        (, );
        (, .NON_FINAL, );

        Jackson2JsonRedisSerializer<?> serializer = new Jackson2JsonRedisSerializer<>();
        (objectMapper);

        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        (redisConnectionFactory);
        (new StringRedisSerializer());
        (serializer);
        (new StringRedisSerializer());
        (serializer);
        ();
        return redisTemplate;
    }

    /**
      * Create StringRedisTemplate
      */
    public StringRedisTemplate createStringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        (redisConnectionFactory);
        return stringRedisTemplate;
    }

    /**
      * Create StringRedisTemplate
      */
    public StringRedisTemplate createStringRedisTemplate(String host, int port, String password, int database) {
        // Basic configuration        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
        (host);
        (port);
        (database);
        if ((password)) {
            RedisPassword redisPassword = (password);
            (redisPassword);
        }

        // General configuration of connection pool        GenericObjectPoolConfig<?> genericObjectPoolConfig = new GenericObjectPoolConfig<>();
        (maxActive);
        (minIdle);
        (maxIdle);
        (maxWait);

        // Lettuce Pool
         builder = ();
        (genericObjectPoolConfig);
        ((timeout));
        LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration, ());
        ();

        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        (connectionFactory);
        return stringRedisTemplate;
    }

}

Pay attention here

@Bean(name = "liveStringRedisTemplate")

Leave the class to spring, and the reference will be introduced according to the name later.

use

When using it, we use @Qualifier to display the reference object:

	// redis-1
    @Autowired
    @Qualifier("redisTemplate")
    private RedisTemplate<String, String> redisTemplate;

    // redis-2
    @Autowired
    @Qualifier("liveStringRedisTemplate")
    private RedisTemplate<String, String> liveStringRedisTemplate;

Below we can use RedisTemplate to happily operate redis! At this point, springboot configures multiple data sources successfully. The RedisTemplate here can also be integrated into the tool class to make the operation more convenient!

Summarize

The above is personal experience. I hope you can give you a reference and I hope you can support me more.