SpringCache integra EhCache2 y EhCache3 (JCache)

Introducción

En el proyecto, quiero usar EhCache como memoria local, y EhCache existe en dos versiones principales, una es 2 y la otra es 3. La diferencia entre los dos es muy grande y es fácil caer en trampas durante la integración : la mayoría (casi todas) las integraciones en Internet se basan en la versión EhCache2 y se configuran a través de xml . Si usa EhCache3 importado por maven en En el proyecto , ¡los métodos de integración serán muy diferentes!
Este artículo presenta principalmente cómo integrar EhCache3 y SpringCache.
Por supuesto, el uso de otros métodos se menciona brevemente de pasada para proporcionar contraste.

Usando EhCache solo

No se requiere configuración adicional, se puede utilizar el paquete de guía. Simplemente mire los ejemplos en el sitio web oficial y no entrará en detalles.

CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder() 
    .withCache("preConfigured",
        CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.heap(10))) 
    .build(); 
cacheManager.init(); 

Cache<Long, String> preConfigured =
    cacheManager.getCache("preConfigured", Long.class, String.class); 

Cache<Long, String> myCache = cacheManager.createCache("myCache", 
    CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.heap(10)));

myCache.put(1L, "da one!"); 
String value = myCache.get(1L); 

cacheManager.removeCache("preConfigured"); 

cacheManager.close(); 

Integrar EhCache2 y SpringCache

1. Importe la dependencia maven de EhCache2
2. Configure en el archivo de configuración de la aplicación:

spring:
  cache:
    type: ehcache
  ehcache:
  	config: ehcache.xml

3. Escriba el archivo de configuración ehcache.xml y colóquelo en el directorio de recursos
4. @EnableCaching
ahora está integrado y puede usar @Cacheable y otras anotaciones en el proyecto.

Integrar EhCache3 y SpringCache

1. Importe la dependencia maven de EhCache3
2. Configure en el archivo de configuración de la aplicación:

spring:
  cache:
    type: jcache

¡Asegúrate de prestar atención, es del tipo jcache! ! ! ¡No es caché! ! !
3.Escribir clase de configuración

package top.dumbzarro.greensource.coupon.config;

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.jcache.JCacheCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import top.dumbzarro.greensource.coupon.entity.CouponEntity;

import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.configuration.MutableConfiguration;
import javax.cache.expiry.CreatedExpiryPolicy;
import javax.cache.expiry.Duration;
import javax.cache.spi.CachingProvider;

/**
 * Description: 整合 SpringCache 和 EhCache
 */
@EnableCaching
@Configuration
public class MyCacheConfig {
    
    
    @Bean
    JCacheCacheManager ehcacheConfiguration() {
    
    

        // 缓存配置
        MutableConfiguration<Integer, CouponEntity> configuration = new MutableConfiguration<Integer, CouponEntity>()
                .setTypes(Integer.class, CouponEntity.class)
                .setStoreByValue(false)
                .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ONE_MINUTE));

        // cacheManager
        CachingProvider cachingProvider = Caching.getCachingProvider();
        CacheManager cacheManager = cachingProvider.getCacheManager();
        cacheManager.createCache("coupon", configuration);

        // jcache
        JCacheCacheManager JCache = new JCacheCacheManager();
        JCache.setCacheManager(cacheManager);

        return JCache;
    }
}

Debes prestar atención al paquete en el que se encuentra cada clase. Muchos tutoriales de integración por la noche omiten el paquete en el que se encuentra la clase introducida, incluida la oficial. Esto trae problemas a algunos novatos (como yo) que no están Familiarícese con él al integrarlo. Muchos problemas.
Solo CacheManager tiene tres

paquetes de clases utilizadas durante la integración. Los he enumerado todos y están todos en el paquete javax. Las razones específicas se analizarán a continuación.

4.@EnableCaching
ahora está integrado y puede usar @Cacheable y otras anotaciones en el proyecto.

Por supuesto, la configuración anterior es solo uno de los métodos de configuración simplificados de EhCache. EhCache3 aún se puede integrar mediante la configuración xml. Para conocer métodos específicos, consulte el sitio web oficial de Ehcache.

JCache también conocido como JSR-107

¿Por qué se configura spring.cache.tpye en la configuración al integrar EhCache3 jcache en lugar de ehcache?
Echemos un vistazo a la introducción en el sitio web oficial de Spring. Lo importante es que SpringCache no es otro marco como Spring Date y Spring Security. Está incluido en el módulo de integración de Spring Framework. El texto original del sitio web oficial es de la siguiente manera

