Ehcache中文指南和实例教程

合集下载

java中ehcache的使用实例

java中ehcache的使用实例使用Ehcache的实例可以如下所示：首先，你需要添加Ehcache的依赖项。

可以在`pom.xml`文件中添加以下依赖项：xml<dependency><groupId>org.ehcache</groupId><artifactId>ehcache</artifactId><version>3.8.1</version></dependency>然后，你需要在代码中创建Ehcache实例，并设置一些配置信息。

可以使用如下代码：javaimport org.ehcache.Cache;import org.ehcache.CacheManager;import org.ehcache.config.CacheConfiguration;import org.ehcache.config.Configuration;import org.ehcache.config.builders.CacheConfigurationBuilder; import org.ehcache.config.builders.CacheManagerBuilder; import org.ehcache.config.builders.ResourcePoolsBuilder; import org.ehcache.config.units.EntryUnit;import org.ehcache.config.units.MemoryUnit;public class EhcacheExample {public static void main(String[] args) {创建Ehcache配置CacheConfiguration<Long, String> cacheConfiguration = CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100, EntryUnit.ENTRIES).offheap(1, MemoryUnit.MB)).build();创建Ehcache管理器CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().withCache("myCache", cacheConfiguration).build();cacheManager.init();获取缓存Cache<Long, String> cache =cacheManager.getCache("myCache", Long.class, String.class);在缓存中存储数据cache.put(1L, "Hello");从缓存中获取数据String value = cache.get(1L);System.out.println(value);关闭缓存管理器cacheManager.close();}}在上面的示例中，我们使用Ehcache创建了一个缓存管理器和一个名为`myCache`的缓存。

ehcache缓存配置详解

一、设置diskstore，对所有的<cache/>和<defaultCache/>有效<!--设置缓存文件 .data 的创建路径。

如果该路径是 Java 系统参数，当前虚拟机会重新赋值，即获取该系统参数所代表的值。

下面的系统参数这样解释：user.home –用户主目录user.dir –用户当前工作目录 java.io.tmpdir--><diskStore path="java.io.tmpdir" />二、defaultCache ：默认的管理策略，其配置用于被其它cache继承，包括被在代码中创建的cache继承。

三、缓存区使用<cache/>标签进行配置，主要属性以及意义如下：(1)name（必填属性）：缓存区名称，用以区别缓存区，必须唯一。

(2)maxEntriesLocalHeap（必填属性）：设置缓存在本地内存中最大（等效于旧版本中的maxElementsInMemory 缓存项数量（0表示无限）。

属性）。

在实际使用中，在非分布式部署条件下，无限等效于Integer.MAX_SIZE(2147483647)。

在分布式部署条件下，缓存项数量由Terracotta Server Array资源上限决定。

(3)maxEntriesLocalDisk（必填属性）：设置保存在本地磁盘中的的最大缓存项数量。

默认为0，表示数量不限。

(4)eternal（必填属性）：设置缓存项是否为永久的。

如果设置为true，缓存项的过期设置将被忽略，缓存项永不过期。

(5)overflowToOffHeap：此属性仅在使用Ehcache企业版时有效。

设置为true，缓存将使用非堆内存，非堆内存并非由Java管理，与Java 垃圾回收无关。

默认为false。

(6)maxBytesLocalHeap：定义保存在Java虚拟机堆内存中的缓存项的最大字节数。

EhCache用户指南(分布式缓存)

分布式缓存原文地址为/documentation/distributed_caching.html译者：中华风筝联系方式：kite.china@（也是GTalk帐号）从1.2版本开始，Ehcache可以使用分布式的缓存了。

分布式这个特性是以plugin的方式实现的。

Ehcache自带了一些默认的分布式缓存插件实现，这些插件可以满足大部分应用的需要。

如果需要使用其他的插件那就需要自己开发了，开发者可以通过查看distribution包里的源代码及JavaDoc来实现它。

尽管不是必须的，在使用分布式缓存时理解一些ehcahce的设计思想也是有帮助的。

这可以参看分布式缓存设计的页面。

以下的部分将展示如何让分布式插件同ehcache一起工作。

下面列出的是一些分布式缓存中比较重要的方面：z你如何知道集群环境中的其他缓存？z分布式传送的消息是什么形式？z什么情况需要进行复制？增加（Puts），更新（Updates）或是失效（Expiries）？z采用什么方式进行复制？同步还是异步方式？为了安装分布式缓存，你需要配置一个PeerProvider、一个CacheManagerPeerListener，它们对于一个CacheManager来说是全局的。

每个进行分布式操作的cache都要添加一个cacheEventListener来传送消息。

正确的元素类型只有可序列化的元素可以进行复制。

一些操作，比如移除，只需要元素的键值而不用整个元素；在这样的操作中即使元素不是可序列化的但键值是可序列化的也可以被复制，成员发现（Peer Discovery）Ehcache进行集群的时候有一个cache组的概念。

每个cache都是其他cache的一个peer，没有主cache的存在。

刚才我们问了一个问题：你如何知道集群环境中的其他缓存？这个问题可以命名为成员发现（Peer Discovery）。

Ehcache提供了两种机制用来进行成员发现，就像一辆汽车：手动档和自动档。

EHCache单独使用

