SpringCache缓存抽象之CacheManager与自定义键生成方式

2025-04-16 10:02 开发作者：程序媛学姐

一、Spring Cache基础架构

1.1 缓存抽象设计理念

Spring Cache的设计遵循了Spring一贯的理念：为特定技术提供高层次抽象，降低实现与业务代码的耦合度。缓存抽象层由注解驱动，支持声明式配置，大大简化了缓存操作的代码量。开发者只需关注缓存策略，无需编写重复的缓存逻辑。

这种设计使得切换不同的缓存提供商变得异常简单，增强了应用的可维护性与扩展性。

// 缓存抽象的关键注解示例
@Service
public class ProductService {
    
    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // 方法调用将被缓存，相同参数的重复调用直接返回缓存结果
        return productRepository.findById(id).orElse(null);
    }
    
    @CacheEvict(value = "products", key = "#product.id")
    public void updateProduct(Product product) {
        // 更新产品信息并清除对应的缓存条目
        productRepository.save(product);
    }
    
    @CachePut(value = "products", key = "#result.id")
    public Product createProduct(Product product) {
        // 创建产品并更新缓存，同时返回结果
        return productRepository.save(product);
    }
    
    @CacheEvict(value = "products", allEntries = true)
    public void clearProductCache() {
        // 清除products缓存中的所有条目
        System.out.println("产品缓存已清空");
    }
}

1.2 核心组件概述

Spring Cache架构由几个核心组件组成，各司其职又协同工作。Cache接口定义了缓存操作的基本行为；CacheManager负责创建、配置和管理Cache实例；KeyGenerator负责为缓存条目生成唯一键；CacheResolver在运行时决定使用哪个缓存。这些组件共同构成了灵活强大的缓存框架。其中，CacheManager是连接缓存抽象与具体实现的桥梁，是整个架构的核心。

// Spring Cache核心接口关系
public interface Cache {
    // 缓存的名称，用于标识不同的缓存
    String getName();
    
    // 底层的原生缓存，可转换为特定实现
    Object getNativeCache();
    
    // 根据键获取缓存值
    ValueWrapper get(Object key);
    
    // 将值存入缓存
    void put(Object key, Object value);
    
    // 从缓存中移除指定键的条目
    void evict(Object key);
    
    // 清除缓存中的所有条目
    void clear();
}

// CacheManager定义
public interface CacheManage编程客栈r {
    // 获取指定名称的缓存
    Cache getCache(String name);
    
    // 获取所有缓存名称的集合
    Collection<String> getCacheNames();
}

二、CacheManager深入解析

2.1 常用CacheManager实现

Spring框架提供了多种CacheManager实现，支持不同的缓存技术。ConcurrentMapCacheManager是基于ConcurrentHashMap的简单实现，适合开发和测试环境；EhCacheCacheManager集成了EhCache的高级特性；RedisCacheManager则提供了与Redis分布式缓存的集成，适用于生产环境。根据应用需求和性能要求，选择合适的CacheManager至关重要。每种实现都有其独特的配置方式和性能特点。

// 不同CacheManager的配置示例
@Configuration
@EnableCaching
public class CacheConfig {
    
    // 简单内存缓存配置
    @Bean
    public CacheManager concurrentMapCacheManager() {
        ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
        cacheManager.setCacheNames(Arrays.asList("products", "customers"));
        return cacheManager;
    }
    
    // Redis缓存配置
    @Bean
    public CacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10))  // 设置缓存过期时间
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2jsonRedisSerializer()));
                
        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .withCacheConfiguration("products", RedisCacheConfiguration
                        .defaultCacheConfig().entryTtl(Duration.ofMinutes(5)))
                .build();
    }
    
    // Caffeine缓存配置
    @Bean
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        
        // 为不同缓存设置不同的配置
        cacheManager.setCacheSpecification("products=maximumSize=500,expireAfterWrite=5m");
        cacheManager.setCacheSpecification("customers=maximumSize=1000,expireAfterWrite=10m");
        
        return cacheManager;
    }
}

2.2 复合缓存策略

在复杂应用中，单一缓存策略往往无法满足所有需求。Spring提供了CompositeCacheManager，允许组合多个CacheManager，构建多级缓存系统。例如，可以组合本地缓存(Caffeine)与分布式缓存(Redis)，前者提供高速访问，后者确保集群一致性。复合策略需要合理规划缓存数据流向和一致性维护机制，避免数据不一致问题。

// 复合缓存管理器配置
@Bean
public CacheManager compositeCacheManager(
        CaffeineCacheManager caffeineCacheManager,
        RedisCacheManager redisCacheManager) {
    
    // 创建复合缓存管理器
    CompositeCacheManager compositeCacheManager = new CompositeCacheManager(
            caffeineCacheManager,
            redisCacheManager
    );
    
    // 设置回退机制，当指定缓存不存在时创建默认缓存
    compositeCacheManager.setFallbackToNoOpCache(true);
    
    return compositeCacheManager;
}

