如何高效实现缓存预热？一文了解九大方法

后端出路在何方
1,148 阅读9分钟

什么是缓存预热

缓存预热是一种在系统启动或运行过程中，提前加载热点数据到缓存的技术，目的是避免用户第一次访问时缓存为空，导致请求直接打到后端数据库或服务，从而提高系统性能和响应速度。

常见的几种缓存预热方案包括：

  1. 启动过程中预热（基于 Spring 的监听器）
  2. 定时任务
  3. 用时加载（惰性加载）
  4. 缓存加载器

1. 启动过程中预热（Spring 监听器实现）

在应用启动时，通过监听 Spring 的生命周期事件，提前加载热点数据到缓存中。

实现原理：

Spring 提供了多种生命周期监听机制，例如 ApplicationListener 或标注为 @EventListener 的方法。我们可以通过监听 ContextRefreshedEvent（Spring 容器初始化完成事件）来触发缓存预热。

代码示例：

@Component
public class CachePrewarmListener implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private CacheService cacheService; // 假设这是一个缓存服务类

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 缓存预热逻辑
        System.out.println("开始缓存预热...");
        List<String> hotData = cacheService.getHotDataFromDatabase(); // 模拟从数据库加载热点数据
        for (String data : hotData) {
            cacheService.putIntoCache(data); // 将数据写入缓存
        }
        System.out.println("缓存预热完成！");
    }
}

优点：

  • 只在系统启动时执行一次预热。
  • 实现简单，适合小规模缓存预热。

缺点：

  • 如果启动过程中要预热的数据量很大，会增加启动时间。
  • 热点数据可能在运行一段时间后发生改变。

mermaid.png

流程：

  1. 系统启动时触发 Spring 容器事件。
  2. 调用数据库，加载热点数据。
  3. 将热点数据写入缓存。
  4. 启动完成，缓存预热结束。

2. 定时任务预热

通过定时任务定期刷新缓存数据，比如每天晚上非高峰时段加载热点数据到缓存中。

实现原理：

利用任务调度框架（如 Spring TaskScheduler 或 Quartz）定期从数据库加载热点数据，并填充到缓存中。

代码示例：

@Component
public class CachePrewarmTask {

    @Autowired
    private CacheService cacheService;

    @Scheduled(cron = "0 0 3 * * ?") // 每天凌晨3点执行
    public void prewarmCache() {
        System.out.println("开始定时缓存预热...");
        List<String> hotData = cacheService.getHotDataFromDatabase(); // 获取热点数据
        for (String data : hotData) {
            cacheService.putIntoCache(data); // 写入缓存
        }
        System.out.println("定时缓存预热完成！");
    }
}

优点：

  • 可以定期刷新缓存，保持缓存数据的最新状态。
  • 对于热点数据变化频繁的场景更为合适。

缺点：

  • 数据可能在任务间隔期间发生较大变化，导致缓存不够实时。
  • 存在一定的任务调度开销。

1.png

流程：

  1. 定时任务触发（例如凌晨 3 点）。
  2. 从数据库加载热点数据。
  3. 将数据写入缓存。
  4. 预热完成，等待下次任务。

3. 用时加载（惰性加载）

只有在用户实际请求某个数据时，才将该数据加载到缓存中。

实现原理：

在查询缓存时，先检查缓存中是否存在数据。如果不存在，调用后端服务或数据库加载数据，然后将其写入缓存。

代码示例：

@Service
public class CacheService {

    private final Map<String, String> cache = new HashMap<>(); // 模拟缓存

    public String getData(String key) {
        if (cache.containsKey(key)) {
            // 如果缓存中存在
            return cache.get(key);
        } else {
            // 如果缓存中不存在，从数据库加载
            String value = getDataFromDatabase(key);
            cache.put(key, value); // 加载到缓存
            return value;
        }
    }

    private String getDataFromDatabase(String key) {
        // 模拟从数据库获取数据
        return "Value for " + key;
    }
}