EHCache单独使用参考：1. EHCache 的特点，是一个纯Java ,过程中（也可以理解成插入式）缓存实现，单独安装Ehcache ，需把ehcache-X.X.jar 和相关类库方到classpath中。

如项目已安装了Hibernate ,则不需要做什么。

直接可以使用EhcacheCache 存储方式：内存或磁盘2. 单独使用 EHCache使用CacheManager 创建并管理Cache1.创建CacheManager有4种方式：A:使用默认配置文件创建Java代码B:使用指定配置文件创建Java代码C:从classpath中找寻配置文件并创建Java代码D:通过输入流创建Java代码卸载CacheManager ,关闭CacheJava代码使用Caches取得配置文件中预先定义的sampleCache1设置,通过CacheManager生成一个CacheJava代码设置一个名为test 的新cache,test属性为默认Java代码设置一个名为test 的新cache,并定义其属性Java代码往cache中加入元素Java代码从cache中取得元素Java代码所以大概步骤为：第一步：生成CacheManager对象第二步：生成Cache对象第三步：向Cache对象里添加由key,value组成的键值对的Element元素具体一个Test.java程序：Java代码3. 在 Hibernate 中运用EHCachehibernate.cfg.xml中需设置如下：2.1版本加入Java代码2.1以下版本加入Java代码在 Hibernate 映射文件的每个需要Cache的Domain中Java代码加入类似如下格式信息：Java代码比如：Java代码具体如下：Java代码然后在ehcache.xml中加入Java代码。

EhCache使用说明

第一章EHCACHE环境 (1)1.库文件增加 (1)2.基础配置文件增加 (1)第二章S PING中使用EHCACHE (2)1.定义EHCACHE管理 (2)2.定义EHCACHE工厂 (2)3.设置EHCACHE缓存 (3)4.使用S PING AOP通知执行设置C ACHE (4)5.清除EHCACHE缓存 (4)6.使用S PING AOP通知执行清除C ACHE (5)7.完整的配置文件 (6)第三章I BATIS中使用EHCACHE (7)1.配置CACHE M ODEL (7)2.调用CACHE M ODEL (8)3.在EHCACHE.XML增加CACHE (8)4.程序中更新缓存 (8)5.编写自定义类型E H C ACHE C ONTROLLER (9)第四章S HIRO中使用EHCACHE (10)1.S HIRO中使用SPRING的EHCACHE (10)第五章E HCACHE分布式发布 (11)1.配置C ACHE R EPLICATORS (11)2.配置C ACHE M ANAGER P EER L ISTENER监听 (11)3.成员发现机制 (12)第一章ehcache环境1.库文件增加在pom.xml文件中增加：<dependency><groupId><artifactId>ehcache</artifactId><version></dependency>2.基础配置文件增加在/#proName/cache目录中建立一个 ehcache.xml 文件：<?xml version="1.0" encoding="UTF-8"?><ehcache xmlns:xsi="/XMLSchema-instance"xsi:noNamespaceSchemaLocation=""updateCheck="false"><diskStore path="" /><defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"overflowToDisk="false"maxElementsOnDisk=""diskPersistent="false"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"/><cachename="DEFAULT_CACHE"maxElementsInMemory="10000"maxElementsOnDisk="1000"eternal="false"overflowToDisk="false"diskSpoolBufferSizeMB="20"timeToIdleSeconds="300"timeToLiveSeconds="600"memoryStoreEvictionPolicy="LFU" ></cache></ehcache>参数说明：-name：Cache的唯一标识maxElementsInMemory：内存中最大缓存对象数maxElementsOnDisk：磁盘中最大缓存对象数，若是0表示无穷大eternal：Element是否永久有效，一但设置了，timeout将不起作用overflowToDisk：配置此属性，当内存中Element数量达到maxElementsInMemory 时，Ehcache将会Element写到磁盘中timeToIdleSeconds：设置Element在失效前的允许闲置时间。

ehcache使用文档

Ehcache使用文档作者：sunyf2013年11月1 基本介绍1.1前言Ehcache是一个快速的、轻量级的、易于使用的、进程内的缓存。

它支持read-only 和read/write 缓存，内存和磁盘缓存。

是一个非常轻量级的缓存实现，而且从1.2 之后就支持了集群，目前的最新版本是2.5。

简单地说来，ehcache有以下特点：●快速.●简单.●多种缓存策略●缓存数据有两级：内存和磁盘，因此无需担心容量问题●缓存数据会在虚拟机重启的过程中写入磁盘●可以通过RMI、可插入API 等方式进行分布式缓存●具有缓存和缓存管理器的侦听接口●支持多缓存管理器实例，以及一个实例的多个缓存区域●提供Hibernate 的缓存实现2 安装和使用2.1下载Ehcache的官方网站/downloads/catalog 上面可以下载到各种版本。

目前用最新版本是2.5.1，下载这个版本即可。

（下载之前，会要求用户注册，按照要求输入即可）。

建议下载ehcache-2.5.1-distribution.tar.gz文件，因为这个文件包含了所有Ehcache的内容。

2.2安装2.2.1 发布包内容说明将ehcache-2.5.1-distribution.tar.gz解压到本地文件系统。

在安装之前，我们先来大致看看发布包里边的内容，如下图2.1所示。

