【Spring】如何同时启用多个Redis连接

Java Spring

发布日期: 2025-02-24

更新日期: 2025-02-25

文章字数: 917

阅读时长: 4 分

阅读次数:

问题背景

在实际应用中，可能需要连接多个 Redis 实例，例如一个用于缓存，另一个用于消息队列或其他用途。Spring 提供了灵活的方式来配置多个 Redis 连接，以便在同一个应用中使用。

解决方案

1. 添加依赖

首先，确保在 pom.xml 中添加了 Spring Data Redis 和 Redis 客户端的依赖。例如，如果使用 Jedis，可以添加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

2. 配置多个 Redis 连接

在 application.yml 或 application.properties 中配置多个 Redis 连接。例如：

spring:
  redis:
    primary:
      host: localhost
      port: 6379
      password: yourpassword
    secondary:
      host: localhost
      port: 6380
      password: yourpassword

3. 创建 Redis 配置类

为每个 Redis 连接创建配置类，并使用 @Primary 注解标记主 Redis 连接。

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
public class RedisConfig {

    @Primary
    @Bean(name = "primaryRedisConnectionFactory")
    public RedisConnectionFactory primaryRedisConnectionFactory(RedisProperties properties) {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName(properties.getPrimary().getHost());
        factory.setPort(properties.getPrimary().getPort());
        factory.setPassword(properties.getPrimary().getPassword());
        return factory;
    }

    @Bean(name = "secondaryRedisConnectionFactory")
    public RedisConnectionFactory secondaryRedisConnectionFactory(RedisProperties properties) {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName(properties.getSecondary().getHost());
        factory.setPort(properties.getSecondary().getPort());
        factory.setPassword(properties.getSecondary().getPassword());
        return factory;
    }

    @Primary
    @Bean(name = "primaryRedisTemplate")
    public RedisTemplate<String, Object> primaryRedisTemplate(
            @Qualifier("primaryRedisConnectionFactory") RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        return template;
    }

    @Bean(name = "secondaryRedisTemplate")
    public RedisTemplate<String, Object> secondaryRedisTemplate(
            @Qualifier("secondaryRedisConnectionFactory") RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        return template;
    }
}

4. 使用示例

在服务层中使用不同的 Redis 连接：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

    @Autowired
    @Qualifier("primaryRedisTemplate")
    private RedisTemplate<String, Object> primaryRedisTemplate;

    @Autowired
    @Qualifier("secondaryRedisTemplate")
    private RedisTemplate<String, Object> secondaryRedisTemplate;

    public void saveToPrimary(String key, Object value) {
        primaryRedisTemplate.opsForValue().set(key, value);
    }

    public Object getFromPrimary(String key) {
        return primaryRedisTemplate.opsForValue().get(key);
    }

    public void saveToSecondary(String key, Object value) {
        secondaryRedisTemplate.opsForValue().set(key, value);
    }

    public Object getFromSecondary(String key) {
        return secondaryRedisTemplate.opsForValue().get(key);
    }
}

5. 测试验证

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class RedisServiceTest {

    @Autowired
    private RedisService redisService;

    @Test
    public void testRedisOperations() {
        redisService.saveToPrimary("key1", "value1");
        System.out.println(redisService.getFromPrimary("key1")); // 输出: value1

        redisService.saveToSecondary("key2", "value2");
        System.out.println(redisService.getFromSecondary("key2")); // 输出: value2
    }
}

最佳实践建议

使用配置文件管理 Redis 连接：将 Redis 连接的配置放在 application.yml 或 application.properties 中，便于管理和修改。
合理使用 RedisTemplate：根据业务需求选择合适的 RedisTemplate，避免不必要的性能损耗。
注意连接池配置：如果使用连接池，确保合理配置连接池的参数。
监控 Redis 性能：定期监控 Redis 的性能指标，确保系统的稳定性。