Spring Boot – Caching

<!-- Spring Boot 4 modularized autoconfiguration: depending on the cache
     abstraction alone gives you the annotations with NO CacheManager, and
     @Cacheable then silently does nothing. -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

@Configuration
@EnableCaching
public class CacheConfig {

    /** The active, customer-facing menu. */
    public static final String MENU_CACHE = "menu";

    /** The active menu filtered to one product type. */
    public static final String MENU_BY_TYPE_CACHE = "menuByType";

    @Bean
    public ConcurrentMapCacheManager cacheManager() {
        ConcurrentMapCacheManager manager =
                new ConcurrentMapCacheManager(MENU_CACHE, MENU_BY_TYPE_CACHE);
        // Refuse to create caches that were never declared above. Without this, a typo in a
        // @Cacheable name quietly creates a brand new cache that no @CacheEvict ever clears.
        manager.setAllowNullValues(false);
        return manager;
    }
}

/**
 * <p>The menu is the right thing to cache and almost the only one here: every visitor loads it, it
 * is identical for all of them, and it changes only when an administrator edits the catalogue. The
 * cart and the orders are cached nowhere — they are per-user and change constantly, and caching
 * them would be a correctness bug dressed as an optimisation.
 */

@Override
@Cacheable(value = CacheConfig.MENU_CACHE, keyGenerator = "methodAwareKeyGenerator")
@Transactional(readOnly = true)
public List<ProductDTO> getMenu() {
    log.debug("Getting the active menu");
    return mapper.mapProductsToProductDTOs(productDAO.findActiveMenu());
}

@Override
@Cacheable(value = CacheConfig.MENU_BY_TYPE_CACHE, key = "#type")
@Transactional(readOnly = true)
public List<ProductDTO> getByType(ProductType type) {
    return mapper.mapProductsToProductDTOs(productDAO.findActiveByType(type));
}

/**
 * The default key generator hashes every method argument together. That is reasonable until a
 * no-argument method appears: {@code getMenu()} and any other no-argument method on the same
 * cache both key to {@link SimpleKey#EMPTY}. Naming the method removes the collision.
 */
@Bean
public KeyGenerator methodAwareKeyGenerator() {
    return (target, method, params) ->
            params.length == 0 ? method.getName() : method.getName() + "-" + List.of(params);
}

/**
 * <p>{@code @Cacheable} and {@code @CacheEvict} refer to a cache by a string. Spelling it
 * differently in the two places is the classic caching bug: reads populate {@code "menu"}, writes
 * evict {@code "menus"}, and stale data is served forever with nothing failing.
 */

@Override
@Caching(
        evict = {
            @CacheEvict(value = CacheConfig.MENU_CACHE, allEntries = true),
            @CacheEvict(value = CacheConfig.MENU_BY_TYPE_CACHE, allEntries = true)
        })
@Transactional
public ProductDTO updateProduct(UUID id, ProductCreateDTO dto) { /* … */ }

/**
 * <p>The eviction matters as much as the write. Without it the menu cache keeps serving the
 * old image URL and the admin reasonably concludes the upload silently failed.
 */

@Service
public class ProductServiceImpl {

    public List<ProductDTO> getMenuTwice() {
        getMenu();      // NOT cached — internal call, the proxy is not involved
        return getMenu();
    }

    @Cacheable("menu")
    public List<ProductDTO> getMenu() { /* … */ }
}

/**
 * <p>It is an in-memory {@code ConcurrentHashMap}: nothing evicts by time, nothing bounds its size,
 * and each instance has its own copy. That is fine for one process and wrong the moment there are
 * two — instance A evicts on a write and instance B keeps serving the old menu until it restarts.
 */

# Caffeine: bounded and time-limited, still local
spring.cache.type=caffeine
spring.cache.caffeine.spec=maximumSize=500,expireAfterWrite=10m

# Redis: shared
spring.cache.type=redis
spring.data.redis.host=localhost
spring.cache.redis.time-to-live=600000

for i in 1 2 3; do curl -s -o /dev/null -w "call $i: %{time_total}s\n" \
  http://localhost:8085/api/products; done

# call 1: 0.003512s   ← populates the cache
# call 2: 0.001593s
# call 3: 0.001646s