// 缓存使用策略示例
@Service
public class TieredCacheService {
    
    // 使用本地缓存，适合高频访问数据
    @Cacheable(value = "localProducts", cacheManager = "caffeineCacheManager")
    public Product getProductForFrontend(Long id) {
        return productRepository.findById(id).orElse(null);
    }
    
    // 使用分布式缓存，适合集群共享数据
    @Cacheable(value = "sharedProducts", cacheManager = "redisCacheManager")
    public Product getProductForApi(Long id) {
        return productRepository.findById(id).orElse(null);
    }
    
    // 两级缓存同步更新
    @Caching(evict = {
        @CacheEvict(value = "localProducts", key = "#product.id", cacheManager = "caffeineCacheManager"),
        @CacheEvict(value = "sharedProducts", key = "#product.id", cacheManager = "redisCacheManager")
    })
    public void updateProduct(Product product) {
        productRepository.save(product);
    }
}

三、自定义键生成策略

3.1 默认键生成机制

Spring Cache默认使用SimpleKeyGenerator生成缓存键。对于无参方法，使用SimpleKey.EMPTY作为键；对于单参数方法，直接使用该参数作为键；对于多参数方法，使用包含所有参数的SimpleKey实例。这种机制简单实用，但在复杂场景下可能导致键冲突或难以管理。默认键生成逻辑缺乏对象属性选择能力，无法处理包含非缓存相关字段的复杂对象。

// 默认键生成器实现逻辑示意
public class SimpleKeyGenerator implements KeyGenerator {
    
    @Override
    public Object generate(Object target, Method method, Object... params) {
        if (params.length == 0) {
            return SimpleKey.EMPTY;
        }
        if (params.length == 1) {
            Object param = params[0];
            if (param != null && !param.getClass().isArray()) {
                return param;
            }
        }
        return new SimpleKey(params);
    }
}

// 默认键生成使用示例
@Cacheable("products") // 使用默认键生成器
public Product getProduct(Long id, String region) {
    // 缓存键将是SimpleKey(id, region)
    return productRepository.findByIdAndRegion(id, region);
}

3.2 自定义KeyGenerator实现

自定义KeyGenerator可以精确控制缓存键的生成逻辑。可以根据业务需求选择特定字段组合、应用哈希算法或添加前缀。例如，对于复杂查询参数，可以提取核心字段构建键；对于分区数据，可以添加租户ID前缀避免冲突。自定义生成器通过@Bean注册，并在@Cacheable注解中通过keyGenerator属性引用。

// 自定义键生成器实现
@Component("customKeyGenerator")
public class CustomKeyGenerator implements KeyGenerator {
    
    @Override
    public Object generate(Object target, Method method, Object... params) {
        StringBuilder keyBuilder = new StringBuilder();
        
        // 添加类名和方法名前缀
        keyBuilder.append(target.getClass().getSimpleName())
                 .append(".")
                 .append(method.getName());
        
        // 处理参数
        for (Object param : pahttp://www.devze.comrams) {
            keyBuilder.append(":");
            if (param instanceof Product) {
                // 对于产品对象，只使用ID和名称
                Product product = (Product) param;
                keyBuilder.append("Product[")
                         .append(product.getId())
                         .append(",")
                         .append(product.getName())
                         .append("]");
            } else {
                // 其他类型直接使用toString
                keyBuilder.append(param);
            }
        }
        
        return keyBuilder.toString();
    }
}

// 在配置类中注册
@Bean
public KeyGenerator customKeyGenerator() {
    return new CustomKeyGenerator();
}

// 使用自定义键生成器
@Cacheable(value = "products", keyGenerator = "customKeyGenerator")
public List<Product> findProductsByCategory(String category, boolean includeInactive) {
    // 键将类似于: "ProductService.findProductsByCategory:Electronics:false"
    return productRepository.findByCategory(category, includeInactive);
}

3.3 SpEL表达式定制缓存键

Spring Expression Language (SpEL)提供了灵活的缓存键定制方式，无需创建额外类。通过key属性指定表达式，可以从方法参数、返回值或上下文环境构建键。SpEL支持字符串操作、条件逻辑和对象导航，能够处理复杂的键生成需求。在多租户系统中，可结合SecurityContext获取租户信息构建隔离的缓存键。

// SpEL表达式缓存键示例
@Service
public class AdvancedCacheService {
    
    // 使用方法参数组合构建键
    @Cacheable(编程客栈value = "productSearch", key = "#category + '_' + #minPrice + '_' + #maxPrice")
    public List<Product> searchProducts(String category, Double minPrice, Double maxPrice) {
        return productRepository.search(category, minPrice, maxPrice);
    }
    