优点：

  • 无需提前加载，节省启动时间。
  • 不会加载无关数据，避免浪费缓存空间。

缺点：

  • 第一次访问时，仍然会有一定的延迟。
  • 如果访问量高，可能导致缓存“雪崩”问题（多个线程同时查询同一数据时，可能都打到数据库）。

2.png

流程：

  1. 用户发出数据请求。
  2. 检查缓存是否有数据：
    • 如果有，直接返回数据。
    • 如果没有，从数据库加载数据。
  3. 将加载的数据写入缓存。
  4. 返回数据给用户。

4. 缓存加载器

使用缓存框架（如 Guava Cache 或 Caffeine）提供的“缓存加载器”功能，自动处理缓存加载逻辑。

实现原理：

缓存框架允许我们定义一个加载器，当缓存中没有相关数据时，自动调用加载器从数据库或其他数据源获取数据。

代码示例：

下面以 Guava Cache 为例：

@Configuration
public class CacheConfig {

    @Bean
    public LoadingCache<String, String> guavaCache() {
        return CacheBuilder.newBuilder()
                .maximumSize(100) // 设置最大缓存大小
                .expireAfterWrite(10, TimeUnit.MINUTES) // 缓存过期时间
                .build(new CacheLoader<String, String>() {
                    @Override
                    public String load(String key) throws Exception {
                        // 如果缓存中不存在，自动调用此方法加载数据
                        return getDataFromDatabase(key);
                    }
                });
    }

    private String getDataFromDatabase(String key) {
        // 模拟从数据库获取数据
        return "Value for " + key;
    }
}

使用代码：

@Autowired
private LoadingCache<String, String> guavaCache;

public String getData(String key) {
    try {
        return guavaCache.get(key); // 如果缓存中不存在，会自动触发加载器
    } catch (ExecutionException e) {
        e.printStackTrace();
        return null;
    }
}

优点：

  • 缓存框架提供了线程安全和高效的数据加载机制。
  • 简化了缓存管理代码。

缺点：

  • 需要引入第三方缓存框架。
  • 不适合大规模预加载的场景。

3.png

流程：

  1. 用户发出数据请求。
  2. 缓存框架检查数据是否存在：
    • 如果存在，直接返回数据。
    • 如果不存在，触发加载器从数据库加载数据。
  3. 加载的数据自动写入缓存。
  4. 返回数据给用户。

总结

方案优点缺点适用场景
启动过程中预热（监听器）简单易实现，适合小规模预热启动时间可能延长，不适合频繁变化的热点数据热点数据相对固定，需在启动时加载
定时任务热点数据实时性更高存在调度开销，可能浪费缓存空间热点数据变化频繁，需定期更新
用时加载（惰性加载）延迟加载节约资源，只加载需要的数据第一次访问会有延迟，可能引发缓存“雪崩”问题数据分散且访问规律不明确
缓存加载器自动加载机制，线程安全，高性能引入第三方依赖，学习成本相对较高高并发场景，缓存访问频繁

其他缓存预热方案：

  1. 手动触发预热
    管理员或运维人员通过后台管理系统、脚本或接口，手动触发缓存预热操作。这种方式适合在需要时临时预热缓存，例如发布新版本或更新热点数据时。

    特点：

    • 灵活性高，可根据实际需要触发。
    • 适合不频繁更新的热点数据。
    • 需要额外开发后台接口或脚本工具。

    示例： 开发一个 REST 接口，供管理员手动触发：

    @RestController
public class CacheController {

    @Autowired
    private CacheService cacheService;

    @PostMapping("/cache/prewarm")
    public ResponseEntity<String> prewarmCache() {
        List<String> hotData = cacheService.getHotDataFromDatabase();
        for (String data : hotData) {
            cacheService.putIntoCache(data);
        }
        return ResponseEntity.ok("缓存预热完成！");
    }
}

4.png