图2.1如一般的开源框架发布包类似，ehcahce的发布包包含以下目录内容：javadoc：ehcache的API文档；lib：ehcache要用到的第三方jar包和自己的jar包；licenses：ehcache的授权文件；samples：ehcache的例子目录；src：ehcache的源代码目录；terracotta：使用terracotta集群时的terracotta服务；ehcache.xml：ehcache的配置文件模板，包括各个配置的英文解释；ehcache.xsd：ehcache.xml文件的验证文件模板；QUICK-START.html：快速开始文件，会连接到ehcache的官方网站；README.html：ehcache版本功能和新特性说明文件。

ehcache说明文档

一、简介非常简单，而且易用。

ehcache 是一个非常轻量级的缓存实现，而且从1.2 之后就支持了集群，而且是hibernate 默认的缓存provider 。

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。

Ehcache可以直接使用。

也可以和Hibernate对象/关系框架结合使用。

还可以做Servlet缓存。

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

官方网站：/主要特性1. 快速.2. 简单.3. 多种缓存策略4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题5. 缓存数据会在虚拟机重启的过程中写入磁盘6. 可以通过RMI、可插入API等方式进行分布式缓存7. 具有缓存和缓存管理器的侦听接口8. 支持多缓存管理器实例，以及一个实例的多个缓存区域9. 提供Hibernate的缓存实现10. 等等二、快速上手1、项目类库中添加ehcache.jar；2、在类路径下编写ehcache.xml配置文件。

三、配置文件参数详解ehcache.xml是ehcache的配置文件，并且存放在应用的classpath中。

下面是对该XML文件中的一些元素及其属性的相关说明：<diskStore>元素：指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下。

下面的参数这样解释：user.home –用户主目录user.dir –用户当前工作目录java.io.tmpdir –默认临时文件路径<defaultCache>元素：设定缓存的默认数据过期策略。

<cache>元素：设定具体的命名缓存的数据过期策略。

<cache>元素的属性name：缓存名称。

通常为缓存对象的类名（非严格标准）。

maxElementsInMemory：设置基于内存的缓存可存放对象的最大数目。

maxElementsOnDisk：设置基于硬盘的缓存可存放对象的最大数目。

shiro-ehcache使用流程

shiro-ehcache使用流程
Shiro和Ehcache集成使用流程主要包括以下几个步骤：
1. 添加依赖：需要在项目的`pom.xml`文件中引入必要的依赖，这包括Spring Boot的缓存启动器、Ehcache以及Shiro的Ehcache 集成。

2. 创建配置文件：在`resources`目录下创建`ehcache.xml`配置文件，定义缓存策略和参数。

配置中会设置缓存名称、最大元素数量、是否永久有效、存活时间等重要属性。

3. 实现Spring与Ehcache缓存集成：创建Spring的Ehcache 配置文件（如`spring-ehcache.xml`），在其中配置`CacheManager`以供Shiro使用。

4. 安全管理器配置：在`SecurityManager`安全管理器中设置缓存管理器，开启Shiro的授权或认证数据缓存。

这通常涉及到自定义`WebSecurityManager`，并将其中的`CacheManager`替换为Ehcache的`CacheManager`。

5. 启用缓存：通过以上配置，Shiro在进行认证和授权时将使用Ehcache提供的缓存机制，减少了对后端存储的频繁访问。

6. 测试验证：最后进行测试以验证缓存是否生效，比如检查用户登录后，再次请求是否能够从缓存中获取到用户信息而无需重新认证。

在整个流程中，需要特别注意配置文件中的各个参数设置，这些参数决定了缓存的行为和性能。

此外，还需要确保在应用程序的其他部分中正确使用了Shiro框架，以便充分发挥集成Ehcache的优势。

EhCache使用详细介绍（转）

EhCache使用详细介绍（转）Ehcache中不仅可以用配置文件来配置缓存，而在代码中也可以实现同样的功能。

CacheManager singletonManager = CacheManager.create();Cache memoryOnlyCache = new Cache(“testCache”, 50000, false, false, 8, 2);Cache test = singletonManager.getCache(“testCache”);删除只需要调用singletonManager.removeCache(“testCache”);Shotdown CacheManager在使用完Ehcache后，必须要shutdown缓存。

Ehcache中有自己的关闭机制，不过最好在你的代码中显示调用CacheManager.getInstance().shutdown();1.EhCache是什么EhCache是Hibernate的二级缓存技术之一，可以把查询出来的数据存储在内存或者磁盘，节省下次同样查询语句再次查询数据库，大幅减轻数据库压力；2.EhCache的使用注意点当用Hibernate的方式修改表数据(save,update,delete等等)，这时EhCache会自动把缓存中关于此表的所有缓存全部删除掉(这样能达到同步)。

