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:
(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:
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:
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:
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:
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.