求推荐Spring Boot Redis集成测试可靠库及嵌入式Redis测试方案

我之前也碰到过嵌入式Redis在Unix构建机上无日志、排查无门的窘境，给你几个经过实战验证的方案，既能搞定集成测试，又能解决跨环境稳定性和日志问题：

方案一：优化现有embedded-redis，补全日志+适配Unix环境 #

如果不想换库，可以先解决日志和环境适配问题，快速定位构建机失败原因：

1. 补全日志输出 #

在测试资源目录下新建logback-test.xml，把嵌入式Redis的日志级别调到DEBUG，这样构建机上就能看到详细启动日志：

<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 开启embedded-redis的DEBUG日志 -->
    <logger name="redis.embedded" level="DEBUG" additivity="false">
        <appender-ref ref="CONSOLE"/>
    </logger>

    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

2. 适配Unix环境的启动参数 #

Unix构建机上经常遇到端口占用、保护模式限制等问题，调整启动逻辑：

import redis.embedded.RedisServer;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;

public abstract class BaseRedisIntegrationTest {
    private static RedisServer redisServer;

    @BeforeAll
    static void startRedis() {
        // 随机分配端口，避免构建机上端口冲突
        redisServer = RedisServer.builder()
                .port(0)
                .setting("protected-mode no") // 禁用Unix环境下的保护模式
                .setting("logfile /dev/stdout") // 让Redis日志输出到标准输出，方便捕获
                .build();
        redisServer.start();
    }

    @DynamicPropertySource
    static void redisProperties(DynamicPropertyRegistry registry) {
        // 把随机端口注入到Spring配置中
        registry.add("spring.redis.port", redisServer::getPort);
    }

    @AfterAll
    static void stopRedis() {
        if (redisServer != null) {
            redisServer.stop();
        }
    }
}

之后你的集成测试类继承这个基类即可，构建机上的日志会清晰展示Redis启动失败的具体原因（比如权限、依赖缺失）。

方案二：改用Testcontainers（跨环境稳定，日志完整） #

如果嵌入式Redis的跨环境问题始终无法解决，推荐用Testcontainers，它会启动真实的Redis容器，本地和Unix构建机环境完全一致，日志也完整可查，是当前Spring Boot集成测试的最佳实践之一：

1. 添加依赖（Maven为例） #

<dependencies>
    <!-- Testcontainers Redis支持 -->
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>redis</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- Testcontainers JUnit 5支持 -->
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>junit-jupiter</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2. 编写测试配置类 #

import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.utility.DockerImageName;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

@TestConfiguration
public class TestRedisContainerConfig {

    @Bean(destroyMethod = "stop")
    public GenericContainer<?> redisContainer() {
        GenericContainer<?> redisContainer = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
                .withExposedPorts(6379);
        redisContainer.start();
        return redisContainer;
    }

    @Bean
    public RedisConnectionFactory redisConnectionFactory(GenericContainer<?> redisContainer) {
        return new LettuceConnectionFactory(
                redisContainer.getHost(),
                redisContainer.getMappedPort(6379)
        );
    }
}

3. 在集成测试中使用 #

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.Import;

@SpringBootTest
@Import(TestRedisContainerConfig.class)
public class RedisCacheIntegrationTest {
    // 你的测试逻辑，比如调用带@Cacheable的服务，验证缓存生效
}

Testcontainers会自动拉取Redis镜像（首次运行后缓存），启动容器并注入连接配置，构建机上只要支持Docker就能正常运行，容器的所有日志都会输出到CI构建日志中，排查问题非常方便。

方案三：纯内存缓存模拟（适合轻量缓存逻辑测试） #

如果你的测试只需要验证缓存注解的逻辑，不需要真实Redis的特性，可以用Spring提供的内存缓存替代：

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;

@SpringBootTest
@EnableCaching
public class CacheLogicIntegrationTest {

    @Primary
    @Bean
    public ConcurrentMapCacheManager cacheManager() {
        return new ConcurrentMapCacheManager("your-cache-name");
    }

    // 测试缓存的存、取、失效逻辑即可
}

这个方案不需要任何外部依赖，速度快，但无法测试Redis特有的功能（比如过期时间、分布式特性）。

内容的提问来源于stack exchange，提问作者aspiringCoder