当前位置：首页 > article >正文

基于Spring Boot的多级缓存架构实现

article 2025/3/10 22:43:50

基于Spring Boot的多级缓存架构实现

以下是一个基于Spring Boot的多级缓存架构实现示例

多级缓存架构实现方案

1. 依赖配置（pom.xml）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. 缓存配置类

@Configuration
@EnableCaching
public class MultiLevelCacheConfig {

    // 一级缓存（本地缓存）
    @Bean
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager manager = new CaffeineCacheManager();
        manager.setCaffeine(Caffeine.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(30, TimeUnit.SECONDS)); // 本地缓存比Redis缓存更短
        return manager;
    }

    // 二级缓存（Redis缓存）
    @Bean
    public CacheManager redisCacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(5))
                .serializeValuesWith(SerializationPair.fromSerializer(RedisSerializer.json()));

        return RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .transactionAware()
                .build();
    }

    // 组合缓存管理器
    @Bean
    @Primary
    public CacheManager multiLevelCacheManager(
            @Qualifier("caffeineCacheManager") CacheManager level1,
            @Qualifier("redisCacheManager") CacheManager level2) {
        return new MultiLevelCacheManager(level1, level2);
    }
}

3. 多级缓存管理器实现

public class MultiLevelCacheManager implements CacheManager {

    private final CacheManager level1; // 本地缓存
    private final CacheManager level2; // Redis缓存
    private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>();

    public MultiLevelCacheManager(CacheManager level1, CacheManager level2) {
        this.level1 = level1;
        this.level2 = level2;
    }

    @Override
    public Cache getCache(String name) {
        return cacheMap.computeIfAbsent(name, 
            key -> new MultiLevelCache(
                level1.getCache(name), 
                level2.getCache(name)
            ));
    }

    @Override
    public Collection<String> getCacheNames() {
        return Stream.concat(
            level1.getCacheNames().stream(),
            level2.getCacheNames().stream()
        ).collect(Collectors.toSet());
    }

    // 多级缓存实现
    static class MultiLevelCache implements Cache {
        private final Cache level1;
        private final Cache level2;
        private final String name;

        public MultiLevelCache(Cache level1, Cache level2) {
            this.level1 = level1 != null ? level1 : new NoOpCache();
            this.level2 = level2 != null ? level2 : new NoOpCache();
            this.name = level1.getName() + ":" + level2.getName();
        }

        @Override
        public String getName() {
            return name;
        }

        @Override
        public Object getNativeCache() {
            return this;
        }

        @Override
        public ValueWrapper get(Object key) {
            // 先查一级缓存
            ValueWrapper value = level1.get(key);
            if (value == null) {
                // 二级缓存查询
                value = level2.get(key);
                if (value != null) {
                    // 回填一级缓存
                    level1.put(key, value.get());
                }
            }
            return value;
        }

        @Override
        public <T> T get(Object key, Class<T> type) {
            // 实现逻辑类似get方法
            T value = level1.get(key, type);
            if (value == null) {
                value = level2.get(key, type);
                if (value != null) {
                    level1.put(key, value);
                }
            }
            return value;
        }

        @Override
        public void put(Object key, Object value) {
            // 同时写入两级缓存
            level1.put(key, value);
            level2.put(key, value);
        }

        @Override
        public void evict(Object key) {
            // 同时清除两级缓存
            level1.evict(key);
            level2.evict(key);
        }

        @Override
        public void clear() {
            level1.clear();
            level2.clear();
        }
    }

    // 空缓存实现（容错）
    static class NoOpCache implements Cache {
        // 实现基础的Cache方法，返回空值
    }
}

4. 业务层使用

@Service
public class ProductService {

    @Cacheable(value = "products", key = "#id")
    public Product getProduct(Long id) {
        // 数据库查询逻辑
        return productRepository.findById(id)
               .orElseThrow(() -> new NotFoundException("Product not found"));
    }

    @CacheEvict(value = "products", key = "#product.id")
    public void updateProduct(Product product) {
        productRepository.save(product);
    }
}

5. 配置说明（application.yml）

spring:
  cache:
    multi-level:
      level1:
        ttl: 30s    # 本地缓存时间
        max-size: 1000
      level2:
        ttl: 5m     # Redis缓存时间
  redis:
    host: redis-cluster.prod
    port: 6379
    timeout: 2000ms

关键实现要点

缓存层级策略

一致性保障

写操作：同时清除两级缓存（@CacheEvict）
读操作：二级缓存命中后自动回填一级缓存
TTL策略：一级缓存TTL（30s） < 二级缓存TTL（5m）

性能优化

本地缓存：使用Caffeine高性能缓存库
异步回填：可扩展为异步加载（需自定义CacheLoader）
批量操作：支持@Cacheable的批量查询优化

扩展建议

缓存预热

@PostConstruct
public void preloadHotData() {
    // 加载热点数据到缓存
    hotProducts.forEach(product -> 
        cacheManager.getCache("products").put(product.getId(), product));
}

监控集成

@Bean
public MeterRegistryCustomizer<MeterRegistry> cacheMetrics() {
    return registry -> {
        CaffeineCacheManager caffeine = context.getBean(CaffeineCacheManager.class);
        RedisCacheManager redis = context.getBean(RedisCacheManager.class);
        
        // 注册Caffeine监控
        CacheMetrics.monitor(registry, caffeine, "level1");
        // 注册Redis监控
        CacheMetrics.monitor(registry, redis, "level2");
    };
}

防雪崩策略

// 在MultiLevelCache.get方法中添加
ValueWrapper get(Object key) {
    try {
        // 添加分布式锁检查
        if (lockManager.tryLock(key)) {
            // 实际查询逻辑
        }
    } finally {
        lockManager.unlock(key);
    }
}