SpringBoot 2.6.X Redis多数据源，多数据库连接

前言

官方对应2.0连接Redis需要不停的刷新，重新加载配置，如下代码

    /**
     * 切换Redis数据库
     * @param redisTemplate Redis连接
     * @param database 第几个数据库
     * @return 切换好的redis连接
     */
    public static RedisTemplate<String, Object> changeRedisDatabase(RedisTemplate<String, Object> redisTemplate, int database) {
        LettuceConnectionFactory lettuceConnectionFactory = (LettuceConnectionFactory)redisTemplate.getConnectionFactory();
        if (lettuceConnectionFactory == null) {
            LOGGER.error("Redis连接工厂为空，未能切换数据库");
            return redisTemplate;
        }
        lettuceConnectionFactory.setDatabase(database);
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        lettuceConnectionFactory.resetConnection();
        lettuceConnectionFactory.afterPropertiesSet();
        return redisTemplate;
    }

多数据源，多数据库配置

Yml配置

redis:
  config:
    - key: redis-0
      hostName: 172.16.54.209
      port: 6379
      database:
        - 0
    - key: redis-1
      hostName: 172.16.54.209
      port: 6380
      database:
        - 0
        - 1
        - 2
        - 3
        - 4

读取对应配置

package com.lihan.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Data
@Component
@ConfigurationProperties(prefix = "redis")
public class RedisConfigProperties {

    private List<RedisProperties> config = new ArrayList<>();

    @Data
    public static class RedisProperties {
        /**
         * Redis 别名，通过key获取对应连接
         */
        private String key;
        /**
         * Redis 连接地址
         */
        private String hostName;

        /**
         * Redis 连接端口
         */
        private Integer port;

        /**
         * Redis 使用到的数据库
         */
        private Integer[] database;

        /**
         * 用户名
         */
        private String username;

        /**
         * 密码
         */
        private String password;
    }
}

生成对应Bean

package com.lihan.config;

import com.lihan.properties.RedisConfigProperties;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Configuration
public class RedisConfigUp {

    /**
     * Redis多数据库Bean
     */
    @Bean
    public Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase(RedisConfigProperties redisConfigProperties) {
        Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase = new HashMap<>();
        List<RedisConfigProperties.RedisProperties> redisProperties = redisConfigProperties.getConfig();
        for (RedisConfigProperties.RedisProperties redisPropertiesTemp : redisProperties) {

            Map<String, RedisTemplate<String, Object>> redisTemplateMap = new HashMap<>();

            for (Integer database : redisPropertiesTemp.getDatabase()) {
                // 1. 配置连接
                RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
                redisStandaloneConfiguration.setHostName(redisPropertiesTemp.getHostName());
                redisStandaloneConfiguration.setPort(redisPropertiesTemp.getPort());
                if (redisPropertiesTemp.getUsername() != null && redisPropertiesTemp.getUsername().length() > 0) {
                    redisStandaloneConfiguration.setUsername(redisPropertiesTemp.getUsername());
                }
                if (redisPropertiesTemp.getPassword() != null && redisPropertiesTemp.getPassword().length() > 0) {
                    redisStandaloneConfiguration.setPassword(redisPropertiesTemp.getPassword());
                }
                // 2.配置数据库
                redisStandaloneConfiguration.setDatabase(database);

                // 3.设置连接池
                GenericObjectPoolConfig<RedisStandaloneConfiguration> genericObjectPoolConfig = new GenericObjectPoolConfig<>();
                LettuceClientConfiguration lettuceClientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(genericObjectPoolConfig).build();
                LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(redisStandaloneConfiguration, lettuceClientConfiguration);
                lettuceConnectionFactory.afterPropertiesSet();
                RedisTemplate<String, Object> template = new RedisTemplate<>();
                template.setConnectionFactory(lettuceConnectionFactory);
                // key采用String的序列化方式
                template.setKeySerializer(new StringRedisSerializer());
                // value序列化方式采用jdk
                template.setValueSerializer(new StringRedisSerializer());
                template.afterPropertiesSet();
                // Key 数据库名，value redis操作类
                redisTemplateMap.put(String.valueOf(database), template);
            }
            redisTemplateDatabase.put(redisPropertiesTemp.getKey(), redisTemplateMap);
        }
        return redisTemplateDatabase;
    }
}

对应工具类

package com.lihan.util;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class RedisUtils {

    private static Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase;

    /**
     * 放入Redis
     * @param redisKey 对应Redis连接Key
     * @param database 对应数据库
     * @param key 放入的Key
     * @param Value 放入的Value
     */
    public static void set(String redisKey, String database, String key, Object Value) {
        Map<String, RedisTemplate<String, Object>> stringRedisTemplateMap = redisTemplateDatabase.get(redisKey);
        stringRedisTemplateMap.get(database).opsForValue().set(key, Value);
    }

    /**
     * 取出Redis对应Redis值
     * @param redisKey 对应Redis连接Key
     * @param database 对应数据库
     * @param key 取值的Key
     * @return key对应的Value
     */
    public static Object get(String redisKey, String database, String key) {
        Map<String, RedisTemplate<String, Object>> stringRedisTemplateMap = redisTemplateDatabase.get(redisKey);
        return stringRedisTemplateMap.get(database).opsForValue().get(key);
    }

    public RedisUtils(Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase) {
        RedisUtils.redisTemplateDatabase = redisTemplateDatabase;
    }
}

对应工具类

package com.lihan.util;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class RedisUtils {

    private static Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase;

    /**
     * 放入Redis
     * @param redisKey 对应Redis连接Key
     * @param database 对应数据库
     * @param key 放入的Key
     * @param Value 放入的Value
     */
    public static void set(String redisKey, String database, String key, Object Value) {
        Map<String, RedisTemplate<String, Object>> stringRedisTemplateMap = redisTemplateDatabase.get(redisKey);
        stringRedisTemplateMap.get(database).opsForValue().set(key, Value);
    }

    /**
     * 取出Redis对应Redis值
     * @param redisKey 对应Redis连接Key
     * @param database 对应数据库
     * @param key 取值的Key
     * @return key对应的Value
     */
    public static Object get(String redisKey, String database, String key) {
        Map<String, RedisTemplate<String, Object>> stringRedisTemplateMap = redisTemplateDatabase.get(redisKey);
        return stringRedisTemplateMap.get(database).opsForValue().get(key);
    }

    public RedisUtils(Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase) {
        RedisUtils.redisTemplateDatabase = redisTemplateDatabase;
    }
}

测试

    @Test
    public void test02() {
        RedisUtils.set("redis-1", "0", "test-0", "test-0");
        RedisUtils.set("redis-1", "1", "test-1", "test-1");
        RedisUtils.set("redis-1", "2", "test-2", "test-2");
        RedisUtils.set("redis-1", "3", "test-3", "test-3");
        RedisUtils.set("redis-1", "4", "test-4", "test-4");

    }

    @Test
    public void test03() {
        System.out.println(RedisUtils.get("redis-1", "0", "test-0"));
    }