流程：

  1. 管理员或运维通过接口或脚本触发预热操作。
  2. 从数据库加载热点数据。
  3. 将数据写入缓存。
  4. 返回触发成功信息。

  1. 基于消息队列的异步预热
    如果系统中有消息队列（如 Kafka、RabbitMQ 等），可以通过消息队列的事件机制实现异步缓存预热。例如，当数据库中的热点数据更新时，发送一个消息通知消费者预热缓存。

    特点：

    • 高效且解耦，数据更新后可实时触发缓存更新。
    • 适合分布式系统和高并发场景。

    示例： 使用 RabbitMQ 实现：

    • 数据变更时，发送消息：

      @Service
public class DatabaseService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void updateData(String key, String value) {
        // 更新数据库
        updateDatabase(key, value);
        // 通知缓存系统
        rabbitTemplate.convertAndSend("cacheExchange", "cache.routing.key", key);
    }
}

    • 消费者接收消息并更新缓存：

      @Service
public class CacheService {

    @RabbitListener(queues = "cacheQueue")
    public void onMessage(String key) {
        // 从数据库加载数据并更新缓存
        String value = getDataFromDatabase(key);
        putIntoCache(key, value);
    }
}

5.png

流程：

  1. 数据库数据更新，发送消息到消息队列。
  2. 消息队列通知缓存服务。
  3. 缓存服务从数据库加载数据。
  4. 将加载的数据写入缓存。

  1. 冷热分离策略
    针对数据的访问频率，将数据分为“热点数据”和“冷数据”，仅对热点数据进行缓存预热。这种方法通常结合大数据分析、日志等工具来识别热点数据。

    特点：

    • 减少缓存占用空间，优化缓存命中率。
    • 适合数据访问热点明确的场景。

    示例：

    • 使用日志分析工具（如 ELK、Flume）统计访问频率。
    • 根据统计结果，将热点数据定期加载到缓存中。

6.png

流程：

  1. 通过大数据分析或日志统计，识别热点数据。
  2. 定期加载热点数据到缓存。
  3. 冷数据无需加载到缓存。
  4. 热点数据预热完成。

  1. 与CDN结合的缓存预热
    如果系统使用了内容分发网络（CDN），可以结合 CDN 的缓存预热功能，在访问前将热点资源（如静态文件、图片、视频）推送到 CDN 节点进行缓存。

    特点：

    • 适用于静态资源预热，如图片、CSS、JS 文件等。
    • 减轻后端服务器压力，提升用户访问速度。

    示例：

    • 调用 CDN 的 API，推送指定资源路径。
    • 常见的 CDN 服务商（如阿里云 CDN、腾讯云 CDN）都提供缓存刷新和预热接口。

7.png

流程：

  1. 管理系统或触发接口调用 CDN 的预热 API。
  2. CDN 接收到请求后，将指定资源缓存到边缘节点。
  3. 用户访问时，直接从 CDN 加载数据。

  1. 基于 AI 的智能预热
    使用机器学习或 AI 算法，预测未来一段时间的访问热点，并提前将预测的数据加载到缓存中。此方法需要结合大数据分析，适合访问量大且有一定规律的数据场景。

    特点：

    • 通过预测优化缓存预热效果。
    • 适合有足够数据支持的复杂场景。

    示例：

    • 使用大数据平台（如 Hadoop、Spark）分析历史访问日志。
    • 基于预测结果，通过定时任务或接口加载预测数据到缓存中。

总结

缓存预热的本质是根据业务需求，选择适合的方案在恰当的时机提前加载数据到缓存中。开发者应根据实际场景（如数据规模、访问规律、技术栈等），灵活运用上述方案，甚至结合多种策略，确保缓存既高效又可靠。

选择合适的方案需要根据具体业务场景的特点，如数据规模、热点数据变化频率、系统启动时间要求等因素来决定。

8.png

具体业务场景实践

看另一篇：缓存预热怎么选？九大场景对号入座！

avatar
文章
阅读
粉丝