# 单元测试 Spring 缓存 ## 概述该技能提供了在没有完整 Spring 上下文的情况下对 Spring 缓存注释（@Cacheable、@CacheEvict、@CachePut）进行单元测试的模式。它涵盖测试缓存行为、命中/未命中、失效策略、缓存键生成以及使用内存缓存管理器的条件缓存。 ## 何时使用在以下情况下使用此技能： * 测试@Cacheable方法缓存 * 测试@CacheEvict缓存失效 * 测试@CachePut缓存更新 * 验证缓存密钥生成 * 测试条件缓存 * 想要在没有 Redis 或缓存基础设施的情况下进行快速缓存测试 ## 说明 1. **使用内存CacheManager** ：使用ConcurrentMapCacheManager进行测试，而不是Redis或其他外部缓存 2. **验证存储库调用计数** ：使用 `times(n)` 通过计算存储库调用来验证缓存命中/未命中 3. **测试缓存和逐出场景**：验证数据在第一次调用时缓存并在适当时逐出 4. **测试缓存密钥生成** : 确保 `@Cacheable(key = "...")` 中的 SpEL 表达式生成正确的密钥 5. **测试条件缓存** : 验证 `unless` 和 `condition` 参数是否正常工作 6. **在测试之间清除缓存** ：在@BeforeEach中重置缓存状态或使用@DirtiesContext 7. **模拟服务依赖项** ：对缓存层使用的存储库和其他服务使用模拟 8. **显式验证缓存行为**：不依赖计时；验证实际的缓存命中/未命中行为 ## 示例 ## 设置：缓存测试 ### Maven <依赖关系> org.springframework.boot spring-boot-starter-cache <依赖关系> org.springframework.boot spring-boot-starter-test <范围>测试 <依赖关系> org.mockito mockito-core <范围>测试 <依赖关系> org.assertj assertj-core <范围>测试 ### 摇篮依赖项{ 实现（“org.springframework.boot：spring-boot-starter-cache”） testImplementation("org.springframework.boot:spring-boot-starter-test") testImplementation("org.mockito:mockito-core") testImplementation("org.assertj:assertj-core") } ## 基本模式：测试@Cacheable ### 缓存命中和未命中行为 // 带缓存的服务 @服务公共类用户服务{ 私有最终 UserRepository userRepository; 公共 UserService(UserRepository userRepository) { this.userRepository = userRepository; } @Cacheable(“用户”) 公共用户 getUserById(长 id) { return userRepository.findById(id).orElse(null); } } // 测试缓存行为导入 org.junit.jupiter.api.Test; 导入 org.junit.jupiter.api.BeforeEach; 导入 org.springframework.cache.CacheManager; 导入 org.springframework.cache.annotation.EnableCaching; 导入 org.springframework.cache.concurrent.ConcurrentMapCacheManager; 导入 org.springframework.context.annotation.Bean; 导入 org.springframework.context.annotation.Configuration; 导入静态 org.mockito.Mockito.*; 导入静态 org.assertj.core.api.Assertions.*; @配置 @启用缓存类 CacheTestConfig { @豆子公共 CacheManager 缓存管理器() { 返回新的ConcurrentMapCacheManager(“用户”); } } 类 UserServiceCachingTest { 私有 UserRepository 用户存储库；私有 UserService 用户服务；私有 CacheManager 缓存管理器； @BeforeEach 无效设置（）{ userRepository = mock(UserRepository.class); cacheManager = new ConcurrentMapCacheManager("用户"); userService = new UserService(userRepository); } @测试无效shouldCacheUserAfterFirstCall（）{ 用户用户=新用户（1L，“爱丽丝”）； when(userRepository.findById(1L)).thenReturn(Optional.of(user)); 用户firstCall = userService.getUserById(1L); 用户 SecondCall = userService.getUserById(1L); assertThat(firstCall).isEqualTo(secondCall); 验证(userRepository, times(1)).findById(1L); // 由于缓存只调用一次 } @测试无效shouldReturnCachedValueOnSecondCall（）{ 用户用户=新用户（1L，“爱丽丝”）； when(userRepository.findById(1L)).thenReturn(Optional.of(user)); userService.getUserById(1L); // 第一次调用 - 命中数据库用户cachedResult = userService.getUserById(1L); // 第二次调用 - 命中缓存 assertThat(cachedResult).isEqualTo(用户); 验证(userRepository, times(1)).findById(1L); } } ## 测试@CacheEvict ### 缓存失效 @服务公共类产品服务{ 私有最终 ProductRepository 产品存储库；公共 ProductService(ProductRepository ProductRepository) { this.productRepository = ProductRepository; } @Cacheable(“产品”) 公共产品 getProductById(长 id) { 返回productRepository.findById(id).orElse(null); } @CacheEvict(“产品”) 公共无效deleteProduct（长id）{ 产品Repository.deleteById(id); } @CacheEvict(value = "产品", allEntries = true) 公共无效clearAllProducts（）{ // 清除整个缓存 } } 类 ProductCacheEvictTest { 私有 ProductRepository 产品存储库；私人产品服务产品服务；私有 CacheManager 缓存管理器； @BeforeEach 无效设置（）{ ProductRepository = 模拟(ProductRepository.class); cacheManager = new ConcurrentMapCacheManager("产品"); 产品服务 = 新产品服务（产品存储库）； } @测试无效shouldEvictProductFromCacheWhenDeleted（）{ 产品产品 = 新产品(1L, "笔记本电脑", 999.99); when(productRepository.findById(1L)).thenReturn(Optional.of(product)); ProductService.getProductById(1L); // 缓存产品产品服务.删除产品(1L); // 从缓存中逐出用户cachedAfterEvict = userService.getUserById(1L); // 驱逐后，应再次调用存储库验证(productRepository, times(2)).findById(1L); } @测试无效shouldClearAllEntriesFromCache() { 产品product1 = 新产品(1L, "笔记本电脑", 999.99); 产品product2 = 新产品(2L, "鼠标", 29.99); when(productRepository.findById(1L)).thenReturn(Optional.of(product1)); when(productRepository.findById(2L)).thenReturn(Optional.of(product2)); ProductService.getProductById(1L); ProductService.getProductById(2L); 产品服务.clearAllProducts(); // 清除所有缓存条目 ProductService.getProductById(1L); ProductService.getProductById(2L); // 存储库为每个产品调用两次验证(productRepository, times(2)).findById(1L); 验证(productRepository, times(2)).findById(2L); } } ## 测试@CachePut ### 缓存更新 @服务公共类 OrderService { 私有最终 OrderRepository orderRepository; 公共 OrderService(OrderRepository orderRepository) { this.orderRepository = orderRepository; } @Cacheable(“订单”) 公共订单 getOrder(长 id) { 返回 orderRepository.findById(id).orElse(null); } @CachePut(value = "订单", key = "#order.id") 公共订单 updateOrder(订单 order) { 返回 orderRepository.save(order); } } 类 OrderCachePutTest { 私有 OrderRepository orderRepository；私有 OrderService orderService； @BeforeEach 无效设置（）{ orderRepository = mock(OrderRepository.class); orderService = new OrderService(orderRepository); } @测试无效shouldUpdateCacheWhenOrderIsUpdated() { 订单原始订单 = 新订单(1L, "待处理", 100.0); 订单更新订单 = 新订单(1L, "已发货", 100.0); when(orderRepository.findById(1L)).thenReturn(Optional.of(originalOrder)); when(orderRepository.save(updatedOrder)).thenReturn(updatedOrder); orderService.getOrder(1L); 订单结果 = orderService.updateOrder(updatedOrder); assertThat(result.getStatus()).isEqualTo("已发货"); // 下一次调用应该从缓存返回更新的版本订单cachedOrder = orderService.getOrder(1L); assertThat(cachedOrder.getStatus()).isEqualTo("已发货"); } } ## 测试条件缓存 ### 有条件缓存 @服务公共类数据服务{ 私有最终 DataRepository dataRepository；公共数据服务（数据存储库数据存储库）{ this.dataRepository = dataRepository; } @Cacheable(value = "data", 除非 = "#result == null") 公共数据 getData(长 id) { 返回 dataRepository.findById(id).orElse(null); } @Cacheable(值 = "用户", 条件 = "#id > 0") 公共用户 getUser(长 id) { return userRepository.findById(id).orElse(null); } } 类条件缓存测试 { @测试无效shouldNotCacheNullResults() { DataRepository dataRepository = mock(DataRepository.class); when(dataRepository.findById(999L)).thenReturn(Optional.empty()); DataService 服务 = new DataService(dataRepository); 服务.getData(999L); 服务.getData(999L); // 应该调用存储库两次，因为空结果不会被缓存验证(dataRepository, times(2)).findById(999L); } @测试无效shouldNotCacheWhenConditionIsFalse() { UserRepository userRepository = mock(UserRepository.class); 用户用户=新用户（1L，“爱丽丝”）； when(userRepository.findById(-1L)).thenReturn(Optional.of(user)); DataService 服务 = new DataService(null); service.getUser(-1L); service.getUser(-1L); // 应该调用存储库两次，因为 id <= 0 与条件不匹配验证(userRepository, times(2)).findById(-1L); } } ## 测试缓存键 ### 验证缓存密钥生成 @服务公共类 InventoryService { 私有最终 InventoryRepository inventoryRepository；公共 InventoryService(InventoryRepository inventoryRepository) { this.inventoryRepository = inventoryRepository; } @Cacheable(value = "库存", key = "#productId + '-' + #warehouseId") 公共InventoryItem getInventory（长产品Id，长仓库Id）{ return inventoryRepository.findByProductAndWarehouse(productId,WarehouseId); } } 类 CacheKeyTest { @测试无效应该生成正确缓存密钥（）{ InventoryRepository存储库=模拟(InventoryRepository.class); 库存物品项 = 新库存物品(1L, 1L, 100); when(repository.findByProductAndWarehouse(1L, 1L)).thenReturn(item); InventoryService 服务 = new InventoryService(存储库); service.getInventory(1L, 1L); // 缓存：“1-1” service.getInventory(1L, 1L); // 命中缓存：“1-1” service.getInventory(2L, 1L); // 未命中缓存：“2-1” verify(repository, times(2)).findByProductAndWarehouse(any(), any()); } } ## 最佳实践 * **使用内存中的CacheManager**进行单元测试 * **验证存储库调用**以确认缓存命中/未命中 * **测试正面和负面**缓存场景 * **彻底测试缓存失效** * **使用各种条件测试条件缓存** * **在测试中保持缓存配置简单** * **服务使用的模拟依赖关系** ## 常见陷阱 * 测试实际的缓存基础设施而不是缓存逻辑 * 不验证存储库调用计数 * 忘记测试缓存驱逐 * 不测试条件缓存 * 在测试之间不重置缓存 ## 限制和警告 * **@Cacheable 需要代理** ：Spring 的缓存通过代理进行工作；直接方法调用绕过缓存 * **缓存密钥冲突** ：请注意，如果密钥生成不特定，则不同的参数可以生成相同的缓存密钥 * **序列化要求** ：使用分布式缓存时，缓存对象必须是可序列化的 * **内存使用**：内存中的缓存可能会消耗大量内存；考虑 TTL 和最大大小设置 * **@CachePut 与 @Cacheable** ：@CachePut 始终执行该方法，而 @Cacheable 在缓存命中时跳过执行 * **空缓存** ：默认情况下，除非指定`unless = "#result == null"`，否则会缓存空结果 * **线程安全** ：缓存操作应该是线程安全的；验证并发访问下的行为 ## 故障排除 **缓存在测试中不起作用**：确保“@EnableCaching”位于测试配置中。 **生成错误的缓存密钥**：在`@Cacheable(key = "...")`中正确使用`SpEL`语法。 **缓存不驱逐**：验证“@CacheEvict”密钥与存储的密钥完全匹配。 ## 参考文献 * [Spring 缓存文档]() * [Spring 缓存抽象]() * [缓存中的 SpEL]()

单元测试缓存

包含技能