EHCache 技术文档缓存 spring缓存

合集下载

Springboot使用cache缓存过程代码实例

Springboot使⽤cache缓存过程代码实例1.pom.xml<dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId></dependency>2.ehcache.xml<?xml version="1.0" encoding="UTF-8"?><ehcache><diskStore path="java.io.tmpdir"/><defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"maxElementsOnDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></defaultCache><cache name="usercache"maxElementsInMemory="1"eternal="true"overflowToDisk="true"maxElementsOnDisk="0"diskPersistent="true"> </cache>diskStore是物理⽂件的存储路径，cache标签中的name是多cache时区分的唯⼀标识，和程序中初始化⽅法getCache("***")参数⼀致。

Spring AOP+ehCache简单缓存系统解决方案

需要使用Spring来实现一个Cache简单的解决方案，具体需求如下：使用任意一个现有开源Cache Framework，要求可以Cache系统中Service或则DAO层的get/find等方法返回结果，如果数据更新（使用Create/update/delete方法），则刷新cache中相应的内容。

根据需求，计划使用Spring AOP + ehCache来实现这个功能，采用ehCache原因之一是Spring提供了ehCache的支持，至于为何仅仅支持ehCache而不支持osCache和JBossCache无从得知(Hibernate???)，但毕竟Spring提供了支持，可以减少一部分工作量：)。

二是后来实现了OSCache和JBoss Cache的方式后，经过简单测试发现几个Cache在效率上没有太大的区别(不考虑集群)，决定采用ehCahce。

AOP嘛，少不了拦截器,先创建一个实现了MethodInterceptor接口的拦截器,用来拦截Service/DAO的方法调用，拦截到方法后，搜索该方法的结果在cache中是否存在，如果存在，返回cache 中的缓存结果，如果不存在，返回查询数据库的结果，并将结果缓存到cache中。

