springboot通过配置文件配置两个单机redis

使用 Spring Boot 配置两个单机 Redis 的详细指南

概述

在现代软件开发中，Redis作为一种高性能的键值数据库，被广泛应用于缓存和数据存储等场景。本文将详细介绍如何在Spring Boot应用中配置两个单机Redis实例，并通过表格展示每个步骤的流程。

步骤流程表

步骤	描述
步骤 1	添加 Redis 依赖于项目中
步骤 2	在配置文件中配置两个 Redis 实例
步骤 3	编写 Redis 配置类
步骤 4	创建 Redis 服务类
步骤 5	测试 Redis 配置

步骤详解

步骤一：添加 Redis 依赖

首先，您需要在pom.xml中添加Spring Boot Redis的依赖。

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

• 该依赖包包含了Redis的自动配置及相关功能支持。

步骤二：在配置文件中配置两个 Redis 实例

在application.yml中配置两个Redis实例：

spring:
  redis:
    database: 0
    host: localhost
    port: 6379
    password: yourPassword1  #第一个 Redis 实例的密码
  redis2:
    database: 1
    host: localhost
    port: 6380
    password: yourPassword2  #第二个 Redis 实例的密码

• 此配置指定了两个Redis实例的连接信息，包括数据库编号、主机地址、端口以及密码。

步骤三：编写 Redis 配置类

接下来，我们需要为每个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.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;

@Configuration
@EnableRedisRepositories(basePackages = "com.example.repository")
public class RedisConfig {

    @Bean
    @Primary
    public RedisTemplate<String, Object> redisTemplate1(
        RedisProperties redisProperties) {
        // 创建第一个 RedisTemplate
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration(
            redisProperties.getHost(), redisProperties.getPort());
        return createRedisTemplate(configuration);
    }

    @Bean(name = "redisTemplate2")
    public RedisTemplate<String, Object> redisTemplate2(
        @Qualifier("redis2Properties") RedisProperties redisProperties) {
        // 创建第二个 RedisTemplate
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration(
            redisProperties.getHost(), redisProperties.getPort());
        return createRedisTemplate(configuration);
    }

    private RedisTemplate<String, Object> createRedisTemplate(
        RedisStandaloneConfiguration configuration) {
        // 初始化 RedisTemplate
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(new JedisConnectionFactory(configuration));
        return template;
    }
}

• 该类定义了两个RedisTemplate bean，分别用于操作两个Redis实例。

步骤四：创建 Redis 服务类

然后，您可以创建一个服务类，来使用这些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("redisTemplate1")
    private RedisTemplate<String, Object> redisTemplate1;

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

    public void setValueInRedis1(String key, Object value) {
        redisTemplate1.opsForValue().set(key, value);
    }

    public Object getValueFromRedis1(String key) {
        return redisTemplate1.opsForValue().get(key);
    }

    public void setValueInRedis2(String key, Object value) {
        redisTemplate2.opsForValue().set(key, value);
    }

    public Object getValueFromRedis2(String key) {
        return redisTemplate2.opsForValue().get(key);
    }
}

• 该服务类提供了对两个Redis实例的操作方法。

步骤五：测试 Redis 配置

最后，可以编写单元测试或使用控制器测试Redis的行为。

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/redis")
public class RedisController {

    private final RedisService redisService;

    public RedisController(RedisService redisService) {
        this.redisService = redisService;
    }

    @PostMapping("/set1")
    public void setValue1(@RequestParam String key, @RequestParam Object value) {
        redisService.setValueInRedis1(key, value);
    }

    @GetMapping("/get1")
    public Object getValue1(@RequestParam String key) {
        return redisService.getValueFromRedis1(key);
    }

    @PostMapping("/set2")
    public void setValue2(@RequestParam String key, @RequestParam Object value) {
        redisService.setValueInRedis2(key, value);
    }

    @GetMapping("/get2")
    public Object getValue2(@RequestParam String key) {
        return redisService.getValueFromRedis2(key);
    }
}

类图

我们可以使用以下的类图来表示系统的结构：

classDiagram
    class RedisConfig {
        +RedisTemplate redisTemplate1()
        +RedisTemplate redisTemplate2()
    }
    class RedisService {
        +void setValueInRedis1(String key, Object value)
        +Object getValueFromRedis1(String key)
        +void setValueInRedis2(String key, Object value)
        +Object getValueFromRedis2(String key)
    }
    class RedisController {
        +void setValue1(String key, Object value)
        +Object getValue1(String key)
        +void setValue2(String key, Object value)
        +Object getValue2(String key)
    }

旅行图

下面的旅行图显示了我们的执行流程：

journey
    title Spring Boot Redis Configuration Journey
    section Setup
      Add dependencies: 5: Developer
    section Configuration
      Configure application.yml: 3: Developer
      Create RedisConfig class: 4: Developer
    section Implementation
      Create RedisService: 4: Developer
      Create RedisController: 4: Developer
    section Testing
      Test API calls: 5: Developer

结论

通过以上步骤，您已经成功配置了两个单机Redis，并可通过不同的RedisTemplate进行操作。这是一个基本的示例，但可以适应更多复杂的场景，如集群Redis、缓存策略等。希望这篇文章对您有所帮助，祝您在实际开发中应用自如！