使用 Redis + Caffeine 实现高性能服务架构缓存设计

在现代分布式系统中，缓存作为提升性能和降低数据库压力的重要组件，其设计显得尤为重要。结合 Redis 和 Caffeine，可以实现高效的多级缓存架构，既能满足高频访问的性能要求，又能有效降低后端服务的负载。

一、多级缓存的基本概念

多级缓存是一种分层设计，将缓存划分为多层级，每一层缓存都有不同的作用和存储位置。

一级缓存（本地缓存）：使用 Caffeine 实现，数据存储在应用的内存中，访问速度最快，但容量受限。
二级缓存（分布式缓存）：使用 Redis 实现，数据存储在独立的缓存服务中，容量较大，可以被多个应用共享。
数据库：作为最终数据存储，提供持久化能力。

二、Redis 与 Caffeine 的优势对比

特性	Caffeine	Redis
存储位置	JVM 内存	独立的内存服务器
访问速度	极快（纳秒级）	快（毫秒级）
数据共享能力	仅限于单实例	多实例共享
持久化支持	无	支持 AOF 和 RDB 持久化
缓存淘汰策略	多种策略（如 LFU、LRU 等）	支持 LRU

通过结合使用，可以取长补短，实现更高效的缓存架构。

三、SpringBoot 中集成 Redis 和 Caffeine

1. 引入依赖

在 pom.xml 中引入所需依赖：

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

2. 配置 Redis

在 application.yml 中配置 Redis：

spring:
  redis:
    host: localhost
    port: 6379
    timeout: 2000ms
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0

3. 配置 Caffeine

创建一个 Caffeine 缓存配置类：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
public class CaffeineConfig {

    @Bean
    public Cache<String, Object> caffeineCache() {
        return Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(1000)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build();
    }
}

4. 编写多级缓存服务

import com.github.benmanes.caffeine.cache.Cache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class CacheService {

    @Autowired
    private Cache<String, Object> caffeineCache;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final long REDIS_EXPIRE_TIME = 60 * 10; // 10 分钟

    public Object get(String key) {
        // 一级缓存查询
        Object value = caffeineCache.getIfPresent(key);
        if (value != null) {
            return value;
        }

        // 二级缓存查询
        value = redisTemplate.opsForValue().get(key);
        if (value != null) {
            // 回填一级缓存
            caffeineCache.put(key, value);
        }
        return value;
    }

    public void put(String key, Object value) {
        // 写入一级缓存
        caffeineCache.put(key, value);
        // 写入二级缓存
        redisTemplate.opsForValue().set(key, value, REDIS_EXPIRE_TIME, TimeUnit.SECONDS);
    }

    public void remove(String key) {
        // 移除一级缓存
        caffeineCache.invalidate(key);
        // 移除二级缓存
        redisTemplate.delete(key);
    }
}

5. 使用示例

在 Controller 中调用缓存服务：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CacheController {

    @Autowired
    private CacheService cacheService;

    @GetMapping("/cache")
    public Object cache(@RequestParam String key, @RequestParam(required = false) String value) {
        if (value != null) {
            cacheService.put(key, value);
            return "Cache updated!";
        }
        return cacheService.get(key);
    }

    @GetMapping("/cache/remove")
    public String remove(@RequestParam String key) {
        cacheService.remove(key);
        return "Cache removed!";
    }
}

四、总结

通过结合 Redis 和 Caffeine，我们可以构建一个高性能的多级缓存架构，利用 Caffeine 的极速访问和 Redis 的共享能力，实现性能和扩展性的平衡。在实际生产环境中，这种多级缓存方案可以有效降低数据库压力，同时提高系统响应速度。

秒客网