How to Warm Up Your Cache for High‑Concurrency Systems

What is Cache Warm-up?

Cache warm-up (预热) refers to preloading frequently used data into the cache before the system starts or before traffic peaks, aiming to increase cache hit rate, improve performance, avoid cache breakdowns and avalanches, reduce backend load, and boost response speed and throughput.

Why Warm the Cache?

Reduce cold‑start impact: avoids slow first requests when the cache is empty.

Increase data access speed: data is quickly available from the cache.

Smooth traffic spikes: helps the system handle high load without performance degradation.

Ensure data freshness: regular warm‑up keeps cached data up‑to‑date.

Alleviate pressure on backend systems: fewer direct queries to databases or other services.

Common Warm‑up Methods

Typical approaches include:

Load at application startup : preload data when the application launches.

Scheduled task loading : periodically run a job to refresh the cache.

Manual trigger : manually invoke loading before a known traffic peak.

Lazy loading on demand : load data into the cache when a request arrives based on access patterns.

Cache loader : use a framework‑provided loader that automatically fetches missing entries.

Redis Warm‑up Tools

RedisBloom : a Redis module offering Bloom filters that can quickly test whether a key is already cached.

Redis Bulk loading : an official tool for batch writing data via the Redis protocol.

Redis Desktop Manager : a GUI client that can import bulk data into Redis for warm‑up.

Application Startup Warm‑up in Spring Boot

Several ways to execute warm‑up logic after the Spring Boot application is ready:

ApplicationReadyEvent

@EventListener(ApplicationReadyEvent.class)
public void preloadCache() {
    // cache warm‑up logic
}

CommandLineRunner / ApplicationRunner

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        // cache warm‑up logic
    }
}

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // cache warm‑up logic
    }
}

Both runners are invoked by SpringApplication.run via the internal callRunners method.

InitializingBean

import org.springframework.beans.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class CachePreloader implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // cache warm‑up logic
    }
}

@PostConstruct

import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;

@Component
public class CachePreloader {
    @PostConstruct
    public void preloadCache() {
        // cache warm‑up logic
    }
}

Scheduled Warm‑up

Use Spring’s @Scheduled annotation or external schedulers like XXL‑Job to refresh the cache periodically.

@Scheduled(cron = "0 0 1 * * ?") // every day at 1 AM
public void scheduledCachePreload() {
    // cache warm‑up logic
}

Cache Loader Example with Caffeine

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class MyCacheService {
    private final LoadingCache<String, String> cache;

    public MyCacheService() {
        this.cache = Caffeine.newBuilder()
                .refreshAfterWrite(1, TimeUnit.MINUTES)
                .build(key -> loadDataFromSource(key));
    }

    public String getValue(String key) {
        return cache.get(key);
    }

    private String loadDataFromSource(String key) {
        // load data from source (DB, external service, etc.)
        System.out.println("Loading data for key: " + key);
        return "Value for " + key;
    }
}