但对于数据经常修改的表来说，可能就失去缓存的意义了(不能减轻数据库压力)；3.EhCache使用的场合3.1比较少更新表数据EhCache一般要使用在比较少执行write操作的表(包括update,insert,delete等)[Hibernate的二级缓存也都是这样]；3.2对并发要求不是很严格的情况两台机子中的缓存是不能实时同步的；4.在项目做的实现4.1在工程的src目录下添加ehcache.xml文件，内容如下：<?xml version="1.0" encoding="UTF-8"?><ehcache><diskStore path="java.io.tmpdir" /><defaultCache maxElementsInMemory="5"eternal="false"overflowToDisk="true"timeToIdleSeconds="15"timeToLiveSeconds="120"/></ehcache>4.2在Hibernate.cfg.xml中的mapping标签上面加以下内容：<property name="show_sql">true</property><propertyname="hibernate.cache.provider_class">org.hibernate.cache.Eh CacheProvider</property><propertyname="e_query_cache">true</property>4.3在要缓存的bean的hbm.xml文件中的class标签下加入以下内容：<cache usage="read-only" />4.4创建DAO，内容如下：Session s = HibernateSessionFactory.getSession();Criteria c = s.createCriteria(Xyz.class);c.setCacheable(true);//这句必须要有System.out.println("第一次读取");List l = c.list();System.out.println(l.size());HibernateSessionFactory.closeSession();s = HibernateSessionFactory.getSession();c = s.createCriteria(Xyz.class);c.setCacheable(true);//这句必须要有System.out.println("第二次读取");l = c.list();System.out.println(l.size());HibernateSessionFactory.closeSession();4.5这时你会看到打印出来的信息为（表示第二次并没有去读库）：第一次读取Hibernate: *******13第二次读取13配置Spring+hibernate使用ehcache作为second-level cache 大量数据流动是web应用性能问题常见的原因，而缓存被广泛的用于优化数据库应用。

ehcache.xml配置详解

ehcache.xml配置详解⼀：配置⽂件案例1 <ehcache>234 8 <diskStore path="java.io.tmpdir" />91011 19 <defaultCache maxElementsInMemory="10000" eternal="false"20 timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true" />2122 26 <cache name="com.zbaccp.entity.Person" maxElementsInMemory="10000" eternal="false"27 timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true" />282930 </ehcache>⼆：属性详解1、diskStore ：指定数据(.data and .index)存储位置，可指定磁盘中的⽂件夹位置期 The diskStore element is optional. It must be configured if you have overflowToDisk or diskPersistent enabled for any cache. If it is not configured, a warning will be issues and java.io.tmpdir will be used.２、defaultCache ：默认的管理策略⼀、以下属性是必须的： 1、name： Cache的名称，必须是唯⼀的(ehcache会把这个cache放到HashMap⾥)。

EHcache

Ehcache 整合Spring 使用页面、对象缓存Ehcache在很多项目中都出现过，用法也比较简单。

一般的加些配置就可以了，而且Ehcache可以对页面、对象、数据进行缓存，同时支持集群/分布式缓存。

如果整合Spring、Hibernate也非常的简单，Spring对Ehcache的支持也非常好。

EHCache支持内存和磁盘的缓存，支持LRU、LFU和FIFO多种淘汰算法，支持分布式的 Cache，可以作为Hibernate的缓存插件。

同时它也能提供基于Filter的Cache，该Filter可以缓存响应的内容并采用Gzip压缩提高响应速度。

一、准备工作如果你的系统中已经成功加入Spring、Hibernate；那么你就可以进入下面Ehcache的准备工作。

1、下载jar包Ehcache 对象、数据缓存：/downloads/destination?name=ehcache-core-2.5.2-distribution.tar.gz&bucket=tcdistributions&file=ehcache-core-2.5.2-distribution.tar.gzWeb页面缓存：/downloads/destination?name=ehcache-web-2.0.4-distribution.tar.gz&bucket=tcdistributions&file=ehcache-web-2.0.4-distribution.tar.gz2、需要添加如下jar包到lib目录下ehcache-core-2.5.2.jarehcache-web-2.0.4.jar 主要针对页面缓存3、当前工程的src目录中加入配置文件ehcache.xmlehcache.xsd这些配置文件在ehcache-core这个jar包中可以找到二、Ehcache基本用法CacheManager cacheManager = CacheManager.create();// 或者cacheManager = CacheManager.getInstance();// 或者cacheManager = CacheManager.create("/config/ehcache.xml");// 或者cacheManager = CacheManager.create("http://localhost:8080/test/ehcache.xml"); cacheManager = CacheManager.newInstance("/config/ehcache.xml");// .......// 获取ehcache配置文件中的一个cacheCache sample = cacheManager.getCache("sample");// 获取页面缓存BlockingCache cache = newBlockingCache(cacheManager.getEhcache("SimplePageCachingFilter"));// 添加数据到缓存中Element element = new Element("key", "val");sample.put(element);// 获取缓存中的对象，注意添加到cache中对象要序列化实现Serializable接口Element result = sample.get("key");// 删除缓存sample.remove("key");sample.removeAll();// 获取缓存管理器中的缓存配置名称for (String cacheName : cacheManager.getCacheNames()) {System.out.println(cacheName);}// 获取所有的缓存对象for (Object key : cache.getKeys()) {System.out.println(key);}// 得到缓存中的对象数cache.getSize();// 得到缓存对象占用内存的大小cache.getMemoryStoreSize();// 得到缓存读取的命中次数cache.getStatistics().getCacheHits();// 得到缓存读取的错失次数cache.getStatistics().getCacheMisses();三、页面缓存页面缓存主要用Filter过滤器对请求的url进行过滤，如果该url在缓存中出现。

EHCache技术文档

