Explicación detallada de Ehcache integrado de SpringBoot para implementar el mecanismo de almacenamiento en caché

Ehcache es un marco de almacenamiento en caché en proceso de Java puro, con características rápidas y Lean, y es el CacheProvider predeterminado en Hibernate.

Ehcache proporciona una variedad de estrategias de almacenamiento en caché, principalmente divididos en los niveles de memoria y disco, por lo que no hay necesidad de preocuparse por los problemas de capacidad.

Spring-Boot es un marco de integración rápido diseñado para simplificar el proceso inicial de construcción y desarrollo de las nuevas aplicaciones de resorte. El marco utiliza una forma específica de configurarlo, de modo que los desarrolladores ya no necesitan definir configuraciones de calderas.

Dado que Spring-Boot no requiere ningún archivo de configuración de Boilerplate, Spring-Boot será ligeramente diferente al integrar otros marcos.

1.spring-boot es un marco para los paquetes JAR gestionados a través de Maven. Las dependencias necesarias para integrar EHCACHE son las siguientes

 <Spendency> <MoupRupid> org.springframework </groupid> <artifactid> spring-Context-support </artifactid> </pepertency> <pendency> <uproupid> net.sf.ehcache </groupid> <artifactid> ehcache </artifactid> <preation> 2.8.3 </versión> </pendency>

El archivo pom.xml específico es el siguiente

 <? xml versión = "1.0" encoding = "utf-8"?> <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschemainstance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelversion> 4.0.0 </modelversion> <grupo> com.lclc.Boot </groupid> <artifactid> <Versión> 0.0.1-Snapshot </versión> <!-Herherit Defals desde Spring Boot-> <Parent> <MoupRoD> org.springframework.boot </groupid> <artifactid> spring-boot-starter-parent </artifactid> <versión> 1.1.3.Release </lotion> </rent> <pendences> <pendency>> <MoupRoD> org.springframework.boot </groupid> <artifactID> spring-boot-starter-web </artifactid> </pepertency> <paper> <moupRupid> org.springframework.boot </proupId> <arifactid> spring-boot-starter-data-jpa </artifactid> </spendency> </artifactid> spring-boot-starter-data-jpa </artifactid> </spendency> <MoupRoD> org.springframework.boot </groupid> <artifactid> spring-boot-starter-thymeleaf </arfactid> </pendency> <pendency> <proupid> mysql </groupid> <arfactid> mysql-connector-java </artifactid> </pendency> <pendency>> <MoupRid> com.google.guava </groupid> <artifactid> guava </artifactid> <versión> 17.0 </versión> </pendency> <pendency> <proupid> org.ssspringframework </groupid> <artifactid> spring-context-support </arfactid> </pendency> <pendency> <MoupRid> net.sf.ehcache </proupid> <artifactid> ehcache </artifactid> <versión> 2.8.3 </versión> </pendency> </dependencias> <pendencymanagement> <pendencies> </pendencies> </pendencs> </dependencias> </dependencias> </pendences> </pendences> </pendencs> <glugins> <MoupRid> org.springframework.boot </groupid> <artifactid> spring-boot --maven-plugin </artifactid> </glugin> </glugins> </build> <repositories> <epository> <d <d> springsnapshots </id> <url> http://Repo.ssnapshot </urlApshot </urly <Snstapshots> <Enedably> true </habilitado> </snstapshots> </epository> <Repository> <id> Spring-Milestones </id> <url> http://repo.spring.io/milestone </url> </repositorio> </repository> </repository> <gluginRepository> <gluginRepository> <Di> Spring-Snapshots </id> <url> http://repo.spring.io/snapshot </url> </pluginrepository> <gluginrepository> <id> spring-milestones </id> <url> http://repo.spring.io/milESTone </url> </pluginrep </pluginRepositories> </proyecto>