:

Spring proporciona algunas implementaciones de esa abstracción: cachés basados ​​en JDK java.util.concurrent.ConcurrentMap, Ehcache 2.x, caché Gemfire, Caffeine y cachés compatibles con JSR-107 (como Ehcache 3.x). Consulte Conexión de diferentes cachés de back-end para obtener más información sobre cómo conectar otros almacenes y proveedores de caché.

Esto significa que SpringCache proporciona algunas implementaciones para ayudarnos a integrar Ehcache 2.x, Caffeine, JSR-107 (como Ehcache3) y otros marcos. En otras palabras, cuando integramos Ehcache3, necesitamos integrar JSR-107, no Ehcache.

El sitio web oficial proporciona un método para integrarlo en Spring, pero estamos usando Springboot y queremos que se inyecte automáticamente.
Específicamente cómo integrarlo en Springboot, el sitio web oficial no lo dice, pero podemos ver que Springboot proporciona un cacheManager para el contenedor, y SpringCache proporciona una implementación para JSR-107 de forma predeterminada. En el paquete JCache, se llama JCacheCacheManger.
La primera vez que pensé en esto fue crear uno nosotros mismos y luego usar @Bean para tirarlo al contenedor.
Esta clase también es fácil de crear y new JCacheCacheManager();se puede construir directamente sin parámetros. Después de ejecutarlo, se informará el error "No se puede encontrar el cacheManager disponible", pero en consecuencia descubrimos que este administrador no proporciona ningún método createCache. Solo admite configurar cacheManager y obtener cacheManager. Obviamente, este JCacheCacheManager en realidad es una fachada. Necesitamos implementar un cacheManager específico, y el tipo de cacheManager que establece está en el paquete javax. Esto también es fácil para las personas saber que el principio de implementación de SpringCache en esta parte es el mecanismo SPI (si no sabe cuál es) Es un mecanismo SPI, entonces puede pensar en el paquete sql también en el paquete javax)
Entonces, para resumir, actualmente necesitamos construir un cacheManager. La clase de implementación específica la proporciona EhCache. Lo hemos importado a través de maven, y ahora usamos javax.cache para crear una instancia de cacheManager usando la interfaz definida en .
Por supuesto, no sabemos exactamente cómo construirlo. Esto no está dentro del alcance de SpringCache y, por supuesto, no se puede encontrar en la documentación de SpringCache, por lo que podemos suponer razonablemente que el sitio web oficial de EhCache3 debería tener ejemplos relevantes. . Lo encontré cuando lo busqué.

No entraré en detalles sobre lo que sigue, ya que se puede escuchar claramente lo que está escrito en los documentos oficiales.

escribe al final

A medida que el conocimiento que aprende se vuelve cada vez menos "popular", la ayuda de blogs relacionados a veces conduce a algunos errores. Puede ser un problema de versión u otros problemas. En resumen, encontrará que confiar en documentos oficiales causará cierta confusión. más y más pesado. De hecho, debido a que esta integración es una práctica personal, no hay demasiados requisitos de rendimiento, características, etc., es del tipo que se puede utilizar, de hecho, los problemas que surgen durante esta integración se pueden cambiar por completo desde la versión 3. Con un poco de esfuerzo a la versión 3. En dos, el problema se puede resolver fácilmente. Sin embargo, esta vez me obligué a leer los documentos oficiales e integrarlos yo mismo, porque es previsible que esta sea una habilidad indispensable en el futuro. Después de varias horas de lectura e intentos, la integración finalmente fue exitosa. Me siento muy realizado y he ganado mucho más que el resultado de una integración exitosa: ya no tengo miedo del inglés ni de los documentos oficiales.
Además, también obtuve algunos pequeños puntos de conocimiento. Por ejemplo, hay una breve sección en el documento SpringCache que explica la diferencia entre Buffer y Cache. Nunca antes había hecho esta distinción y me sentí iluminado después de leerlo. También me gustaría compartirlo con ustedes aquí:

un breve resumen es:

• El búfer se utiliza para aliviar el problema de que los dispositivos rápidos tengan que esperar a que lleguen los dispositivos lentos dividiéndolos en partes enteras para mejorar el rendimiento.
• Los mismos datos solo se recuperan una vez del búfer.
• La caché mejora el rendimiento al permitir que los datos se lean rápidamente
• Los mismos datos se leen varias veces en la memoria caché.