EHCache技术⽂档⽬录0. ⽂档介绍 (2)0.1 ⽂档⽬的 (2)0.2 ⽂档范围 (2)0.3 读者对象 (2)0.4 参考⽂献 (2)0.5 术语与缩写解释 (2)1. 概述 (3)1.1背景 (3)1.2 主要特征 (3)1.3环境 (5)1.4下载资源 (5)2. EHCache页⾯缓存的配置 (5)2.1 EHCache的类层次模型 (5)2.2环境搭建 (6)2.3 ehcache配置⽂件中元素说明 (8)2.4 在⼯程中单独使⽤ (10)3. 在Spring中运⽤EHCache. 174. 分布式缓存集群环境配置 (19)4.1 集群配置⽅式 (19)5. 测试⽤例 (28)0. ⽂档介绍0.1 ⽂档⽬的记录使⽤EHCache实现页⾯级的缓存以及完成集群设计的过程。

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

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

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

EHCache简介：Spring整合EHCache：0.5 术语与缩写解释缩写、术语解释EHCache EHCache是⼀个快速的、轻量级的、易于使⽤的、进程内的缓存。

它⽀持read-only和read/write缓存，内存和磁盘缓存。

是⼀个⾮常轻量级的缓存实现，⽽且从1.2 之后就⽀持了集群，⽬前的最新版本是2.1。

…1. 概述1.1背景系统缓存是位于应⽤程序与物理数据源之间，⽤于临时存放复制数据的内存区域，⽬的是为了减少应⽤程序对物理数据源访问的次数，从⽽提⾼应⽤程序的运⾏性能. 缓存设想内存是有限的，缓存的时效性也是有限的，所以可以设定内存数量的⼤⼩，可以执⾏失效算法，可以在内存满了的时候，按照最少访问等算法将缓存直接移除或切换到硬盘上。

springbootehcache配置使用方法代码详解

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

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

下⾯通过本⽂给⼤家介绍springboot ehcache 配置使⽤⽅法，具体内容如下所⽰：1. pom 引⼊依赖<dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache</artifactId></dependency>2.resources ⽬录下直接放个⽂件ehcache.xml<ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="/ehcache.xsd"updateCheck="false"><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="menucache"maxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"maxElementsOnDisk="10000000"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"><persistence strategy="localTempSwap"/></cache></ehcache>3.在Service层⽅法上加上注解@CacheEvict(value="menucache", allEntries=true) ，更新缓存@Cacheable(key="'menu-'+#parentId",value="menucache") 读取缓存，"'menu-'+#parentId" 通配符，也可以直接写死字符串menucache 对应上⾯ xmlname="menucache"/**删除菜单* @param MENU_ID* @*/@CacheEvict(value="menucache", allEntries=true)public void deleteMenuById(String MENU_ID) throws Exception{this.cleanRedis();menuMapper.deleteMenuById(MENU_ID);}/*** 通过ID获取其⼦⼀级菜单* @param parentId* @return* @*/@Cacheable(key="'menu-'+#parentId",value="menucache")public List<Menu> listSubMenuByParentId(String parentId) throws Exception {return menuMapper.listSubMenuByParentId(parentId);}到此这篇关于springboot ehcache 配置使⽤⽅法代码详解的⽂章就介绍到这了,更多相关springboot ehcache 配置使⽤内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

Ehcache缓存配置以及基本使用

Ehcache缓存配置以及基本使⽤在java项⽬⼴泛的使⽤。

它是⼀个开源的、设计于提⾼在数据从RDBMS中取出来的⾼花费、⾼延迟采取的⼀种缓存⽅案。

正因为Ehcache 具有健壮性（基于java开发）、被认证（具有apache 2.0 license）、充满特⾊（稍后会详细介绍），所以被⽤于⼤型复杂分布式web application的各个节点中。

够快Ehcache的发⾏有⼀段时长了，经过⼏年的努⼒和不计其数的性能测试，Ehcache终被设计于large, high concurrency systems.够简单开发者提供的接⼝⾮常简单明了，从Ehcache的搭建到运⽤运⾏仅仅需要的是你宝贵的⼏分钟。

其实很多开发者都不知道⾃⼰⽤在⽤Ehcache，Ehcache被⼴泛的运⽤于其他的开源项⽬⽐如：hibernate够袖珍关于这点的特性，官⽅给了⼀个很可爱的名字small foot print ，⼀般Ehcache的发布版本不会到2M，V 2.2.3 才 668KB。

够轻量核⼼程序仅仅依赖slf4j这⼀个包，没有之⼀！好扩展Ehcache提供了对⼤数据的内存和硬盘的存储，最近版本允许多实例、保存对象⾼灵活性、提供LRU、LFU、FIFO淘汰算法，基础属性⽀持热配置、⽀持的插件多监听器缓存管理器监听器（CacheManagerListener）和缓存监听器（CacheEvenListener）,做⼀些统计或数据⼀致性⼴播挺好⽤的如何使⽤？POM⽂件<dependency><groupId>net.sf.ehcache</groupId><artifactId>ehcache-core</artifactId><version>2.6.6</version></dependency>配置⽂件在resources资源⽬录下创建⼀个ehcache-config.xml⽂件，内容如下:<?xml version="1.0" encoding="UTF-8"?><ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="/ehcache.xsd"updateCheck="false"><diskStore path="java.io.tmpdir/ehcache" /><defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"overflowToDisk="true"maxElementsOnDisk="10000000"diskPersistent="false"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="FIFO" /><cache name="cache_mall_keys"maxElementsInMemory="200"eternal="false"timeToIdleSeconds="7200"timeToLiveSeconds="7200"overflowToDisk="true"maxElementsOnDisk="1000"diskPersistent="false"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="FIFO" /><cache name="cache_pos_codes"maxElementsInMemory="200"eternal="false"timeToIdleSeconds="43200"timeToLiveSeconds="43200"overflowToDisk="true"maxElementsOnDisk="1000"diskPersistent="false"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="FIFO" /></ehcache>Spirng整合配置注意⼀下内容必须注册在Spring的主配置⽂件中<cache:annotation-driven cache-manager="cacheManager"/><bean id="cacheManagerFactory" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"><property name="configLocation" value="classpath:ehcache-config.xml"></property></bean><bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager"><property name="cacheManager" ref="cacheManagerFactory"></property></bean>使⽤⽅法这⾥可以使⽤注解的⽅式 @Cacheable(value = "cache_pos_codes") 其中value的是设置的配置⽂件ehcache-config.xml的配置名称。