2. Usando ehcache, necesitamos un ehcache.xml para definir algunos atributos de caché.

 <? xml versión = "1.0" encoding = "utf-8"?> <ehcache xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: nonamespaceschemalocatation = "http://ehcache.org/ehcache.xsd" <diskstore path = "java.io.tmpdir /tmp_ehcache" /> <defaultcache eternal = "false" maxelementsInmemory = "1000" overflowTodisk = "false" diskpersistent = "falso" timetoidleseConds = "0" TimetoliveSeconds = "600" MemoryStoreevictionPolicy name = "Demo" Eternal = "False" MaxElementSInmemory = "100" OverflowTodisk = "False" diskpersistent = "falso" timetoidleseConds = "0" timetoliveSeConds = "300" MemoryStoreEvictionPolicy = "lru" /> </cache>>

Explique las etiquetas en este archivo XML.

(1) .DiskStore: es la ruta de caché, Ehcache se divide en dos niveles: memoria y disco. Esta propiedad define la ubicación del caché del disco. Los parámetros se explican de la siguiente manera:

1. Usuario. Directorio de inicio del usuario de casos
2. usuario.dir directorio de trabajo actual del usuario
3. java.io.tmpdir ruta de archivo temporal predeterminado

(2) .DefaultCache: la política de caché predeterminada. Cuando Ehcache no puede encontrar el caché definido, se utilizará esta política de caché. Solo uno puede definirse.

(3) .Cache: política de caché personalizado, una política de caché personalizado. Los parámetros se explican de la siguiente manera:

1. Propiedades del elemento Cache:
2. Nombre: nombre de caché
3. maxelementsInMemory: número máximo de objetos en caché en la memoria
4. MaxelementSondisk: el número máximo de objetos almacenados en caché en el disco duro. Si es 0, significa infinito
5. Eternal: Verdadero significa que el objeto nunca vence. En este momento, se ignorarán las propiedades de los timetoidlesegundos y el timetoliveSeconds, y el valor predeterminado es falso
6. OverflowTodisk: Verdadero significa que cuando el número de objetos almacenados en caché en la memoria alcanza el límite MaxElementSInMemory, los objetos desbordados se escribirán en el caché de disco duro. Nota: Si el objeto en caché se va a escribir en el disco duro, el objeto debe implementar la interfaz serializable.
7. DiskspoolBufferSizember: Tamaño del caché de disco, el valor predeterminado es de 30 MB. Cada caché debe tener su propio área de caché.
8. DiskPersistente: si se debe almacenar en caché los datos de la máquina virtual durante los datos
9. DiskexpiryThreadIntervalSeconds: intervalo de tiempo de ejecución de hilo de falla del disco, el valor predeterminado es de 120 segundos
10. Timetoidlesegundos: establece el tiempo máximo para permitir que el objeto esté inactivo, en segundos. Cuando se accede al objeto por última vez, si el valor de la propiedad TimetoidleseConds excede el valor de la propiedad TimetoidleseConds, el objeto caducará y Ehcache lo borrará del caché. Esta propiedad solo es válida si la propiedad eterna es falsa. Si el valor de la propiedad es 0, significa que el objeto puede estar inactivo indefinidamente
11. TimetoliveSeconds: establece el tiempo máximo que el objeto permite existir en el caché, en segundos. Cuando el objeto se ha almacenado en el caché, si el tiempo en la memoria caché excede el valor de la propiedad TimetoliveSeconds, el objeto caducará y Ehcache lo borrará del caché. Esta propiedad solo es válida si la propiedad eterna es falsa. Si el valor de la propiedad es 0, significa que el objeto puede existir en el caché indefinidamente. TimetoliveSeconds debe ser mayor que la propiedad del timetoidlesegunds para tener sentido
12. MemoryStoreEvictionPolicy: cuando se alcanza el límite maxelementsInMemory, Ehcache limpiará la memoria de acuerdo con la política especificada. Las políticas opcionales son: LRU (la última política de usado recientemente usado), FIFO (primero en, primero fuera) y LFU (número mínimo de visitas).

SpringBoot admite muchos métodos de almacenamiento en caché: Redis, Guava, Ehcahe, Jcache, etc.

Explique la diferencia entre Redis y Ehcache:

