Caché en Spring Boot con @Cacheable y @CacheEvict

Cómo evitar repetir una consulta lenta guardando su resultado en caché con @Cacheable, medir la diferencia con curl y vaciar la caché cuando los datos cambian.

La idea

Si consultar el tipo de cambio tarda un segundo y miles de clientes lo piden cada minuto, preguntarle al proveedor cada vez es tirar tiempo y dinero: el valor casi no cambia. Una caché guarda el resultado de la primera consulta y lo entrega al instante las siguientes. En Spring Boot se activa con una anotación en la clase principal y se agrega con la dependencia Spring Cache Abstraction (spring-boot-starter-cache):

package com.ejemplo.cache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class CacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(CacheApplication.class, args);
    }

}

@Cacheable y @CacheEvict

package com.ejemplo.cache;

import java.math.BigDecimal;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class TipoDeCambio {

    private static final Logger log = LoggerFactory.getLogger(TipoDeCambio.class);

    @Cacheable("tipos")
    public BigDecimal consultar(String moneda) throws InterruptedException {
        log.info("Consultando el tipo de {} al proveedor (tarda 1 segundo)", moneda);
        Thread.sleep(1000);                         // simula un servicio externo lento
        return moneda.equals("USD") ? new BigDecimal("18.42") : new BigDecimal("21.37");
    }

    @CacheEvict(cacheNames = "tipos", allEntries = true)
    public void olvidar() {
        log.info("Se vació la caché de tipos de cambio");
    }
}

@Cacheable("tipos") envuelve el método: antes de ejecutarlo, Spring busca en la caché «tipos» un resultado guardado para los mismos parámetros (aquí, la moneda). Si lo encuentra, lo devuelve sin ejecutar el método; si no, lo ejecuta y guarda lo que devolvió. @CacheEvict borra lo guardado, por ejemplo cuando sabes que los datos cambiaron.

Probarlo

curl muestra al final de cada respuesta cuánto tardó:

terminal$ curl -s -w "  (%{time_total} s)\n" localhost:8080/tipos/USD
18.42  (1.084067 s)
$ curl -s -w "  (%{time_total} s)\n" localhost:8080/tipos/USD
18.42  (0.003069 s)
$ curl -s -w "  (%{time_total} s)\n" localhost:8080/tipos/EUR
21.37  (1.004497 s)
$ curl -s -w "  (%{time_total} s)\n" localhost:8080/tipos/USD
18.42  (0.002963 s)
$ curl -s -X DELETE localhost:8080/tipos
$ curl -s -w "  (%{time_total} s)\n" localhost:8080/tipos/USD
18.42  (1.004227 s)
registro de la aplicación2026-11-22T10:36:08.772-06:00  INFO 94 --- [cache] [nio-8080-exec-1] com.ejemplo.cache.TipoDeCambio           : Consultando el tipo de USD al proveedor (tarda 1 segundo)
2026-11-22T10:36:09.832-06:00  INFO 94 --- [cache] [nio-8080-exec-4] com.ejemplo.cache.TipoDeCambio           : Consultando el tipo de EUR al proveedor (tarda 1 segundo)
2026-11-22T10:36:10.875-06:00  INFO 94 --- [cache] [nio-8080-exec-8] com.ejemplo.cache.TipoDeCambio           : Se vació la caché de tipos de cambio
2026-11-22T10:36:10.894-06:00  INFO 94 --- [cache] [io-8080-exec-10] com.ejemplo.cache.TipoDeCambio           : Consultando el tipo de USD al proveedor (tarda 1 segundo)

La primera consulta del dólar tardó un segundo; la segunda, milésimas, y el registro confirma que el método no se volvió a ejecutar. El euro tiene su propia entrada. Después de vaciar la caché, el dólar volvió a tardar.

Esta caché no caduca. Sin más configuración, Spring Boot usa un mapa en memoria: los valores se quedan ahí hasta que se vacía la caché o se reinicia la aplicación, y no tiene límite de tamaño. Para un tipo de cambio, eso significa servir el valor de la mañana toda la tarde. En producción, agrega Caffeine (la dependencia com.github.ben-manes.caffeine:caffeine) y define tiempo de vida y tamaño máximo, por ejemplo con spring.cache.caffeine.spec=maximumSize=500,expireAfterWrite=10m; con varias instancias, usa una caché compartida como Redis. Y recuerda que @Cacheable funciona con un proxy: una llamada desde la misma clase no pasa por la caché, igual que @Transactional en las rarezas.

Cada proyecto de esta página se compiló con Spring Boot 4.2.0, Java 25 (Temurin 25.0.5.1) y Maven 3.10.1 en un contenedor limpio y sin red, se arrancó y se probó con las peticiones de curl que ves; las respuestas y los registros están copiados de esa ejecución.