EHCache

关于ehcache 配置欠了很久的文章，本来都不想发了，可还是发吧ehcache的默认配置文件名为ehcache.xml，也可以自己指定。

配置文件比较的简单，基本上也就是常用的几个元素。

配置元素说明：diskStore：配置DiskStore，当需要使用磁盘保存的时候，需要对象实现序列化接口属性：path 配置文件存储位置，如user.home，user.dir，java.io.tmpdircacheManagerEventListenerFactory ：指定CacheManagerEventListenerFactory，用于创建CacheManagerPeerProvider用于提醒当CacheManager中的缓存增加或者删除时。

属性:class:完整的工厂类名称properties:逗号分割的属性事件包括增加cache和删除cachecacheManagerPeerProviderFactory:指定CacheManagerPeerProviderFactory，用于创建CacheManagerPeerProvider，用于在cluster中查找CacheManagers，主要用于机群环境属性：class:完整的工厂类名称properties:逗号分割的属性默认的配置：<cacheManagerPeerProviderFactoryclass="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFa ctory"properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1,multicastGroupPort=4446, timeToLive=32"/><cacheManagerPeerProviderFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"properties="peerDiscovery=manual,rmiUrls=//server1:40000/sampleCache1|//server2:40000/sampleCache 1|//server1:40000/sampleCache2|//server2:40000/sampleCache2"/>cacheManagerPeerListenerFactory：指定CacheManagerPeerListenerFactory，用于创建CacheManagerPeerListener，监听cluster中的复制信息属性：class:完整的工厂类名称properties:逗号分割的属性默认配置<cacheManagerPeerListenerFactoryclass="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"properties="hostName=fully_qualified_hostname_or_ip,port=40001,socketTimeoutMillis=120000"/>defaultCache: 默认缓存配置必须属性：name:设置缓存的名称，用于标志缓存,惟一maxElementsInMemory:在内存中最大的对象数量maxElementsOnDisk：在DiskStore中的最大对象数量，如为0，则没有限制eternal：设置元素是否永久的，如果为永久，则timeout忽略overflowToDisk：是否当memory中的数量达到限制后，保存到Disk可选的属性：timeToIdleSeconds：设置元素过期前的空闲时间timeToLiveSeconds：设置元素过期前的活动时间diskPersistent：是否disk store在虚拟机启动时持久化。

ehchashe 使用方法

ehchashe 使用方法（原创实用版4篇）篇1 目录1.ehchashe 简介2.ehchashe 使用方法3.使用注意事项4.结论篇1正文ehchashe（发音为“Eh-chashe”）是一种用于缓解焦虑和压力的自然疗法。

它起源于古老的印度传统医学阿育吠陀，现在作为一种替代疗法在全世界范围内受到越来越多的关注。

本文将为您介绍 ehchashe 的使用方法。

1.ehchashe 简介Ehchashe 是一种独特的自然疗法，通过刺激人体的能量系统来帮助缓解焦虑和压力。

它主要通过按摩头部、颈部和肩部的特定穴位来实现这一目的。

Ehchashe 的名字来源于两个梵文单词：“eh”表示能量，“chashe”表示释放。

因此，ehchashe 的含义就是释放能量。

2.ehchashe 使用方法要使用 ehchashe，您需要遵循以下步骤：（1）准备工作：找一个安静、舒适的地方，确保在处理过程中不会受到干扰。

此外，准备一些舒缓的音乐，可以帮助您更好地放松。

（2）按摩头部：用手指轻轻按摩头部的穴位，尤其是眉毛上方、头顶和后脑勺的部位。

按摩时要注意不要用力过猛，以免造成不必要的疼痛。

（3）按摩颈部和肩部：用同样的方法按摩颈部和肩部的穴位。

这些部位有很多重要的能量通道，通过按摩可以有效地缓解压力和焦虑。

（4）深呼吸：在整个过程中，保持深呼吸，以帮助您更好地放松。

深呼吸可以提高氧气供应，有助于身体释放紧张情绪。

（5）冥想：在按摩和深呼吸之后，进行一些简单的冥想，可以帮助您更好地体验到 ehchashe 的效果。

可以选择一个舒适的坐姿，然后集中注意力在呼吸上，让思绪自然地流淌。

3.使用注意事项在使用 ehchashe 时，请注意以下几点：（1）不要用力过猛：按摩过程中，避免用力过猛，以免损伤皮肤和肌肉组织。