Redis: es un programa de ejecución independiente. Después de la instalación solo, se manipula usando JEDIS en Java. Debido a que es independiente, si escribe un programa de prueba unitaria, coloque algunos datos en Redis y luego escriba otro programa para obtener los datos, puede obtener los datos. ,
EHCACHE: Obviamente es diferente de Redis, está vinculado a los programas Java. Cuando el programa Java está vivo, está vivo. Por ejemplo, si escribe un programa independiente para poner datos y luego escribe un programa independiente para obtener datos, no obtendrá datos. Los datos solo se pueden obtener en programas independientes.

3. Exponga el administrador de ehcache al contenedor de contexto de primavera.

 @Configuración // La anotación inicia el caché @enablecachingpublic class Cacheconfiguration {/** ehcache Main Manager*/ @Bean (name = "Appehcachecachemanager") public ehcachecachemanager ehcacheCachemanager (ehcachemanagerBean bean) {return newcacheCachemanager ((); } / * * Según la configuración de compartir o no, Spring crea una base de ehcache a través de Cachemanager.Create () o nuevo Cachemanager () respectivamente. */ @Bean public ehcachemanagerFactoryBean EhcachemanagerFactoryBean () {ehcachemanagerFactoryBean CachemanagerFactoryBean = new EhcachemanagerFactoryBean (); CachemanagerFactoryBean.SetConfigLocation (nuevo classpathResource ("conf/ehcache-app.xml")); CachemanagerFactoryBean.SetShared (verdadero); regresar CachemanagerFactoryBean; }}

@Configuration: Anotado para Boot Spring-Boot, principalmente anotado como una clase de configuración, y se da prioridad al escaneo.

@Bean: Agregue el frijol al contenedor de resorte.

Todas las configuraciones se realizan hasta ahora, e integrar el marco a través de Spring-Boot es así de simple.

4. Use ehcache

El uso de ehcache se realiza principalmente a través del mecanismo de caché de resorte. Hemos implementado el mecanismo de caché de primavera utilizando ehcache, por lo que podemos usar el mecanismo de caché de resorte completamente en términos de uso.

Hay algunas notas involucradas:

@Cacheable: responsable de agregar el valor de retorno del método al caché, el parámetro 3
@CacheEvict: responsable de borrar caché, parámetro 4

Explicación del parámetro:

1. Valor: el nombre de ubicación de caché no puede estar vacío. Si se usa ehcache, es el nombre del caché declarado en ehcache.xml
2. Clave: la clave en caché, el valor predeterminado está vacío, lo que significa que el tipo de parámetro y el valor del parámetro del método utilizado como clave y admite Spel
3. Condición: Condición de activación, solo si se cumple la condición se agregará al caché. El valor predeterminado está vacío, lo que significa que todos se agregan al caché y admite Spel
4. AllEnentries: CacheEvict Parameter, verdadero significa borrar todos los cachés en el valor, el valor predeterminado es falso

Sin más ADO, simplemente suba el código:

 @ServicePublic clase CachedemosServiceImpl implementa CachedemosService {/** * Cache Key */public static final String Thing_all_key = "/" Thing_all/""; /*** El atributo de valor indica qué política de caché utilizar. La política de caché se encuentra en ehcache.xml */ public static final String demo_cache_name = "demo"; @CacheEvict (value = demo_cache_name, key = thing_all_key) @Override public void create (Thing Thing) {long id = getNextId (); Thing.SetId (id); data.put (id, cosa); } @Cacheable (valor = demo_cache_name, key = "#thing.getid () + 'thing'") @Override public Things FindById (Long ID) {System.err.println ("¡Sin caché!" + ID); return data.get (id); } @Cacheable (valor = demo_cache_name, key = thing_all_key) @Override Public List <Ting> findall () {return lists.newarrayList (data.values ​​()); } @Override @Cacheput (value = Demo_cache_name, Key = "#Thing.getID ()+'Thing'") @CacheEvict (valor = Demo_cache_name, Key = Thing_all_Key) public What Update (Thing) {System.out.println (cosa); data.put (Thing.getID (), Thing); volver a la cosa; } @CacheEvict (valor = demo_cache_name) @Override public void Delete (Long ID) {data.remove (id); }}

