Caffeine

Introducción

Cafeína es una biblioteca de almacenamiento en caché de alto rendimiento para Java.

Una diferencia fundamental entre una caché y un Mapa es que una caché desalojará los elementos almacenados.

Una política de desalojo decide qué objetos deben ser eliminados en un momento dado. Esta política afecta directamente la tasa de aciertos de la caché, una característica crucial de las bibliotecas de caché.

Caffeineutiliza la política de desalojo Window TinyLfu, que proporciona una tasa de aciertos casi óptima.

Caffeine Configuración

Primero, vamos a crear un Caffeine bean. Esta es la configuración principal que controlará el comportamiento de la caché, como la expiración, los límites de tamaño de la caché y más:

    private CaffeineCache buildCaffeineCache(String name, CaffeineCacheSetting cacheSpec) {
        log.info("Cache {} specified timeout of {} min, max of {}", name, cacheSpec.getTimeout(), cacheSpec.getMaxSize());
        final Caffeine<Object, Object> caffeineBuilder =
            Caffeine.newBuilder()
                .expireAfterWrite(cacheSpec.getTimeout())
                .maximumSize(cacheSpec.getMaxSize())
                .recordStats();
        return new CaffeineCache(name, caffeineBuilder.build());
    }

A continuación, necesitamos otro bean utilizando el Spring CacheManager interfaz. Caffeine proporciona su implementación de esta interfaz, que requiere el Caffeine objeto que creamos arriba:

    @Bean(name = "ipfCacheManager")
    CacheManager ipfCaffeineCacheManager() {
        SimpleCacheManager manager = new SimpleCacheManager();
        if (Objects.nonNull(settings)) {
            List<CaffeineCache> caches = settings.entrySet().stream()
                .map(entry -> buildCaffeineCache(entry.getKey(), entry.getValue()))
                .collect(Collectors.toList());
            manager.setCaches(caches);
        }
        return manager;
    }

Todo el beans mencionado anteriormente lo obtenemos de forma gratuita al agregar la dependencia de maven mencionada antes.

Sin embargo, el Caffeine el caché requiere los siguientes valores de configuración para cada caché que se proporciona:

ipf.caching.caffeine.settings."${cache_name}".timeout=[Duration]
ipf.caching.caffeine.settings."${cache_name}".max-size=[Long]

  • cache_name-nombre de la caché que se está utilizando

  • tiempo de espera - La duración de la caché permanecerá en memoria activa antes de ser desalojada.

  • max-size-tamaño máximo de caché antes de que la caché expulse entradas que son menos propensas a ser utilizadas nuevamente consulte Cafeína

Un ejemplo:

ipf.caching.caffeine.settings.cache1.timeout=10m
ipf.caching.caffeine.settings.cache1.max-size=10000
ipf.caching.caffeine.settings.cache2.timeout=20s
ipf.caching.caffeine.settings.cache2.max-size=100000

Caffeine Implementación

La implementación es sencilla, ya que este módulo es consciente de Spring Boot y conectará todo lo necesario.beans y conéctelos a Spring CacheManager proporcionando métricas.

Simplemente añada la dependencia de maven y luego recupere cualquier caché por nombre.

Obtenemos el CacheFactory*bean gratis de *ipf-cache-caffeine módulo y habilitando la caché de caffeine.

    @Bean(name = "caffeineCacheFactory")
    CacheFactory<?, ?> cacheFactory(CacheManager cacheManager, CacheLogger<Object, Object> cacheLogger) {
        return new CaffeineCacheFactory(cacheManager, cacheLogger);
    }

Entonces, solo necesita utilizar el CacheFactory para crear ya sea un AsyncCacheAdapter:

        @Bean
        AsyncCacheAdapter<String, String> asyncCacheAdapter3(CacheFactory<String, String> cacheFactory) {
            return cacheFactory.asyncCreateCacheAdapter(CACHE_3);
        }

O un CacheAdapter:

        @Bean
        CacheAdapter<?, ?> cacheAdapter1(CacheFactory<?, ?> cacheFactory) {
            return cacheFactory.createCacheAdapter(CACHE_1);
        }

Dependencias

La dependencia de ipf-cache-api el módulo requiere algunas dependencias suministradas para leer y escribir en el registro de mensajes.

Estos pueden ser añadidos a su aplicación (si no están presentes) de la siguiente manera:

        @Bean
        ObjectMapper objectMapper() {
            return new ObjectMapper();
        }

        @Bean
        MessageLogger messageLogger() {
            return messageLogEntry -> log.info("log entry: {}", messageLogEntry);
        }