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.
También te puede interesar
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.