5. Solo necesita anotar en el método de la capa de servicio a través de anotaciones y puede usar el caché, almacenar el caché en Find ** y borrar el caché en Delete ** y actualizar **.

Explicación detallada de las anotaciones de caché

@CacheconFig: se usa principalmente para configurar algunas configuraciones de caché comunes que se utilizarán en esta clase. Aquí @CacheConFig (Cachenames = "Usuarios"): el contenido devuelto en el objeto de acceso de datos está configurado para almacenarse en el objeto de caché con nombre de usuarios. También podemos definirlo directamente a través del propio nombre del conjunto de caché de @Cacheable sin usar esta anotación.

@Cacheable: el valor de retorno de la función FindByName configurada se agregará al caché. Al mismo tiempo, al consultar, primero obtendrá del caché, y si no existe, se iniciará el acceso a la base de datos. Esta anotación tiene principalmente los siguientes parámetros:

1. Valor y nombres de cachenaje: dos parámetros equivalentes (los nombres de cachena se agregan a Spring 4 como un alias para el valor), que se utiliza para especificar el nombre de la colección del almacenamiento de caché. Dado que @CacheConFig se agrega en la primavera 4, el atributo de valor que se requirió originalmente en la primavera 3 también se ha convertido en un no esencial
2. Clave: No se requiere el valor clave almacenado en la colección de mapas de los objetos de caché. Por defecto, todos los parámetros de la función se combinan como el valor clave. Si lo configura usted mismo, debe usar expresiones de Spel, como: @cacheable (key = "#p0"): use el primer parámetro de la función como el valor de la tecla en caché. Para obtener más detalles sobre las expresiones de Spel, consulte el documento oficial.
3. CONDICIÓN: No se requieren las condiciones para los objetos de caché, y también se requieren expresiones de Spel. Solo el contenido que cumpla con las condiciones de expresión será almacenado en caché. Por ejemplo: @Cachable (Key = "#P0", condición = "#P0.Length () <3"), lo que significa que se almacenará en caché solo cuando la longitud del primer parámetro sea inferior a 3. Si el usuario de AAA en esta configuración no será almacenado en caché, los lectores pueden experimentar y probarlo por su cuenta.
4. A menos: otro parámetro condicional de caché, que no es necesario, requiere el uso de la expresión de Spel. Lo que lo hace diferente del parámetro de condición radica en su tiempo de juicio. Esta condición se juzga solo después de que se llama la función, por lo que puede juzgarse por el resultado.
5. KeyGenerator: se usa para especificar el generador de claves, no requerido. Si necesita especificar un generador de claves personalizado, necesitamos implementar la interfaz org.springframework.cache.interceptor.KeyGenerator y usar este parámetro para especificarlo. Cabe señalar que este parámetro y clave son mutuamente excluyentes
6. Cachemanager: se usa para especificar qué administrador de caché usar, no es necesario. Use solo si hay múltiples
7. CACHERESOLVER: se utiliza para especificar qué analizador de caché usar, no requerido. Debe implementar su propio analizador de caché a través de la interfaz org.springframework.cache.interceptor.cacheresolver y especificarlo con este parámetro.

Además de las dos anotaciones utilizadas aquí, también hay las siguientes anotaciones básicas:

@Cacheput: Configurado en una función, se puede almacenar en caché de acuerdo con los parámetros y define las condiciones. A diferencia de @Cachable, realmente llama a la función cada vez, por lo que se usa principalmente para operaciones de adición y modificación de datos. Sus parámetros son similares a @Cachable. Para funciones específicas, consulte el análisis anterior de los parámetros @Cachable.

@CacheEvict: configurado en funciones, generalmente utilizadas en los métodos de eliminación, para eliminar los datos correspondientes de la caché. Además de los mismos parámetros que @Cachable, tiene los siguientes dos parámetros:

1. Allentries: no esencial, predeterminado a falso. Cuando es cierto, todos los datos se eliminan
2. Antes de la invocación: no esencial, el valor predeterminado es falso y los datos se eliminarán después de que se llame al método. Cuando es verdadero, los datos se eliminan antes de llamar al método.

Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.