（2）避免在饭后立即进行：在饱餐后，最好等待一段时间再进行ehchashe，以免引起消化不良。

（3）个人体验：每个人的体验可能不同，因此请根据自己的感受调整按摩的力度和时间。

ehcache实例

AOP，需要2个拦截器：1.一个是方法执行前查找缓存的拦截器；（query方法执行前先查找是否有缓存，如果有，走缓存，如果没有，执行方法，并且把结果缓存）2.另一个是方法执行后销毁缓存的拦截器；（update,insert,delete等方法执行后需要销毁缓存）方法执行前的拦截器MethodCacheInterceptor.java：Java代码package ehcache;Import java.io.Serializable;import org.aopalliance.intercept.MethodInterceptor;import org.aopalliance.intercept.MethodInvocation;import mons.logging.LogFactory;import mons.logging.Log;import org.springframework.beans.factory.InitializingBean;import org.springframework.util.Assert;import net.sf.ehcache.Cache;import net.sf.ehcache.Element;public class MethodCacheInterceptor implements MethodInterceptor, InitializingBean {private static final Log logger = LogFactory.getLog(MethodCacheInterceptor.class);private Cache cache;public void setCache(Cache cache) {this.cache = cache;}public void afterPropertiesSet() throws Exception {Assert.notNull(cache, "A cache is required. Use setCache(Cache) to provide one.");}public Object invoke(MethodInvocation invocation) throws Throwable {String targetName = invocation.getThis().getClass().getName();String methodName = invocation.getMethod().getName();Object[] arguments = invocation.getArguments();Object result;logger.debug("looking for method result in cache");String cacheKey = getCacheKey(targetName, methodName, arguments);Element element = cache.get(cacheKey);if (element == null) {// call target/sub-interceptorlogger.debug("calling intercepted method");result = invocation.proceed();// cache method resultlogger.debug("caching result");element = new Element(cacheKey, (Serializable) result);cache.put(element);}else{logger.debug("get result from cache");}return element.getValue();}private String getCacheKey(String targetName, String methodName, Object[] arguments) {StringBuffer sb = new StringBuffer();sb.append(targetName).append(".").append(methodName);if ((arguments != null) && (arguments.length != 0)) {for (int i = 0; i < arguments.length; i++) {sb.append(".").append(arguments[i]);}}return sb.toString();}}---------------------------------------------------------------------------------------------------------------------------------------方法执行后的拦截器MethodCacheAfterAdvice.java：Java代码package ehcache;import ng.reflect.Method;import java.util.List;import net.sf.ehcache.Cache;import mons.logging.Log;import mons.logging.LogFactory;import org.springframework.aop.AfterReturningAdvice;import org.springframework.beans.factory.InitializingBean;import org.springframework.util.Assert;public class MethodCacheAfterAdvice implements AfterReturningAdvice, InitializingBean{private static final Log logger = LogFactory.getLog(MethodCacheAfterAdvice.class);private Cache cache;public void setCache(Cache cache) {this.cache = cache;}public MethodCacheAfterAdvice() {super();}public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throw able {String className = arg3.getClass().getName();List list = cache.getKeys();for(int i = 0;i<list.size();i++){String cacheKey = String.valueOf(list.get(i));if(cacheKey.startsWith(className)){cache.remove(cacheKey);logger.debug("remove cache " + cacheKey);}}}public void afterPropertiesSet() throws Exception {Assert.notNull(cache, "Need a cache. Please use setCache(Cache) create it.");}}---------------------------------------------------------------------------------------------------------------------------------------测试用的测试方法TestService.java：Java代码package ehcache;public class TestService{public String testMethod(){System.out.println("没走缓存，直接调用TestService.testMethod()");return "1";}public void updateMethod(){System.out.println("updateMethod");}public void insertMethod(){System.out.println("insertMethod");}public void deleteMethod(){System.out.println("deleteMethod");}}---------------------------------------------------------------------------------------------------------------------------------------缓存配置文件ehcache.xml：Java代码<defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"overflowToDisk="false"diskSpoolBufferSizeMB="30"maxElementsOnDisk="10000000"diskPersistent="false"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"/><cache name="testCache"maxElementsInMemory="1000"eternal="false"timeToIdleSeconds="150"timeToLiveSeconds="150"overflowToDisk="false"memoryStoreEvictionPolicy="LRU"/>缓存配置文件ehcache-config.xmlJava代码<beans><bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactor yBean"><property name="configLocation"><value>src/ehcache/ehcache.xml</value></property></bean><bean id="methodCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean"><property name="cacheManager"><ref local="cacheManager"/></property><property name="cacheName"><value>testCache</value></property></bean><bean id="methodCacheInterceptor" class="ehcache.MethodCacheInterceptor"><property name="cache"><ref local="methodCache" /></property></bean><bean id="methodCacheAfterAdvice" class="ehcache.MethodCacheAfterAdvice"><property name="cache"><ref local="methodCache" /></property></bean><bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPoi ntcutAdvisor"><property name="advice"><ref local="methodCacheInterceptor"/></property><property name="patterns"><list><value>.*TestService.testMethod</value></list></property></bean><bean id="methodCacheDestory" class="org.springframework.aop.support.RegexpMethodPoin tcutAdvisor"><property name="advice"><ref local="methodCacheAfterAdvice"/></property><property name="patterns"><list><value>.*TestService.update*</value><value>.*TestService.insert*</value><value>.*TestService.delete*</value></list></property></bean></beans><beans>---------------------------------------------------------------------------------------------------------------------------------------Spring配置文件applicationContext.xmlXml代码<beans default-autowire="byName"><import resource="ehcache-config.xml"/><bean id="testService" class="org.springframework.aop.framework.ProxyFactoryBean" ><property name="target"><bean class="ehcache.TestService"/></property><property name="interceptorNames"><list><value>methodCachePointCut</value><value>methodCacheDestory</value></list></property></bean></beans>---------------------------------------------------------------------------------------------------------------------------------------测试用Main方法：Java代码package ehcache;import org.springframework.context.ApplicationContext;import org.springframework.context.support.FileSystemXmlApplicationContext;public class TestMain {public static void main(String args[]) throws Exception{ApplicationContext ctx = new FileSystemXmlApplicationContext("src/ehcache/applicationCon text.xml");TestService t = (TestService)ctx.getBean("testService");System.out.println("第一次调用：" + t.testMethod());System.out.println("第二次调用：" + t.testMethod());System.out.print("更新操作：");t.updateMethod();System.out.println("第三次调用：" + t.testMethod());}}---------------------------------------------------------------------------------------------------------------------------------------运行结果：Java代码没走缓存，直接调用TestService.testMethod()第一次调用：1第二次调用：1更新操作：updateMethod没走缓存，直接调用TestService.testMethod()第三次调用：1没走缓存，直接调用TestService.testMethod() 第一次调用：1 第二次调用：1 更新操作：updateMethod 没走缓存，直接调用TestService.testMethod() 第三次调用：1可以看到，第一次调用时没走缓存，第二次就走缓存然后执行update操作，执行完后销毁缓存第三次调用，又没走缓存。

二级缓存(ehcache)

以下是使用hibernate二级缓存时常遇到的一些配置的详细解释，希望对各位有所帮助：配置一：hibernate.cfg.xml文件中增加<propertyname="cache.provider_class">org.hibernate.cache.EhCacheProvider</property> <property name="e_query_cache">true</property>配置二：工程项目src文件下新建一个ehcache.xml文件，其内容为<?xml version="1.0" encoding="UTF-8"?><ehcache><diskStore path="java.io.tmpdir" /><defaultCache maxElementsInMemory="10000" eternal="false" overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="180" diskPersistent="false" diskExpiryThreadIntervalSeconds="120" /></ehcache>配置三：为了缓存某类的对象，其hbm文件中需添加<cache usage="read-only"/>属性例如：<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="com.vogue.bbsphoto.entity.Forum"table="cdb_forums"><cache usage="read-only"/><id name="ID" column="fid" unsaved-value="null"><generator class="increment" /></id><property name="name" column="name" type="string" /><property name="type" column="type" type="string" /></class></hibernate-mapping>配置四：为了使用查询缓存，Query必须设置cacheable为true,query.setCacheable(true);例如dao父类中用于hql查询的方法修改后为：/*** 执行hql语句的查询* @param sql* @return*/public List executeQuery(String hql){List list = new ArrayList();Session session = HibernateSessionFactory.currentSession();Transaction tx = null;Query query = session.createQuery(hql);query.setCacheable(true);try {tx = session.beginTransaction();list = query.list();mit();} catch (Exception ex) {ex.printStackTrace();HibernateSessionFactory.rollbackTransaction(tx);} finally {HibernateSessionFactory.closeSession();}return list;}。

ehcache

Ehcache缓存配置文章分类:Java编程简介Cache的配置很灵活，官方提供的Cache配置方式有好几种。

你可以通过声明配置、在xml中配置、在程序里配置或者调用构造方法时传入不同的参数。

你可以将Cache的配置从代码中剥离出来，也可以在使用运行时配置，所谓的运行时配置无非也就是在代码中配置。

以下是运行时配置的好处：·在同一个地方配置所有的Cache，这样很容易管理Cache的内存和磁盘消耗。

·发布时可更改Cache配置。

·可再安装阶段就检查出配置错误信息，而避免了运行时错误。

本文将会对ehcache.xml配置文件进行详细的阐述。

在配置的时可以拷贝一个现有的ehcache.xml，如果没有请点击这里去下载。

ehcache-failsafe.xml如果你调用了CacheManager默认构造方法去创建CacheManager的实例，此方法会到classpath中找ehcache.xml文件，否则它会到类路径下找ehcache-failsafe.xml文件。

而ehcache-failsafe.xml被包含在jar包中，所有它肯定能找的到。

ehcache-failsafe.xml提供了一个非常简单的默认配置，这样可以使用户在没有创建ehcache.xml的情况下使用Ehcache。

不过这样做Ehcache会提醒用户创建一个正确的Ehcache配置。

ehcache.xml片段：<ehcache><diskStore path="java.io.tmpdir"/><defaultCachemaxElementsInMemory="10000"eternal="false"timeToIdleSeconds="120"timeToLiveSeconds="120"overflowToDisk="true"maxElementsOnDisk="10000000"diskPersistent="false"diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"/></ehcache>ehcache.xml和其他配置文件在Ehcache-1.6之前的版本，只支持ASCII编码的ehcache.xml配置文件。