Una nota muy importante para esa respuesta: si alguna vez planea actualizar esos valores (almacenados en caché), no olvide usar @CacheEvict en save() y delete() en los repositorios. De lo contrario, tendrá problemas para obtener el nuevo registro cuando se actualice.

Implementé mi solución (con EhCache) de esta manera (en el repositorio):

CurrencyRepository.java: // definir una declaración almacenable en caché

 @Cacheable("currencyByIdentifier") public Currency findOneByIdentifier(String identifier);

CacheConfiguration.java: // Definir ese caché en EhCache Configuration

 @Bean public JCacheManagerCustomizer cacheManagerCustomizer() { return cm -> { cm.createCache("currencyByIdentifier", jcacheConfiguration); cm.createCache("sourceSystemByIdentifier", jcacheConfiguration); }; }

CurrencyRepository.java: // desalojar al guardar y eliminar anulando el método predeterminado

 @Override @CacheEvict("currencyByIdentifier") <S extends Currency> S save(S currency); @Override @CacheEvict("currencyByIdentifier") void delete(Currency currency);

Espero que eso ayude :)

Intente usar Springs Cache Abstraction, docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html .

Puede usar esta abstracción en el método que tiene la llamada restTemplate.

Cualquier respuesta de llamadas a métodos se puede almacenar en caché utilizando esta abstracción, con los parámetros del método como claves y el tipo de retorno como respuesta.

 @Cacheable("username") public UserResponse getUser(String username){ // Code to call your rest api }

Esto crea un consejo Spring AOP sobre el método. Cada vez que se llama al método, verifica si los datos están disponibles en el caché para esta clave (nombre de usuario), si es así, devuelve la respuesta del caché y no llama al método real. Si los datos no están disponibles en la memoria caché, llama al método real y almacena los datos en la memoria caché, de modo que la próxima vez que se llame al mismo método con la misma clave, los datos se pueden seleccionar de la memoria caché.

Esta abstracción de caché puede respaldarse con cachés JVM simples como Guava o implementaciones de caché más sofisticadas como EHCache, Redis, HazelCast también.