    // 使用对象属性
    @Cacheable(value = "userProfile", key = "#user.id + '_' + #user.role")
    public UserProfile getUserProfile(User user) {
        return profileService.loadProfile(user);
    }
    
    // 使用条件表达式
    @Cacheable(value = "reports", 
               key = "#reportType + (T(java.lang.String).valueOf(#detailed ? '_detailed' : '_summary'))",
               condition = "#reportType != 'REALTIME'")  // 实时报告不缓存
    public Report generateReport(String reportType, boolean detailed) {
        return reportGenerator.create(reportType, detailed);
    }
    
    // 结合内置对象和方法
    @Cacheable(value = "securedData", 
               key = "#root.target.getTenantPrefix() + '_' + #dataId",
               unless = "#result == null")
    public SecuredData getSecuredData(String dataId) {
        return securityRepository.findData(dataId);
    }
    
    // 辅助方法，用于SpEL表达式中
    public String getTenantPrefix() {
        return SecurityContextHolder.getContext().getAuthentication().getName() + "_tenant"js;
    }
}

四、实践中的缓存设计

4.1 缓存一致性策略

缓存一致性是系统设计的关键挑战。在Spring Cache中，主要通过@CacheEvict和@CachePut维护一致性。时间驱动策略通过设置TTL控制缓存过期；事件驱动策略在数据变更时主动更新缓存。复杂系统中，可以结合消息队列实现跨服务缓存同步。定期刷新关键缓存也是保障数据新鲜度的有效手段。不同场景需要权衡一致性与性能。

// 缓存一致性维护示例
@Service
public class ConsistentCacheService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    // 读取缓存数据
    @Cacheable(value = "productDetails", key = "#id")
    public ProductDetails getProductDetails(Long id) {
        return productDetailsRepository.findById(id).orElse(null);
    }
    
    // 更新并刷新缓存
    @Transactional
    public ProductDetails updateProductDetails(ProductDetails details) {
        // 先保存数据
 android       ProductDetails saved = productDetailsRepository.save(details);
        
        // 发布缓存更新事件
        eventPublisher.publishEvent(new ProductCacheInvalidationEvent(saved.getId()));
        
        return saved;
    }
    
    // 事件监听器，处理缓存刷新
    @EventListener
    public void handleProductCacheInvalidation(ProductCacheInvalidationEvent event) {
        clearProductCache(event.getProductId());
    }
    
    // 清除特定产品缓存
    @CacheEvict(value = "productDetails", key = "#id")
    public void clearProductCache(Long id) {
        // 方法体可以为空，注解处理缓存清除
        System.out.println("产品缓存已清除: " + id);
    }
    
    // 缓存事件定义
    public static class ProductCacheInvalidationEvent {
        private final Long productId;
        
        public ProductCacheInvalidationEvent(Long productId) {
            this.productId = productId;
        }
        
        public Long getProductId() {
            return productId;
        }
    }
}

总结

Spring Cache抽象层通过统一接口和声明式注解，为Java应用提供了强大而灵活的缓存支持。CacheManager作为核心组件，连接缓存抽象与具体实现，支持从简单内存缓存到复杂分布式缓存的各种场景。

自定义键生成策略，无论是通过KeyGenerator实现还是SpEL表达式定制，都为精确控制缓存行为提供了有力工具。

在实际应用中，合理选择CacheManager、设计缓存键策略并维护缓存一致性，是构建高性能缓存系统的关键。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。

继续阅读：SpringCache CacheManager SpringCache缓存抽象 SpringCache自定义键生成

SpringCache缓存抽象之CacheManager与自定义键生成方式

目录

一、Spring Cache基础架构

1.1 缓存抽象设计理念

1.2 核心组件概述

二、CacheManager深入解析

2.1 常用CacheManager实现

2.2 复合缓存策略

三、自定义键生成策略

3.1 默认键生成机制

3.2 自定义KeyGenerator实现

3.3 SpEL表达式定制缓存键

四、实践中的缓存设计

4.1 缓存一致性策略

总结

更多精彩内容

精彩评论

最新开发

Java基于Log4j2实现异步日志系统的性能优化实践指南

C++将字符串转换为整数和浮点数的几种方法

Linux中配置Java环境变量实现过程

Java实现经纬度坐标转换的示例代码

java正则表达式校验篇(附详细代码示例)

开发排行榜

springboot后端存储富文本内容的思路与步骤(含图片内容)

PyCharm运行python测试,报错“没有发现测试”/“空套件”的解决

return base64.b64encode(b).decode(

基于C语言实现钻石棋游戏的示例代码

Sublime Text 3解决中文乱码问题（实测可用）