java学习之路笔记（二）：SpringBoot配置多数据源redis

最新推荐文章于 2024-09-15 18:07:28 发布

dinghomie

最新推荐文章于 2024-09-15 18:07:28 发布

阅读量201

点赞数

文章标签： redis java

本文链接：https://blog.youkuaiyun.com/dinghomie/article/details/100123486

版权

本文介绍如何在SpringBoot中配置多数据源Redis，解决分库问题。通过YML配置和序列化方式调整，实现了动态获取不同数据源，并提供测试类验证配置效果。配置过程中遇到的特殊字符序列化错误也得到了解决。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

SpringBoot配置多数据源redis

继上次配置redis之后拿到客户redis库发现，redis是进行了分库，按照原先的写法，我们只能获取redis库的第一个库，默认database也为0
在这里插入图片描述

所以还得重新进行配置一次动态获取不同数据源的方式

如下yml配置

redis:
    host: 127.0.0.1
    port: 6379
    dataone: 0
    datatwo: 1
    datathree: 2
    datafour: 3  #这里是你每个库的所在位置
    password:
    keytimeout: 1000
    timeout: 0
    pool:
      max-active: 8
      max-wait: -1
      max-idle: 8
      min-idle: 0

配置类更改后，这里对每个数据源进行配置

中途一直遇到取值特殊符号序列化错误，序列化方式进行修改后才取值成功

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Value("${spring.redis.host}")
    private String hostName;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${spring.redis.pool.max-idle}")
    private int maxIdl;
    @Value("${spring.redis.pool.min-idle}")
    private int minIdl;
    @Value("${spring.redis.dataone}")
    private int database1;
    @Value("${spring.redis.datatwo}")
    private int database2;
    @Value("${spring.redis.datathree}")
    private int database3;
    @Value("${spring.redis.datafour}")
    private int database4;
    /**
     * retemplate相关配置
     * @return
     */
    @Bean(name = "redisTemplateOne")
    public RedisTemplate<String, Object> redisTemplateOne() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(redisConnectionFactoryOne());
        template = buildRedisTemplate(template);
        return template;
    }
    @Bean(name = "redisTemplateTwo")
    public RedisTemplate<String, Object> redisTemplateTwo() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(redisConnectionFactoryTwo());
        template = buildRedisTemplate(template);
        return template;
    }
    @Bean(name = "redisTemplateThree")
    public RedisTemplate<String, Object> redisTemplateThree() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(redisConnectionFactoryThree());
        template = buildRedisTemplate(template);
        return template;
    }
    @Bean(name = "redisTemplateFour")
    public RedisTemplate<String, Object> redisTemplateFour() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(redisConnectionFactoryFour());
        template = buildRedisTemplate(template);
        return template;
    }


    public JedisConnectionFactory buildJedisConnectionFactory() {
        JedisPoolConfig poolConfig=new JedisPoolConfig();
        poolConfig.setMaxIdle(maxIdl);
        poolConfig.setMinIdle(minIdl);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(true);
        poolConfig.setTestWhileIdle(true);
        poolConfig.setNumTestsPerEvictionRun(10);
        poolConfig.setTimeBetweenEvictionRunsMillis(60000);
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(poolConfig);
        jedisConnectionFactory.setHostName(hostName);
        if(!password.isEmpty()){
            jedisConnectionFactory.setPassword(password);
        }
        jedisConnectionFactory.setPort(port);
        return jedisConnectionFactory;
    }
    public RedisConnectionFactory redisConnectionFactoryOne(){
        JedisConnectionFactory jedisConnectionFactory = buildJedisConnectionFactory();
        jedisConnectionFactory.setDatabase(database1);
        return jedisConnectionFactory;
    }
    public RedisConnectionFactory redisConnectionFactoryTwo(){
        JedisConnectionFactory jedisConnectionFactory = buildJedisConnectionFactory();
        jedisConnectionFactory.setDatabase(database2);
        return jedisConnectionFactory;
    }
    public RedisConnectionFactory redisConnectionFactoryThree(){
        JedisConnectionFactory jedisConnectionFactory = buildJedisConnectionFactory();
        jedisConnectionFactory.setDatabase(database3);
        return jedisConnectionFactory;
    }
    public RedisConnectionFactory redisConnectionFactoryFour(){
        JedisConnectionFactory jedisConnectionFactory = buildJedisConnectionFactory();
        jedisConnectionFactory.setDatabase(database4);
        return jedisConnectionFactory;
    }

    public RedisTemplate<String, Object> buildRedisTemplate(RedisTemplate<String, Object> template) {
        // 使用 StringRedisSerializer 做序列化
        StringRedisSerializer jacksonSeial = new StringRedisSerializer();

        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(jacksonSeial);

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(jacksonSeial);
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }

写一个测试类进行测试

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ApplicationTests {

    @Qualifier("redisTemplateOne")
    @Autowired
    RedisTemplate redisTemplateOne;
    @Qualifier("redisTemplateTwo")
    @Autowired
    RedisTemplate redisTemplateTwo;

    @Test
    public void contextLoads() {
        RedisUtil redisUtil1 = new RedisUtil(redisTemplateOne);
        RedisUtil redisUtil1 = new RedisUtil(redisTemplateTwo);
        System.out.println(redisUtil1.hget("你的key", "你的fied"));
        System.out.println(redisUtil2.get("你的key"));
    }
}