MethodCacheInterceptor.java代码:package com.co.cache.ehcache;import java.io.Serializable;import net.sf.ehcache.Cache;import net.sf.ehcache.Element;importorg.aopalliance.intercept.MethodInter ceptor;importorg.aopalliance.intercept.MethodInvoc ation;import mons.logging.Log; importmons.logging.LogFactory;importorg.springframework.beans.factory.Ini tializingBean;importorg.springframework.util.Assert;public class MethodCacheInterceptor implements MethodInterceptor, InitializingBean{private static final Log logger = LogFactory.getLog(MethodCacheIntercep tor.class);private Cache cache;public void setCache(Cache cache) { this.cache = cache;}public MethodCacheInterceptor() {super();}/*** 拦截Service/DAO的方法，并查找该结果是否存在，如果存在就返回cache中的值，* 否则，返回数据库查询结果，并将查询结果放入cache*/public Objectinvoke(MethodInvocation invocation) throws Throwable {String targetName =invocation.getThis().getClass().getNa me();String methodName =invocation.getMethod().getName();Object[] arguments =invocation.getArguments();Object result;logger.debug("Find object from cache is " + cache.getName());String cacheKey =getCacheKey(targetName, methodName, arguments);Element element =cache.get(cacheKey);if (element == null) {logger.debug("Hold up method , Get method result and create cache........!");result = invocation.proceed(); element = new Element(cacheKey, (Serializable) result);cache.put(element);}return element.getValue();}/*** 获得cache key的方法，cache key是Cache中一个Element的唯一标识* cache key包括包名+类名+方法名，如erServiceImpl. getAllUser*/private String getCacheKey(String targetName, String methodName, Object[] arguments) {StringBuffer sb = newStringBuffer();sb.append(targetName).append("." ).append(methodName);if ((arguments != null) && (arguments.length != 0)) {for (int i = 0; i <arguments.length; i++) {sb.append(".").append(argu ments[i]);}}return sb.toString();}/*** implement InitializingBean，检查cache是否为空*/public void afterPropertiesSet() throws Exception {Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");}}上面的代码中可以看到，在方法public Object invoke(MethodInvocation invocation) 中，完成了搜索Cache/新建cache的功能。

Springboot整合ehcache缓存

Springboot整合ehcache缓存EhCache是⼀个⽐较成熟的Java缓存框架，最早从hibernate发展⽽来，是进程中的缓存系统，它提供了⽤内存，磁盘⽂件存储，以及分布式存储⽅式等多种灵活的cache 管理⽅案，快速简单。

Springboot对ehcache的使⽤⾮常⽀持，所以在Springboot中只需做些配置就可使⽤，且使⽤⽅式也简易。

在你的项⽬上配置以下⼏步即可使⽤⾸先，⽼规矩,pom.xml加依赖;<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency><dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId></dependency>第⼆步，创建ehcache.xml配置⽂件位置：classpath⽬录下，即src/main/resources/ehcache.xml⽂件内容开发的时候可参考第⼀步导⼊的jar包，具体在哪呢，看下⾯：再看代码：<ehcache xmlns:xsi="/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd"><diskStore path="java.io.tmpdir"/><defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"maxElementsOnDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></defaultCache><cache name="users"maxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"maxElementsOnDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></cache></ehcache>　说明：<diskStore path="java.io.tmpdir"/>这个是磁盘存储路径，当内存缓存满了的时候，就会往这⾥⾯放，java.io.tmdir是操作系统缓存的临时⽬录，不同操作系统缓存⽬录不⼀样。

SpringBoot项目中EhCache缓存技术的实现

SpringBoot项目中EhCache缓存技术的实现作者：王萍来源：《电脑知识与技术》2021年第29期摘要：从本质上看，EhCache是一个缓存管理器，不仅可以和Hibernate配合实现缓存，也可以和其他框架比如spring boot结合，作为一个缓存管理器，该文这里举一个例子，来论述SpringBoot项目中EhCache缓存技术的实现过程，以“spring boot + mybatis + EhCache”实现本地缓存为例，探讨了SpringBoot项目中EhCache缓存技术的实现。

关键词：SpringBoot项目;EhCache;缓存技术中图分类号：TP311 文献标识码：A文章编号：1009-3044（2021）29-0079-031概述1.1 SpringBootSpringBoot是由Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring应用的初始搭建以及开发过程。

该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

通过这种方式，SpringBoot在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。

简而言之，SpringBoot是当前 web 开发主流，其简化了 Spring 的配置让开发者能够更容易上手Web项目的开发。

由于Spring 的发展、微服务的发展使得SpringBoot越来越流行，已经成为JavaWeb开发的主流框架。

1.2 Spring Boot的缓存机制SpringBoot高速缓存抽象不提供实际存储，且依赖于由org. springframework.cache.Cache 和org.springframework.cache.Cache⁃ Manager接口实现的抽象。

Spring Boot根据自动配置实现合适的CacheManager，只要缓存支持通过@EnableCaching 注释启用即可。

ehcache缓存的详细配置

用到缓存，主要是用来解决并发问题的。

其中ehcache是一个纯Java的过程中缓存实现Hibernate2.1,Spring都支持EHcache嵌入。

本文主要写Spring中引入ehcache而不是用hibernate.ehcache部署起来很简单，主要分两步：1.首先要给他写个核心配置XML文件Xml代码<ehcache><diskStore path="java.io.tmpdir"/><defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"overflowToDisk="true"diskPersistent="false"diskExpiryThreadIntervalSeconds ="120"memoryStoreEvictionPolicy="LRU"/><cache name="cache1"maxElementsInMemory="10000"eternal="false" maxEle mentsOnDisk="1000"overflowToDisk="true"timeToIdleSeconds="300"timeToLiveSeconds="600"memoryStoreEvictionPolicy="LFU"/></ehcache>属性解释：简单配置，在ehcache.xml文件中有此配置，在使用Ehcache前最好将其删除掉，自己配置。

Ehcache+SpringJob缓存策略

diskPersistent - Whether the disk store persists between restarts of the Virtual
Machine. The default value is false.
diskExpiryThreadIntervalSeconds - The numbehe disk expiry thread. The
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "/dtd/spring-beans-2.0.dtd"> <beans default-autowire="autodetect" default-lazy-init="true">
</property> </bean>  <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers"> <list> <ref bean="cacheTrigger" /> </list>
default value is 120 seconds.
4. spring Job 配置
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"

spring-ehcache缓存配置（注解方式）

spring-ehcache缓存配置（注解方式）spring cacheSpring 3.1 引入了激动人心的基于注释（annotation）的缓存（cache）技术，它本质上不是一个具体的缓存实现方案（例如EHCache 或者OSCache），而是一个对缓存使用的抽象，通过在既有代码中添加少量它定义的各种annotation，即能够达到缓存方法的返回对象的效果。

Spring 的缓存技术还具备相当的灵活性，不仅能够使用SpEL（Spring Expression Language）来定义缓存的key 和各种condition，还提供开箱即用的缓存临时存储方案，也支持和主流的专业缓存例如EHCache 集成。

其特点总结如下：∙通过少量的配置annotation 注释即可使得既有代码支持缓存∙支持开箱即用Out-Of-The-Box，即不用安装和部署额外第三方组件即可使用缓存∙支持Spring Express Language，能使用对象的任何属性或者方法来定义缓存的key 和condition∙支持AspectJ，并通过其实现任何方法的缓存支持∙支持自定义key 和自定义缓存管理者，具有相当的灵活性和扩展性本人主要讲解spring与ehcache整合方法（基于maven项目），至于spring cache 详细介绍请参考《注解驱动的spring cache 缓存介绍》，为了能更好的理解，建议在看本文前先把这篇的文章的例子做一遍。

maven jar包准备工作主要需要如下几个slf4j-log4j12 （log4j日志）ehcache-core （ehcache核心包）spring-webm vc （spring webmvc）spring-context-support(spring 上下文扩展包)测试需要junitspring-test好了以上这些足够，不用再添加其他的内容。

当然maven项目会自动将依赖报加载进来。

SpringBoot中的缓存支持(一)注解配置与EhCache使用

中的缓存支持（一）注解配置与 EhCache 使用随着时间的积累，应用的使用用户不断增加，数据规模也越来越大，往往数据库查询操作会成为影响用户使用体验的瓶颈，此时使用缓存往往是解决这一问题非常好的手段之Spring 3 开始提供了强大的基于注解的缓存支持，可以在 Spring Boot 中对于缓存的支持，提供了一系列的自动化配置，使我们可以非常方便的使用缓存。

下面我们通过一个简单的例子来展示，我们是如何给一个既有应用增加缓存功能的。

快速入门首先，下载样例工程 chapter3-2-2 。

本例通过 spring-data-jpa实现了对 User 用户表的一些操作，若没有这个基础，可以先阅读《使用 Spring-data-jpa 简化数据访问层》一文对数据访问有所基础。

准备工作为了更好的理解缓存，我们先对该工程做一些简单的改造。

application.properties 文件中新增spring.jpa.properties.hibernate.show_sql=true ，开启 hibernate 对 sql 语句的打印Spring Boot 通过注解配置方式低侵入的给原有 Spring 应用增加缓存功能，提高数据访问性能台匕修改单元测试ApplicationTests ，初始化插入User 表一条用户名为AAA ，年龄为10 的数据。

并通过findByName 函数完成两次查询。

@RunWith(SpringJUnit4ClassRunner.class)@SpringApplicationConfiguration(Application.class) public class ApplicationTests {@Autowired private UserRepository userRepository;@Before public void before() {userRepository.save(new User("AAA", 10));@Testpublic void test() throws Exception {User u1 = userRepository.findByName("AAA");System.out.println(" 第一次查询：" +u1.getAge());User u2 = userRepository.findByName("AAA");System.out.println(" 第二次查询：" +u2.getAge());执行单元测试，我们可以在控制台中看到下面内容。

EHCache详解_技术文档

目录0. 文档介绍 (2)0.1文档目的 (2)0.2文档范围 (2)0.3读者对象 (2)0.4参考文献 (2)0.5术语与缩写解释 (3)1.概述 (4)1.1背景 (4)1.2主要特征 (3)1.3环境 (5)1.4下载资源 (5)2. EHCACHE页面缓存的配置 (5)2.1EHC ACHE的类层次模型 (5)2.2环境搭建 (6)2.3 EHCACHE配置文件中元素说明................................................... 错误！未定义书签。

2.4在工程中单独使用...................................................................... 错误！未定义书签。

3. 在SPRING中运用EHCACHE ....................................................... 错误！未定义书签。

4. 分布式缓存集群环境配置 (19)4.1集群配置方式 (19)5. 测试用例 (28)0. 文档介绍0.1 文档目的记录使用EHCache实现页面级的缓存以及完成集群设计的过程。

0.2 文档范围记录使用EHCache实现页面级的缓存以及完成集群设计的过程。

0.3 读者对象任何有兴趣的家伙。

0.4 参考文献提示：列出本文档的所有参考文献（可以是非正式出版物），格式如下：[标识符] 作者，文献名称，出版单位（或归属单位），日期大部分都是网络上查询的资料，很多，不列举了。

0.5 术语与缩写解释1.概述1.1背景系统缓存是位于应用程序与物理数据源之间，用于临时存放复制数据的内存区域，目的是为了减少应用程序对物理数据源访问的次数，从而提高应用程序的运行性能. 缓存设想内存是有限的，缓存的时效性也是有限的，所以可以设定内存数量的大小，可以执行失效算法，可以在内存满了的时候，按照最少访问等算法将缓存直接移除或切换到硬盘上。

ehcache 缓存参数 -回复

ehcache 缓存参数-回复关于ehcache缓存参数的文章引言：在现代软件开发中，为了提高系统的性能和响应速度，应用程序经常会使用缓存来存储经常访问的数据。

ehcache是一个Java缓存库，它提供了丰富而强大的缓存功能。

本文将深入探讨ehcache缓存参数的相关知识，帮助读者了解如何优化和配置ehcache缓存以提高系统的性能。

第一部分：什么是ehcache缓存1.1 缓存的定义和作用缓存是一种将数据存储在临时存储器中的技术，以便可以快速地检索和更新数据。

它可以在磁盘或内存中存储数据，并可以根据需求设置缓存失效策略。

1.2 ehcache简介ehcache是一个广泛使用的Java缓存库，它提供了高性能、可扩展和可靠的缓存功能。

它可以与各种Java框架集成，如Spring、Hibernate等。

第二部分：ehcache缓存参数的配置2.1 缓存的初始化和配置要使用ehcache缓存，首先需要在应用程序中添加ehcache的依赖，并在项目的配置文件中进行相应的配置。

2.2 重要的ehcache缓存参数ehcache提供了一些重要的缓存参数，可以通过配置文件进行设置。

下面是其中一些常用参数的说明：- timeToIdleSeconds：设置对象在缓存中的空闲时间。

如果对象在指定的时间间隔内没有被访问，那么它将被从缓存中移除。

- timeToLiveSeconds：设置对象在缓存中的存活时间。

如果对象存活时间超过指定的时间间隔，那么它将被从缓存中移除。

- maxEntriesLocalHeap：在堆内存中存储的最大缓存对象数。

- maxEntriesLocalDisk：在磁盘中存储的最大缓存对象数。

- diskExpiryThreadIntervalSeconds：设置缓存失效检查线程的执行间隔时间。

2.3 缓存参数配置的注意事项在配置ehcache缓存参数时，需要注意以下几点：- 根据应用程序的需求合理设置缓存的空闲和存活时间，以免存储过期或无用的数据。

springehcache配置的AOP的CACHE

SPRING AOP的EHCACHE最近根据网上的文章配置了一个面向应用的EHCACHE，发现使用起来很方便。

只要是继承了这个CACHE的配置，那么自动会拦截GET和FIND等方法来做CACHE下载ehcache包这些就不用说了。

ehcache.xml文件配置如下，这个不用做多少改动：<ehcache><diskStore path="c:\\temp\\cache"/><defaultCachemaxElementsInMemory="1000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"overflowToDisk="true"/><cache name="DEFAULT_CACHE"maxElementsInMemory="10000"eternal="false"timeToIdleSeconds="300000"timeToLiveSeconds="600000"overflowToDisk="true"/></ehcache> 需要做CACHE的servers这么配置，这是我的applicationContext-core-service.xml:<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd"><beans default-autowire="byName" default-lazy-init="true"><bean id="userManager" parent="baseTxService"><property name="target"><beanclass="erManagerImpl" /></property></bean></beans>拦截方法做cache的配置主要就在这个baseTxService上面，我把事务拦截也放在这里了,applicationContext-transaction.xml如下：<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd"><beans default-autowire="byName"><bean id="baseTxService"class="org.springframework.transaction.interceptor.TransactionProxyFa ctoryBean"abstract="true"><property name="transactionManager" ref="transactionManager" /><property name="proxyTargetClass" value="true" /><property name="transactionAttributes"><props><prop key="get*">PROPAGATION_REQUIRED,readOnly</prop><prop key="find*">PROPAGATION_REQUIRED,readOnly</prop><prop key="load*">PROPAGATION_REQUIRED,readOnly</prop><prop key="save*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="remove*">PROPAGATION_REQUIRED</prop></props></property><property name="preInterceptors"><list><ref bean="methodCachePointCut" /><ref bean="methodCachePointCutAdvice"/></list></property></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager " /></beans>这里面的两个拦截的bean,methodCachePointCut和methodCachePointCutAdvice专门放置到一个文件中配置，applicationContext-cache.xml如下：<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd"><beans><bean id="defaultCacheManager"class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"> <property name="configLocation"><value>classpath:ehcache.xml</value></property></bean><bean id="ehCache"class="org.springframework.cache.ehcache.EhCacheFactoryBean"><property name="cacheManager"><ref local="defaultCacheManager" /></property><property name="cacheName"><value>DEFAULT_CACHE</value></property></bean><bean id="methodCacheInterceptor"class="com.sillycat.plugin.cache.interceptors.MethodCacheInterceptor" ><property name="cache"><ref local="ehCache" /></property></bean><bean id="methodCacheAfterAdvice"class="com.sillycat.plugin.cache.interceptors.MethodCacheAfterAdvice" ><property name="cache"><ref local="ehCache" /></property></bean><bean id="methodCachePointCut"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice"><ref local="methodCacheInterceptor" /></property><property name="patterns"><list><value>.*find.*</value><value>.*get.*</value></list></property></bean><bean id="methodCachePointCutAdvice"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice"><ref local="methodCacheAfterAdvice" /></property><property name="patterns"><list><value>.*create.*</value><value>.*save.*</value><value>.*insert.*</value><value>.*update.*</value><value>.*delete.*</value><value>.*remove.*</value></list></property></bean></beans>如上所配置，只要继承了这个配置的service，里面的find get方法就会先走cache，另外，当发生create,save,insert,updatedelete,remove等方法时，就会去flush一下。

spring整合ehcache注解实现查询缓存，并实现实时缓存更新或删除

spring整合ehcache注解实现查询缓存，并实现实时缓存更新或删除写在前⾯：上⼀篇博客写了spring cache和ehcache的基本介绍，个⼈建议先把这些最基本的知识了解了才能对今天主题有所感触。

不多说了，开⼲！注：引⼊jar<dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId><version>2.8.3</version></dependency>第⼀步：⾸先配置ehcache.xml<?xml version="1.0" encoding="UTF-8"?><ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="ehcache.xsd"updateCheck="true" monitoring="autodetect"dynamicConfig="true"><diskStore path="java.io.tmpdir"/><defaultCachemaxEntriesLocalHeap="10000"eternal="false"overflowToDisk="false"timeToIdleSeconds="120"timeToLiveSeconds="120"diskSpoolBufferSizeMB="30"maxEntriesLocalDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></defaultCache><cache name="myCache"maxEntriesLocalHeap="10000"maxEntriesLocalDisk="1000"eternal="false"diskSpoolBufferSizeMB="30"timeToIdleSeconds="300"timeToLiveSeconds="600"memoryStoreEvictionPolicy="LFU"transactionalMode="off"><persistence strategy="localTempSwap"/></cache></ehcache>第⼆步：在spring.xml的配置⽂件中引⼊schema，缓存的配置：<cache:annotation-driven cache-manager="ehcacheManager"/><bean id="ehcacheManagerFactory" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"><property name="configLocation" value="classpath:ehcache.xml" /></bean><bean id="ehcacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager"><property name="cacheManager" ref="ehcacheManagerFactory" /></bean>OK!缓存的相关配置已经完成。

ehcache缓存配置

ehcache缓存配置# 在pom.xml中引⼊依赖<dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId><version>2.10.6</version></dependency># 在src/main/resources/创建⼀个配置⽂件 ehcache.xml默认情况下Ehcache会⾃动加载classpath根⽬录下名为ehcache.xml⽂件，也可以将该⽂件放到其他地⽅在使⽤时指定⽂件的位置。

<?xml version="1.0" encoding="UTF-8"?><ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="/ehcache.xsd"><diskStore path="java.io.tmpdir/ehcache"/><defaultCachemaxEntriesLocalHeap="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"maxEntriesLocalDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></defaultCache><cache name="HelloWorldCache"maxElementsInMemory="1000"eternal="false"timeToIdleSeconds="5"timeToLiveSeconds="5"overflowToDisk="false"memoryStoreEvictionPolicy="LRU"/></ehcache># 测试类public class CacheTest {public static void main(String[] args) throws IOException {// 1. 创建缓存管理器。

详解SpringMVC集成EHCache缓存

详解SpringMVC集成EHCache缓存废话少说，直接上代码：ehcache.xml ⽂件<?xml version="1.0" encoding="UTF-8"?><ehcache dynamicConfig="false" monitoring="off" updateCheck="false"xmlns:xsi="/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd"><!--1）maxElementsInMemory（正整数）：在内存中缓存的最⼤对象数量 2）maxElementsOnDisk（正整数）：在磁盘上缓存的最⼤对象数量，默认值为0，表⽰不限制。

Spring缓存注解@Cache使用

Spring缓存注解@Cache使⽤@Cacheable @Cacheable 的作⽤主要针对⽅法配置，能够根据⽅法的请求参数对其结果进⾏缓存@Cacheable 作⽤和配置⽅法参数解释examplevalue缓存的名称，在 spring 配置⽂件中定义，必须指定⾄少⼀个例如:@Cacheable(value=”mycache”)@Cacheable(value={”cache1”,”cache2”}key缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照⽅法的所有参数进⾏组合@Cacheable(value=”testcache”,key=”#userName”)condition缓存的条件，可以为空，使⽤ SpEL 编写，返回 true 或者 false，只有为 true 才进⾏缓存@Cacheable(value=”testcache”,condition=”#userName.length()>2”)实例 @Cacheable(value=”accountCache”)，这个注释的意思是，当调⽤这个⽅法的时候，会从⼀个名叫 accountCache 的缓存中查询，如果没有，则执⾏实际的⽅法（即查询），并将执⾏的结果存⼊缓存中，否则返回缓存中的对象。

这⾥的缓存中的 key 就是参数 userName，value 就是 Account 对象。

“accountCache”缓存是在spring*.xml 中定义的名称。

@Cacheable(value="accountCache")// 使⽤了⼀个缓存名叫 accountCachepublic Account getAccountByName(String userName) {// ⽅法内部实现不考虑缓存逻辑，直接实现业务System.out.println("real query account."+userName);return getFromDB(userName);}@CachePut@CachePut 的作⽤主要针对⽅法配置，能够根据⽅法的请求参数对其结果进⾏缓存，和 @Cacheable 不同的是，它每次都会触发真实⽅法的调⽤@CachePut 作⽤和配置⽅法参数解释examplevalue缓存的名称，在 spring 配置⽂件中定义，必须指定⾄少⼀个@CachePut(value=”my cache”)key缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照⽅法的所有参数进⾏组合@CachePut(value=”testcache”,key=”#userName”)condition缓存的条件，可以为空，使⽤ SpEL 编写，返回 true 或者 false，只有为 true 才进⾏缓存@CachePut(value=”testcache”,condition=”#userName.length()>2”)实例@CachePut 注释，这个注释可以确保⽅法被执⾏，同时⽅法的返回值也被记录到缓存中，实现缓存与数据库的同步更新。

springboot添加cache缓存，并添加自定义缓存配置

springboot添加cache缓存，并添加⾃定义缓存配置maven依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency><dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId></dependency>全局配置和具体实现启动类上⾯添加@EnableCaching 注解@SpringBootApplication@EnableCachingpublic class EpidemicApplication {public static void main(String[] args) {SpringApplication.run(EpidemicApplication.class, args);}}实现上⾯添加@Cacheable@Component@CacheConfig(cacheNames = "orgCode")public class OrgCodeDaoImpl implements OrgCodeDao {@Autowiredprivate OrgCodeRepository orgCodeRepository;@Cacheable(value = "orgCodeFindAll")@Overridepublic List<OrgCode> findAll() {return orgCodeRepository.findAll();}}实体类需要实现Serializablepublic class OrgCode implements Serializable {}⾃定义配置resource⽬录下添加ehcache.xml，或者在application.properties⽂件中添加配置⽂件路径spring.cache.ehcache.config=ehcache.xml具体配置⽂件内容：<ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="/ehcache.xsd"><diskStore path="java.io.tmpdir"/><defaultCachemaxElementsInMemory="50000"maxElementsOnDisk="100000"eternal="true"overflowToDisk="true"diskPersistent="false"timeToIdleSeconds="0"timeToLiveSeconds="0"diskSpoolBufferSizeMB="50"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LFU"/><cache name="orgCodeFindAll"maxElementsInMemory="1"maxElementsOnDisk="100000"eternal="false"overflowToDisk="true"diskPersistent="false"timeToIdleSeconds="0"timeToLiveSeconds="21600"diskSpoolBufferSizeMB="50"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="FIFO"/></ehcache>附录报错调试1.ng.IllegalArgumentException: Cannot find cache named '' for Builder[public java.util.List com.avivacofco.epidemic.hr.dao.impl.HrUserDaoImpl.findAll()] caches=[hrFindAll] | key='' | keyGenerator='' | cacheManager='' | cacheResolver='' | con 解决⽅案：在ehcache.xml中添加具体cache配置cache注解其中重要的是两个属性即 value 和 key，其中value必填，并且在ehcache.xml中进⾏配置，key可以为空，如为空，spring会使⽤默认策略⽣成key。

Spring缓存机制

Spring缓存机制Spring的缓存机制⾮常灵活，可以对容器中任意Bean或者Bean的⽅法进⾏缓存，因此这种缓存机制可以在JavaEE应⽤的任何层次上进⾏缓存。

Spring缓存底层也是需要借助其他缓存⼯具来实现，例如EhCache(Hibernate缓存⼯具），上层则以统⼀API编程。

要使⽤Spring缓存，需要以下三步1.向Spring配置⽂件导⼊context:命名空间2.在Spring配置⽂件启⽤缓存，具体是添加 <cache:annotation-driven cache-manager="缓存管理器ID" />3.配置缓存管理器，不同的缓存实现配置不同，如果是EhCache，需要先配置⼀个ehcache.xml例如1<?xml version="1.0" encoding="UTF-8"?>2<ehcache>3<diskStore path="java.io.tmpdir"/>45<defaultCache6maxElementsInMemory="10000"7 eternal="false"8 timeToIdleSeconds="120"9 timeToLiveSeconds="120"10 maxElementsOnDisk="10000000"11 diskExpiryThreadIntervalSeconds="120"12 memoryStoreEvictionPolicy="LRU"/>1314<cache name="users"15 maxElementsInMemory="10000"16 eternal="false"17 overflowToDisk="true"18 timeToIdleSeconds="300"19 timeToLiveSeconds="600"/>20</ehcache>上⾯的ehcache.xml配置了两个缓存区，Spring中的Bean将会缓存在这些缓存区中，⼀般的，Spring容器中有多少个Bean，就会在ehcache 中定义多少个缓存区。

详解springboot整合ehcache实现缓存机制

详解springboot整合ehcache实现缓存机制EhCache 是⼀个纯Java的进程内缓存框架，具有快速、精⼲等特点，是Hibernate中默认的CacheProvider。

ehcache提供了多种缓存策略，主要分为内存和磁盘两级，所以⽆需担⼼容量问题。

spring-boot是⼀个快速的集成框架，其设计⽬的是⽤来简化新Spring应⽤的初始搭建以及开发过程。

该框架使⽤了特定的⽅式来进⾏配置，从⽽使开发⼈员不再需要定义样板化的配置。

由于spring-boot⽆需任何样板化的配置⽂件，所以spring-boot集成⼀些其他框架时会有略微的不同。

1.spring-boot是⼀个通过maven管理的jar包的框架，集成ehcache需要的依赖如下<dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId></dependency><dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId><version>2.8.3</version></dependency>具体pom.xml⽂件如下<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.lclc.boot</groupId><artifactId>boot-cache</artifactId><version>0.0.1-SNAPSHOT</version><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.1.3.RELEASE</version></parent><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>17.0</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId></dependency><dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId><version>2.8.3</version></dependency></dependencies><dependencyManagement><dependencies></dependencies></dependencyManagement><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build><repositories><repository><id>spring-snapshots</id><url>http://repo.spring.io/snapshot</url><snapshots><enabled>true</enabled></snapshots></repository><repository><id>spring-milestones</id><url>http://repo.spring.io/milestone</url></repository></repositories><pluginRepositories><pluginRepository><id>spring-snapshots</id><url>http://repo.spring.io/snapshot</url></pluginRepository><pluginRepository><id>spring-milestones</id><url>http://repo.spring.io/milestone</url></pluginRepository></pluginRepositories></project>2.使⽤ehcache，我们需要⼀个ehcache.xml来定义⼀些cache的属性。

Spring使用Cache、整合Ehcache

从3.1开始，Sprin‎g引入了对‎C ache‎的支持。

其使用方法‎和原理都类‎似于Spr‎i ng对事‎务管理的支‎持。

Sprin‎g Cache‎是作用在方‎法上的，其核心思想‎是这样的：当我们在调‎用一个缓存‎方法时会把‎该方法参数‎和返回结果‎作为一个键‎值对存放在‎缓存中，等到下次利‎用同样的参‎数来调用该‎方法时将不‎再执行该方‎法，而是直接从‎缓存中获取‎结果进行返‎回。

所以在使用‎S prin‎g Cache‎的时候我们‎要保证我们‎缓存的方法‎对于相同的‎方法参数要‎有相同的返‎回结果。

使用Spr‎i ng Cache‎需要我们做‎两方面的事‎：⏹声明某些方‎法使用缓存‎⏹配置Spr‎i ng对C‎a che的‎支持和Spri‎n g对事务‎管理的支持‎一样，Sprin‎g对Cac‎h e的支持‎也有基于注‎解和基于X‎M L配置两‎种方式。

下面我们先‎来看看基于‎注解的方式‎。

1基于注解的‎支持Sprin‎g为我们提‎供了几个注‎解来支持S‎p ring‎Cache‎。

其核心主要‎是@Cache‎a ble和‎@Cache‎E vict‎。

使用@Cache‎a ble标‎记的方法在‎执行后Sp‎r ing Cache‎将缓存其返‎回结果，而使用@Cache‎E vict‎标记的方法‎会在方法执‎行前或者执‎行后移除S‎p ring‎Cache‎中的某些元‎素。

下面我们将‎来详细介绍‎一下Spr‎i ng基于‎注解对Ca‎c he的支‎持所提供的‎几个注解。

1.1 @Cache‎a ble@Cache‎a ble可‎以标记在一‎个方法上，也可以标记‎在一个类上‎。

当标记在一‎个方法上时‎表示该方法‎是支持缓存‎的，当标记在一‎个类上时则‎表示该类所‎有的方法都‎是支持缓存‎的。

对于一个支‎持缓存的方‎法，Sprin‎g会在其被‎调用后将其‎返回值缓存‎起来，以保证下次‎利用同样的‎参数来执行‎该方法时可‎以直接从缓‎存中获取结‎果，而不需要再‎次执行该方‎法。

配置Spring+hibernate使用ehcache作为second-levelcache

配置Spring+hibernate使用ehcache作为second-levelcache大量数据流动是web应用性能问题常见的原因，而缓存被广泛的用于优化数据库应用。

cache被设计为通过保存从数据库里load的数据来减少应用和数据库之间的数据流动。

数据库访问只有当检索的数据不在cache里可用时才必要。

hibernate可以用两种不同的对象缓存：first-level cache 和second-level cache。

first-level cache和Session对象关联，而second-level cache是和Session Factory对象关联。

缺省地，hibernate已经使用基于每个事务的first-level cache。

Hibernate用first-level cache主要是减少在一个事务内的sql查询数量。

例如，如果一个对象在同一个事务内被修改多次，hibernate 将只生成一个包括所有修改的UPDATE SQL语句。

为了减少数据流动，second-level cache在Session Factory级的不同事务之间保持load的对象，这些对象对整个应用可用，不只是对当前用户正在运行的查询。

这样，每次查询将返回已经load在缓存里的对象，避免一个或更多潜在的数据库事务。

下载ehcache，hibernate3.2必须要ehcache1.2以上才能支持。

可以修改log4j配置文件.sf.hibernate.cache=debug查看日志1.在类路径上ehcache.xml：<ehcache><diskStore path="java.io.tmpdir"/><defaultCachemaxElementsInMemory="10000"eternal="false"overflowToDisk="true"timeToIdleSeconds="120"timeToLiveSeconds="120"diskPersistent="false"diskExpiryThreadIntervalSeconds="120"/></ehcache>2.applicationContext-hibernate.xml里Hibernate SessionFactory配置：<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSes sionFactoryBean"><property name="dataSource" ref="dataSource"/><propertyname="configLocation"><value>classpath:hibernate .cfg.xml</value></property><property name="hibernateProperties"><props><prop key="hibernate.dialect">@HIBERNATE-DIALECT@</prop><propkey="hibernate.max_fetch_depth">3</prop> <propkey="e_outer_join">true</pro p><propkey="hibernate.jdbc.batch_size">10</prop><propkey="e_query_cache">true</pr op><propkey="e_second_level_cache">tr ue</prop><propkey="hibernate.cache.provider_class">org.hibern ate.cache.EhCacheProvider</prop> </props></property><property name="entityInterceptor"><ref local="auditLogInterceptor"/></property></bean>说明：如果不设置“查询缓存”，那么hibernate只会缓存使用load()方法获得的单个持久化对象，如果想缓存使用findall()、list()、Iterator()、createCriteria()、createQuery()等方法获得的数据结果集的话，就需要设置e_query_cache true 才行3.model类里采用Xdoclet生成*.hbm.xml里的cache xml标签，即<cache usage="read-only"/>/*** @hibernate.class table="WF_WORKITEM_HIS"* @hibernate.cache usage="read-write"**/4.对于"query cache"，需要在程序里编码：getHibernateTemplate().setCacheQueries(true);return getHibernateTemplate().find(hql);。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

2.4在工程中单独使用...................................................................... 错误！未定义书签。

3. 在SPRING中运用EHCACHE ....................................................... 错误！未定义书签。

4. 分布式缓存集群环境配置 (19)4.1集群配置方式 (19)5. 测试用例 (28)0. 文档介绍0.1 文档目的记录使用EHCache实现页面级的缓存以及完成集群设计的过程。

0.2 文档范围记录使用EHCache实现页面级的缓存以及完成集群设计的过程。

0.3 读者对象任何有兴趣的家伙。

Ehcache从Hibernate发展而来，逐渐涵盖了Cahce界的全部功能,是目前发展势头最好的一个项目。

具有快速,简单,低消耗，依赖性小，扩展性强,支持对象或序列化缓存，支持缓存或元素的失效，提供LRU、LFU和FIFO缓存策略，支持内存缓存和磁盘缓存，分布式缓存机制等等特点。

Cache 存储方式：内存或磁盘。

官方网站：/1.2 主要特性1. 快速.2. 简单.3. 多种缓存策略4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题5. 缓存数据会在虚拟机重启的过程中写入磁盘6. 可以通过RMI、可插入API等方式进行分布式缓存7. 具有缓存和缓存管理器的侦听接口8. 支持多缓存管理器实例，以及一个实例的多个缓存区域9. 提供Hibernate的缓存实现1.3 环境Windows XP、JDK1.6.03、Tomcat5.5、EHcache2.1注意：配置好环境变量。

1.4下载资源ehcache-2.1.0-distribution.tar.gz：以及ehcache-web-2.0.2-distribution.tar.gz/projects/ehcache/注意：同时要下载源代码，部分功能需要修改源代码，重新做包。

2. EHCache页面缓存的配置2.1 EHCache的类层次模型主要为三层，最上层的是CacheManager，他是操作Ehcache的入口。

我们可以通过CacheManager.getInstance()获得一个单子的CacheManger，或者通过CacheManger的构造函数创建一个新的CacheManger。

每个CacheManager都管理着多个Cache。

而每个Cache都以一种类Hash的方式，关联着多个Element。

Element则是我们用于存放要缓存内容的地方。

2.2 环境搭建将ehcache-2.1.0-distribution.tar.gz：以及ehcache-web-2.0.2-distribution.tar.gz解压得到需要将它们放置到WEB-INF/lib下。

有一个重要的配置文件ehcache.xml，可以从ehcache组件包中拷贝一个，也可以自己建立一个。

需要放到classpath下。

常放的路径为/WEB-INF/classes/ehcache.xml。

2.3 ehcache配置文件中元素说明ehcach.xml配置文件主要参数的解释,其实文件里有详细的英文注释//DiskStore 配置，cache文件的存放目录，主要的值有* user.home - 用户主目录* user.dir - 用户当前的工作目录* java.io.tmpdir - Default temp file path默认的temp文件目录范例1、首先设置EhCache，建立配置文件ehcache.XML，默认的位置在class- path，可以放到你的src目录下：＜?xml version="1.0" encoding="UTF-8"?＞＜ehcache＞＜diskStore path="Java.io.tmpdir"/＞＜defaultCachemaxElementsInMemory="10000" ＜!- 缓存最大数目-＞eternal="false" ＜!- 缓存是否持久-＞overflowToDisk="true" ＜!- 是否保存到磁盘，当系统当机时-＞timeToIdleSeconds="300" ＜!- 当缓存闲置n秒后销毁-＞timeToLiveSeconds="180" ＜!- 当缓存存活n秒后销毁-＞diskPersistent="false"diskExpiryThreadIntervalSeconds= "120"/＞＜/ehcache＞了解ehcache 的几个概念，1 timeToIdleSeconds ，多长时间不访问该缓存，那么ehcache 就会清除该缓存。

2 timeToLiveSeconds ，缓存的存活时间，从开始创建的时间算起。

Ehcache的三种清空策略1 FIFO，first in first out，这个是大家最熟的，先进先出。

2 LFU，Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。

如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。

3 LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

首页的页面缓存一个网站的首页估计是被访问的次数最多的，我们可以考虑给首页做一个页面缓存缓存策略：我认为应该是某个固定时间之内不变的，比如说2分钟更新一次，以应用结构page-filter-action-service-dao-db 为例。

位置：页面缓存做到尽量靠近客户的地方，就是在page和filter之间，这样的优点就是第一个用户请求之后，页面被缓存，第二个用户再来请求的时候，走到filter这个请求就结束了，无需再走后面的action- service-dao-db。

带来的好处是服务器压力的减低和客户段页面响应速度的加快。

首页的页面缓存的存活时间，我们定的是2 分钟，那么也就是说我们的timeToLiveSeconds 应该设置为120 ，同时我们的timeToIdleSeconds 最好也设置为2 分钟，或者小于2 分钟。

我们来看一下下面这个配置，这个配置片段应该放到ehcache.xml 中：SimplePageCachingFilter 是缓存的名字，maxElementsInMemory 表示内存中SimplePageCachingFilter 缓存中元素的最大数量为10，maxElementsOnDisk 是指持久化该缓存的元素到硬盘上的最大数量也为10 （），eternal=false 意味着该缓存会死亡。

overflowToDisk=true 意思是表示当缓存中元素的数量超过限制时，就把这些元素持久化到硬盘，如果overflowToDisk 是false ，那么maxElementsOnDisk 的设置就没有什么意义了。

memoryStoreEvictionPolicy=LFU 是指按照缓存的hit 值来清除，也就是说缓存满了之后，新的对象需要缓存时，将会将缓存中hit 值最小的对象清除出缓存，给新的对象腾出地方来了。

接着我们来看一下SimplePageCachingFilter的配置，XML/HTML代码<filter><filter-name>indexCacheFilterfilter-name><filter-class>net.sf.ehcache.constructs.web.filter.SimplePageCachingFilter<filter-class><filter><filter-mapping><filter-name>indexCacheFilterfilter-name><url-pattern>*index.actionurl-pattern><filter-mapping>就只需要这么多步骤，我们就可以给某个页面做一个缓存的，把上面这段配置放到你的web.xml中，那么当你打开首页的时候，你会发现，2分钟才会有一堆sql语句出现在控制台上。

当然你也可以调成5分钟，总之一切都在控制中。

好了，缓存整个页面看上去是非常的简单，甚至都不需要写一行代码，只需要几行配置就行了，够简单吧，虽然看上去简单，但是事实上内部实现却不简单哦，有兴趣的话，大家可以看看SimplePageCachingFilter继承体系的源代码。

上面的配置针对的情况是缓存首页的全部，如果你只想缓存首页的部分内容时，你需要使用SimplePageFragmentCachingFilter这个filter。

我们看一下如下片断：XML/HTML代码<filter><filter-name>indexCacheFilterfilter-name><filter-class>net.sf.ehcache.constructs.web.filter.SimplePageFragmentCachingFilter <filter-class>filter><filter-mapping><filter-name>indexCacheFilterfilter-name><url-pattern>*/index_right.jspurl-pattern><filter-mapping>这个jsp需要被jsp:include到其他页面，这样就做到的局部页面的缓存。