SpringBoot Redis 多数据源配置

SpringBoot Redis 多数据源配置

引入 maven 依赖

    以下依赖按需引入

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
    </dependency>
    <dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

添加 Properties

RedisDynamicProperties.class

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

import java.util.Map;

/**
 * Redis 多数据源配置
 */
@Data
@Component
@ConfigurationProperties(prefix = "onovo.redis.dynamic")
public class RedisDynamicProperties {

    /**
     * 多个 redis 配置
     */
    private Map<String, RedisDynamicItemPropertie> datasource;

}

RedisDynamicProperties.class

import lombok.Data;

/**
 * Redis 多数据源配置项
 */
@Data
public class RedisDynamicItemPropertie {

    /**
     * 数据库编号
     */
    private int database = 0;

    /**
     * 主机名
     */
    private String host = "localhost";

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

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

    /**
     * 端口
     */
    private int port = 6379;

    /**
     * 超时时间（秒）
     */
    private long timeout = 10;

    /**
     * 资源池最大连接数
     */
    private int maxTotal = 8;

    /**
     * 资源池允许最大空闲连接数
     */
    private int maxIdle = 8;

    /**
     * 资源池确保最少空闲连接数
     */
    private int minIdle = 0;

    /**
     * 当资源池连接用尽后，调用者的最大等待时间（单位毫秒）
     */
    private long maxWaitMillis = -1L;

}

启动类添加 Properties 配置注解

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

@SpringBootApplication
@EnableConfigurationProperties({RedisDynamicProperties.class})
public class DkModifyStatisticsApplication {

    public static void main(String[] args) {
        SpringApplication.run(DkModifyStatisticsApplication.class, args);
    }

}

添加 Config 按需修改

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
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.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;
import java.util.Map;

/*
 * Redis 多数据源配置
 */
@Configuration
public class RedisDynamicConfig {

    /**
     * 获取 redis 连接模板
     * @param propertie
     * @return
     */
    private RedisTemplate<String, Object> getRedisTemplate(RedisDynamicItemPropertie propertie) {
        // 构建工厂对象
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(propertie.getHost());
        config.setPort(propertie.getPort());
        config.setPassword(RedisPassword.of(propertie.getPassword()));

        // 配置redis连接池
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(propertie.getMaxTotal());
        poolConfig.setMaxIdle(propertie.getMaxIdle());
        poolConfig.setMinIdle(propertie.getMinIdle());
        poolConfig.setMaxWaitMillis(propertie.getMaxWaitMillis());

        LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofSeconds(propertie.getTimeout()))
                .poolConfig(poolConfig)
                .build();

        LettuceConnectionFactory factory = new LettuceConnectionFactory(config, clientConfig);
        // 设置使用的redis数据库
        factory.setDatabase(propertie.getDatabase());
        // 重新初始化工厂
        factory.afterPropertiesSet();

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer<Object> jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
//        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        jacksonSeial.setObjectMapper(objectMapper);

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jacksonSeial);
        redisTemplate.setHashValueSerializer(jacksonSeial);

        redisTemplate.setConnectionFactory(factory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 注入 redis 模板1
     * @param redisDynamicProperties
     * @return
     */
//    @Primary
    @Bean("redisTemplate1")
    public RedisTemplate<String, Object> redisTemplate1(RedisDynamicProperties redisDynamicProperties) {
        return getRedisTemplate(redisDynamicProperties.getDatasource().get("redis1"));
    }

    /**
     * 注入 redis 模板2
     * @param redisDynamicProperties
     * @return
     */
    @Bean("redisTemplate2")
    public RedisTemplate<String, Object> redisTemplate2(RedisDynamicProperties redisDynamicProperties) {
        return getRedisTemplate(redisDynamicProperties.getDatasource().get("redis2"));
    }

}

添加配置文件

# 自定义 Redis 配置文件
onovo:
  # redis 多数据源配置
  redis:
    dynamic:
      datasource:
        # redis1
        redis1:
          host: xxxx.xxxx.xxxx.xxxx
          database: 1
        # redis2
        redis2:
          host: xxxx.xxxx.xxxx.xxxx
          database: 2

测试

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class ApplicationTests {
	@Resource(name = "redisTemplate1")
    private RedisTemplate<String, Object> redisTemplate1;

    @Resource(name = "redisTemplate2")
    private RedisTemplate<String, Object> redisTemplate2;

	@Test
	public void readRedis() {
		String str1 = redisTemplate1.opsForValue().get("user:1");
		String str2 = redisTemplate2.opsForValue().get("user:2");
		System.out.println(str1);
		System.out.println(str2);
	}

}