ehcache原理

合集下载

ehcache让内容一直持久化在磁盘，防止异常丢失

ehcache让内容一直持久化在磁盘，防止异常丢失公司让做一个项目，客户提交一批100万的数据上来，程序异步保存提交上来的数据。

于是我把这100万数据缓存在ehcache 里，一开始，保存进去的数据只能读取一次，强行关闭tomcat ，再次读取，缓存的内容就丢失了。

经过多次测试发现，当调用 cache.getValue(key) 方法时，xxx.index 文件大小变为0了（我测试只有一条element，取一个即将全部取出，故为0），如果程序非正常关闭，那么xxx.index 文件就永久为0了，xxx.data 倒是还有内容。

如果程序正常退出（会触发ehcache 的 despose事件），则xxx.index 索引文件恢复原来的大小。

后来经过多次测试，发现，cache.flush() 也有效果，于是在每次cache.getValue(key)之后立马执行一下 cache.flush() ，这样ehcache 会将索引（xxx.index）回写到磁盘。

这样就不用担心程序是否非正常退出导致缓存丢失了。

附上配置文件：<?xml version="1.0" encoding="UTF-8"?><ehcache><diskStore path="mmsehcache" /><defaultCache maxElementsInMemory="10000" eternal="true" overflowToDisk="true" /><cachename="mms"maxElementsInMemory="0"eternal="true"overflowToDisk="true"diskPersistent="true"memoryStoreEvictionPolicy="LFU" ><cacheEventListenerFactoryclass="com.fractal.gateway.util.EhcacheListenerFactory" properties=""/></cache></ehcache>。

EhCache使用详细介绍(转)

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

CacheManager singletonManager = CacheManager.create(); Cache memoryOnlyCache = newCache(“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" /><defaultCachemaxElementsInMemory="5"eternal="false"overflowToDisk="true"timeToIdleSeconds="15"timeToLiveSeconds="120"/></ehcache>4.2在Hibernate.cfg.xml中的mapping标签上面加以下内容：<propertyname="show_sql">true</property><propertyname="hibernate.cache.provider_class">org.hibernate.cache. EhCacheProvider</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

集群环境中使用ehcacheEhCache 缓存系统简介EhCache 是一个纯Java 的进程内缓存框架，具有快速、精干等特点，是Hibernate 中默认的CacheProvider。

下图是EhCache 在应用程序中的位置：图1. EhCache 应用架构图EhCache 的主要特性有：1.快速；2.简单；3.多种缓存策略；4.缓存数据有两级：内存和磁盘，因此无需担心容量问题；5.缓存数据会在虚拟机重启的过程中写入磁盘；6.可以通过RMI、可插入API 等方式进行分布式缓存；7.具有缓存和缓存管理器的侦听接口；8.支持多缓存管理器实例，以及一个实例的多个缓存区域；9.提供Hibernate 的缓存实现；由于EhCache 是进程中的缓存系统，一旦将应用部署在集群环境中，每一个节点维护各自的缓存数据，当某个节点对缓存数据进行更新，这些更新的数据无法在其它节点中共享，这不仅会降低节点运行的效率，而且会导致数据不同步的情况发生。

例如某个网站采用A、B 两个节点作为集群部署，当A 节点的缓存更新后，而B 节点缓存尚未更新就可能出现用户在浏览页面的时候，一会是更新后的数据，一会是尚未更新的数据，尽管我们也可以通过Session Sticky 技术来将用户锁定在某个节点上，但对于一些交互性比较强或者是非Web 方式的系统来说，Session Sticky 显然不太适合。

所以就需要用到EhCache 的集群解决方案。

EhCache 从1.7 版本开始，支持五种集群方案，分别是：●Terracotta●RMI●JMS●JGroups●EhCache Server本文主要介绍其中的三种最为常用集群方式，分别是RMI、JGroups 以及EhCache Server 。

RMI 集群模式RMI 是Java 的一种远程方法调用技术，是一种点对点的基于Java 对象的通讯方式。

EhCache 从1.2 版本开始就支持RMI 方式的缓存集群。

ehcache缓存原理

ehcache缓存原理
Ehcache是一种基于Java的缓存框架，可以提供缓存服务，它的原理是将数据（对象）放入内存中存储，以提高系统的性能。

Ehcache 可以让应用程序更快地访问数据，而不必再从磁盘或数据库获取它。

Ehcache的核心是一种叫做“缓存”的技术，它将数据保存在快速访问的内存中，使其可以快速访问。

这种技术可以大大提高系统性能，并减少CPU和磁盘空间的使用率。

Ehcache使用一种叫做“淘汰”（eviction）的机制来管理它的缓存，也就是如果缓存中的数据量超过一定量，就会将相对不常访问的数据从缓存中移除掉。

这样可以节省很多内存，同时能够更快地访问缓存中的数据。

Ehcache还可以通过一种称为“缓存链接”（cache-chaining）的机制，来连接不同的缓存，以便在系统中存储更多的数据。

这样，当缓存中的数据超过一定量时，将自动向缓存链接中添加新的缓存，从而实现更好的数据存储空间。

Ehcache还支持持续性分区（persistent partitioning），这种技术可以将系统中的缓存数据分割成多个部分，每个部分存储的数据不会超过一定的大小，避免缓存溢出的现象。

另外，Ehcache还提供了一种称为“内存重用”（memory reclamation）的技术，目的是当系统中数据量变大时，可以释放系统中已经不再使用的缓存数据，以便用于存储新的数据。

总的来说，Ehcache的核心原理就是将系统中的数据存储在快速
访问的内存中，以提高系统的性能，同时也可以通过淘汰、缓存链接、持久性分区和内存重用等技术来管理Ehcache的缓存。

Ehcache的优势在于其可靠性高、支持多种数据格式以及用于整个系统的可扩展性。

EhCache缓存系统的使用

EhCache缓存系统的使用在Web开发中，缓存系统的应用能极大提高系统的响应速度，其中在Java应用中EhCache是比较常用的一个缓存框架。

EhCache是一个纯Jvm进程内的缓存框架，具有快速轻量、配置简单、功能强大等特点，是Hibernate中的默认CacheProvider。

下图是EhCache 的基本架构：EhCache的基本模块提供了缓存的实现，包括缓存管理器、多种的缓存策略、缓存的存储及相关扩展和控制接口，Replication模块提供了多种的分布式缓存的实现，两个APIs接口模块并且提供了基于J2EE技术相关的API。

EhCache的使用EhCache的基本包是ehcache-core-$ver.jar，依赖包是SLF4J，可以通过代码配置也可以使用配置文件，基本的元素有：CacheManager，缓存管理器，管理一组缓存的实例；Cache，一个缓存的实例，是缓存存放的地方，实现缓存存取接口；Element，单条缓存的组成单位，有Key、Value两部分，这两部分需要实现Serializeable接口。

基本使用代码如下：CacheManager manager = CacheManager.newInstance("src/config/ehcache.xml");manager.addCache("testCache");Cache test = manager .getCache("testCache");test.put(new Element("key1", "value1"));Element result = test.get(“key1”);test.remove(“key1”);使用Spring框架的时候可以使用IOC简化CacheManager的获取：@Autowiredprivate Cache sysSymbolCache;配置文件的使用介绍：<ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"monitoring="autodetect"><diskStore path="atoscache" /><defaultCache maxElementsInMemory="100000" eternal="false"timeToIdleSeconds="300" timeToLiveSeconds="720000" overflowToDisk="true"memoryStoreEvictionPolicy="LRU" /><cache name="sysSymbolCache" maxElementsInMemory="200000"eternal="false" overflowToDisk="true" diskPersistent="true" timeToIdleSeconds="216000"timeToLiveSeconds="720000"memoryStoreEvictionPolicy="LFU"></cache></ehcache>diskStore代表存储的目录名，默认是java.io.tmpdir，defaultCache是默认的Cache配置。

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

Java的进程内缓存框架：EhCache

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

Ehcache缓存的特点:1. 快速.2. 简单.3. 多种缓存策略4. 缓存数据有两级：内存和磁盘，因此⽆需担⼼容量问题5. 缓存数据会在虚拟机重启的过程中写⼊磁盘6. 可以通过RMI、可插⼊API等⽅式进⾏分布式缓存7. 具有缓存和缓存管理器的侦听接⼝8. ⽀持多缓存管理器实例，以及⼀个实例的多个缓存区域9. 提供Hibernate的缓存实现Ehcache缓存的使⽤(1) – 安装ehcacheEhcache 的特点，是⼀个纯Java ,过程中（也可以理解成插⼊式）缓存实现，单独安装Ehcache ，需把ehcache-X.X.jar 和相关类库⽅到classpath中。

如项⽬已安装了Hibernate ,则不需要做什么，直接可以使⽤Ehcache 。

Ehcache缓存的使⽤(2) - ⽣成CacheManager使⽤CacheManager 创建并管理Cache1.创建CacheManager有4种⽅式：A:使⽤默认配置⽂件创建Java代码1.CacheManager manager = CacheManager.create();B:使⽤指定配置⽂件创建Java代码1.CacheManager manager = CacheManager.create("src/config/ehcache.xml");C:从classpath中找寻配置⽂件并创建Java代码1.URL url = getClass().getResource("/anothername.xml");2.CacheManager manager = CacheManager.create(url);D:通过输⼊流创建Java代码1.InputStream fis = new FileInputStream(new File("src/config/ehcache.xml").getAbsolutePath());2.try {3.manager = CacheManager.create(fis);4.} finally {5.fis.close();6.}Ehcache缓存的使⽤(3) – 解读Ehcache配置⽂件ehcache.xml重要的参数<diskStore path="D:/work2/renhewww/cache"/><cache name=" sampleCache1"maxElementsInMemory="1"maxElementsOnDisk="10000"eternal="false"overflowToDisk="true"diskSpoolBufferSizeMB="20"diskPersistent="true"timeToIdleSeconds="43200"timeToLiveSeconds="86400"memoryStoreEvictionPolicy="LFU"/>属性解释：必须属性：name:设置缓存的名称，⽤于标志缓存,惟⼀maxElementsInMemory:在内存中最⼤的对象数量maxElementsOnDisk：在DiskStore中的最⼤对象数量，如为0，则没有限制eternal：设置元素是否永久的，如果为永久，则timeout忽略overflowToDisk：是否当memory中的数量达到限制后，保存到Disk可选的属性：timeToIdleSeconds：设置元素过期前的空闲时间timeToLiveSeconds：设置元素过期前的活动时间diskPersistent：是否disk store在虚拟机启动时持久化。

Ehcache缓存框架详解

Ehcache缓存框架详解一、前言ehcache是一个比较成熟的Java缓存框架，它提供了用内存，磁盘文件存储，以及分布式存储方式等多种灵活的cache管理方案。

ehcache最早从hibernate发展而来。

由于3.x的版本和2.x的版本API差异比较大。

这里直接学习最新版本的了,但是最后整合spring的时候还是有2.x。

二、安装由于我的项目是使用maven管理的，因此只要在pom文件中添加如下代码即可。

<dependency><groupId>javax.cache</groupId><artifactId>cache-api</artifactId><version>1.0.0</version></dependency><dependency><groupId>org.ehcache</groupId><artifactId>ehcache</artifactId><version>3.3.1</version></dependency>好像ehcache还要依赖上面的那个Cache，因此最好两个多加上。

三、使用1、快速入门__JA V A实现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();这里使用的官网的例子。

ajax技术原理

ajax技术原理Ajax是一种用于创建交互式Web应用程序的技术，它可以让Web页面可以在不刷新整个页面的情况下向服务器发送请求并获取数据，然后在页面中动态地显示它们。

Ajax技术是基于多种技术的复杂集成，它涉及到浏览器端JavaScript、DOM、XMLHttpRequest对象、服务器端脚本等多个方面。

本文将针对Ajax技术的原理、工作流程、技术架构等方面进行详细的介绍。

一、Ajax技术的原理Ajax全称为Asynchronous JavaScript and XML，它最初是由Jesse James Garrett提出的一种Web开发技术，Ajax技术的核心思想是使用JavaScript和XMLHttpRequest对象来与服务器异步通信，从而实现页面的更新，而不需要刷新整个页面。

在使用Ajax技术前，Web应用程序需要刷新整个页面，同时每次页面刷新会向服务器发送一次请求，导致页面响应延迟，影响用户体验。

而使用Ajax技术后，浏览器可以只更新部分页面，不需要刷新整个页面，同时可以多次向服务器请求数据。

Ajax技术的原理是基于JavaScript语言，通过JavaScript语法实现浏览器与服务器之间的异步通信。

在Web页面中，我们可以通过JavaScript创建一个XMLHttpRequest对象，然后使用该对象向服务器发送请求并获取数据。

发送的请求类型可以是各种不同的请求类型，比如GET、POST、PUT、DELETE等。

服务器接收到请求后，会对请求进行处理，并将响应数据返回给浏览器。

浏览器接收到响应数据后，就可以将其显示到页面中，完成页面的更新，而不需要刷新整个页面。

二、Ajax技术的工作流程Ajax技术的工作流程是由浏览器端和服务器端两部分组成。

浏览器端负责通过JavaScript创建XMLHttpRequest 对象，然后向服务器发送HTTP请求。

在服务器端，接收到HTTP请求后，服务器会根据请求类型进行相应的处理，然后将处理结果返回给浏览器。

Ehcache介绍

Ehcache介绍关键字：Ehcache、缓存Ehcache是一个缓存库。

在开始介绍Ehcache之前，首先介绍一下常规的缓存。

1 关于缓存以下是维基百科中对于缓存的解释：在计算机工程领域，缓存是透明的存储以后需要的快速使用的数据的组件。

存储在缓存中的数据可能是先前已经计算好的数据或存储在别处数据的副本。

如果数据存储在缓存中，数据请求可以通过读取缓存快速的被处理。

否则（如果不在缓存中），数据不得不被重新计算或从原来存储介质中提取，相比较从缓存中读取而言，处理速度较慢。

因此，缓存可以处理越多的数据请求的话，系统性能就会越好。

[译文, 参见参考文献1]2 关于EhcacheEhcache是一个开源、基于标准(JSR107 JCACHE，参考文献3)、用来提高性能、降低数据库压力并简化可伸缩性的缓存库(关于可伸缩性，参见参考文献4)。

Ehcache是健全的、经过验证的、全特性的、使用最广泛的基于Java的缓存库。

它可以使用千兆级别的缓存，从处理中的单个或多个节点扩充到处理中/非处理中混合配置。

当应用系统需要连贯的分布式缓存时，Ehcache使用开源的Terracotta服务阵列3 Ehcache特性3.1快速和轻量级多年来，各种不同的性能测试已经表明Ehcache是最快的Java缓存之一。

Ehcache的线程是为大规模的、高并发的系统设计的。

很多Ehcache用户几乎不知道它们在使用Ehcache, 合理的默认行为不需要初始配置。

API非常简单，容易使用，使得Ehcache可以在几分钟内启动和与运行。

3.2可伸缩为提供扩展到千兆字节，提供内存和磁盘存储。

最大的Ehcache安装在千兆字节范围上使用内存和磁盘存储，Ehcache依内存和磁盘大小被调整。

扩展到几百个缓存。

最大的Ehcache安装使用几百个缓存。

调整大型多CPU服务器的并发负载。

线程安全和性能之间有一种拉力。

Ehcache的的线程初始时是粗粒度的，但已越来越多地使用Doug Lea(参见参考文献5)的建议，来实现更高的性能。

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原理Ehcache是一个开源的、高性能的Java缓存库，它可以被用于在Java应用程序中进行缓存数据以提高性能。

以下是Ehcache的原理。

1.缓存机制：Ehcache将数据存储在内存中，以提高访问速度。

它使用一个固定的内存空间作为缓存区域，当缓存被填满时，它会使用一种LRU（最近最少使用）策略来替换最旧的缓存项。

Ehcache还可以将缓存项存储在磁盘上，以便在应用程序重启时持久化缓存数据。

2.键值对存储：Ehcache使用键值对的方式存储缓存项。

每个缓存项都有一个唯一的键和一个对应的值。

通过键，应用程序可以在缓存中查找和访问相应的值。

3.缓存策略：Ehcache提供了多种缓存策略来满足不同的需求。

例如，可以通过设置缓存的存活时间来控制缓存项的有效期，一旦超过了指定的时间，缓存项将会过期并被移出缓存区域。

此外，Ehcache还支持基于空间大小的缓存策略，通过设置缓存的最大容量，可以限制缓存中存储的缓存项数量，以防止缓存过度填充。

4.缓存失效：Ehcache提供了多种缓存失效的方式。

除了根据时间或空间来失效缓存项之外，Ehcache还支持手动失效缓存项，即应用程序可以通过指定键来从缓存中移除特定的缓存项。

5.缓存管理：Ehcache允许应用程序对缓存进行管理和配置。

可以通过配置文件或程序代码来设置缓存的属性，例如存活时间、最大容量等。

Ehcache还提供了监控和统计功能，以便了解缓存的使用情况和性能。

6.缓存同步：Ehcache支持多线程环境下的缓存同步。

当多个线程同时访问同一个缓存项时，Ehcache会通过锁机制来确保只有一个线程更新缓存数据。

其他线程将等待更新完成后再获取数据，以保证数据的一致性。

7.分布式缓存：Ehcache还支持分布式缓存，在集群环境下可以将缓存数据存储在多个节点上。

Ehcache使用RMI机制来实现节点之间的通信和缓存数据的同步。

分布式缓存可以提高应用程序的可伸缩性和容错性。

SpringBoot中引入Ehcache3.x

SpringBoot中引入Ehcache3.x1.Ehcache介绍Ehcache是一个用Java实现的简单、高速、线程安全的缓存管理类库。

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

2.引入依赖在项目的pom.xml中添加下面这三个依赖：dependency> groupId>javax.cachegroupId> artifactId>cache-apiartifactId>dependency>dependency> groupId>org.ehcachegroupId> artifactId>ehcacheartifactId> version>3.7.0version>dependency>dependency>groupId>org.springframework.bootgroupId> artifactId>spring-boot-starter-cacheartifactId>dependency>•cache-api是JSR-107 Cache的规范，定义了一列接口规范（但是这只是一种规范，需要使用它的实现，例如ehcache3.x、Hazelcast等）。

•ehcache是ehcache的功能包。

•springBoot要支持第三方缓存的话，还需要引入spring-boot-starter-cache。

3.配置属性3.1 配置application.properties在application.properties添加如下配置：# 可选，配置了spring.cache.jcache.config属性会自动装配JCacheCacheManagerspring.cache.type=jcache# 指定ehcache的配置文件所在的位置spring.cache.jcache.config=classpath:ehcache-3.x.xml3.2配置ehcache-3.x.xml在resources文件夹下新建ehcache-3.x.xml，添加如下内容：eh:config xmlns:xsi='/2001/XMLSchema-instance' xmlns:eh='/v3' xsi:schemaLocation='/v3 /schema/ehcache-core-3.3.xsd'> eh:persistence directory='${java.io.tmpdir}/cache-data'/> eh:cache-template name='default'> eh:expiry> eh:ttl unit='seconds'>600eh:ttl> eh:expiry> eh:resources> eh:heap unit='entries'>2000eh:heap> eh:offheap unit='MB'>100eh:offheap> eh:resources> eh:cache-template> eh:cache alias='sample' uses-template='default'>eh:cache> eh:cache alias='authority_service' uses-template='default'> eh:expiry> eh:ttl unit='hours'>1eh:ttl> eh:expiry> eh:cache> eh:cache alias='shop_service' uses-template='default'> eh:expiry> eh:ttl unit='hours'>24eh:ttl> eh:expiry> eh:cache>eh:config> 更多配置知识，请参考ehcache官网：ehcache XML配置4.使用示例4.1 准备一个controller该controller只有一个方法，获得某类商品的列表：@RestController@Validated@RequestMapping('/v1.0/api/s hop')public class ShopController { @Autowired ShopService shopService; @RequestMapping(value = {'/commodity'}, method = RequestMethod.GET) public List listCommodity (@RequestParam String type) { System.out.println('ShopController: type is ' + type); return shopService.listCommodity(type); }}4.2 准备一个service1.在需要使用缓存的Bean上面添加@EnableCaching注解，那该bean具有缓存功能。

ehcache缓存原理

Ehcache是一个开源的Java分布式缓存框架，它使用内存来存储数据并在需要时从磁盘中加载数据。

它的工作原理如下：
当应用程序需要访问数据时，Ehcache首先在内存中查找数据。

如果数据在内存中，则立即返回数据。

如果数据不在内存中，Ehcache将从磁盘中加载数据并将其存储在内存中，然后返回数据。

当内存中的数据超过一定的限制时，Ehcache会将一些数据存储到磁盘上，以腾出内存空间。

Ehcache使用一种称为淘汰策略的机制来决定哪些数据应该被保留在内存中，哪些应该被淘汰。

常用的淘汰策略有LRU（最近最少使用），LFU（最少访问次数）等。

Ehcache可以通过网络将缓存数据分发到多台机器上，这样就可以实现分布式缓存。

这样的话，当一台机器中的缓存被访问时，其他机器上的缓存也会被更新。

这样，如果其中一台机器宕机，应用程序仍然可以从其他机器获取所需的数据，确保了系统的高可用性。

除此之外，Ehcache还提供了一些高级特性，如缓存过期，缓存刷新，缓存锁定等，来满足不同场景下的需求。

总之，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的属性。

ehcache技术详解

Ehcache技术详解1 基本概念EHCache是一个快速的、轻量级的、易于使用的、进程内的缓存。

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

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

1.1 主要特性(1)快速、简单(2)提供LRU、LFU和FIFO 缓存策略(3)缓存数据有两级：内存和磁盘，因此无需担心容量问题(4)缓存数据会在虚拟机重启的过程中写入磁盘(5)支持分布式缓存(6)支持多缓存管理器实例，以及一个实例的多个缓存区域2 部署2.1 引入官网地址：/下载发布包ehcache-2.8.1-distribution.tar.gz并解压1、将lib下的jar包引入自己的工程包括核心包：ehcache-2.8.1.jar，依赖jar包：slf4j-api-1.6.6.jar，slf4j-jdk14-1.6.6.jar2、将ehcache.xml放到src目录下。

2.2 配置ehcache.xml中的内容如下：<?xml version="1.0"encoding="UTF-8"?><ehcache xmlns:xsi="/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="/ehcache.xsd"> <diskStore path="java.io.tmpdir"/><cache name="sampleCache1"maxEntriesLocalHeap="10000"maxEntriesLocalDisk="1000"eternal="false"overflowToDisk="true"diskPersistent="true"diskSpoolBufferSizeMB="20"timeToIdleSeconds="300"timeToLiveSeconds="600"memoryStoreEvictionPolicy="LFU"diskExpiryThreadIntervalSeconds ="120"transactionalMode="off"><cacheEventListenerFactoryclass="com.ehcache.EhcacheListenerTest"properties="wxwtestkey=200,wxtestkey2=300"/><persistence strategy="localTempSwap"/></cache></ehcache>配置项详解：<diskStore path="java.io.tmpdir"/>此配置项配置的是，磁盘缓存的位置。

EhCache注解（转载）

EhCache注解（转载）其实EhCache使⽤的就是Spring Cache的注解。

1.1 @Cacheable@Cacheable可以标记在⼀个⽅法上，也可以标记在⼀个类上。

当标记在⼀个⽅法上时表⽰该⽅法是⽀持缓存的，当标记在⼀个类上时则表⽰该类所有的⽅法都是⽀持缓存的。

对于⼀个⽀持缓存的⽅法，Spring会在其被调⽤后将其返回值缓存起来，以保证下次利⽤同样的参数来执⾏该⽅法时可以直接从缓存中获取结果，⽽不需要再次执⾏该⽅法。

Spring在缓存⽅法的返回值时是以键值对进⾏缓存的，值就是⽅法的返回结果，⾄于键的话，Spring⼜⽀持两种策略，默认策略和⾃定义策略，这个稍后会进⾏说明。

需要注意的是当⼀个⽀持缓存的⽅法在对象内部被调⽤时是不会触发缓存功能的。

@Cacheable可以指定三个属性，value、key和condition。

1.1.1 value属性指定Cache名称value属性是必须指定的，其表⽰当前⽅法的返回值是会被缓存在哪个Cache上的，对应Cache的名称。

其可以是⼀个Cache也可以是多个Cache，当需要指定多个Cache时其是⼀个数组。

@Cacheable("cache1")//Cache是发⽣在cache1上的public User find(Integer id) {return null;}@Cacheable({"cache1", "cache2"})//Cache是发⽣在cache1和cache2上的public User find(Integer id) {return null;}1.1.2 使⽤key属性⾃定义keykey属性是⽤来指定Spring缓存⽅法的返回结果时对应的key的。

该属性⽀持SpringEL表达式。

当我们没有指定该属性时，Spring将使⽤默认策略⽣成key。

我们这⾥先来看看⾃定义策略，⾄于默认策略会在后⽂单独介绍。

详细解析Ehcache的底层实现原理和逻辑

详细解析Ehcache的底层实现原理和逻辑（英文介绍）：Ehcache is a widely used open-source caching library for Java-based applications. Its underlying implementation principles and logic are centered around providing an efficient, scalable, and easy-to-use caching solution.At the core of Ehcache lies the concept of a cache manager and cache instances. The cache manager, represented by the CacheManager class, serves as the entry point for accessing and managing caches. It handles tasks such as cache creation, configuration, and lifecycle management. Each cache instance, represented by the Cache interface, represents a named and configurable storage container for caching data.Ehcache supports both in-memory and disk-based caching. In-memory caching stores data in the JVM's heap space, providing fast access times. Disk-based caching, on the other hand, persists data to the file system, allowing for larger cache sizes and data survival across application restarts. Ehcache efficiently manages the transfer of data between these two storage tiers based on configuration parameters and runtime conditions.The caching logic in Ehcache revolves around key-value pairs. When a data item is put into the cache, it is associated with a unique key, which is used for subsequent retrieval operations. Ehcache provides various eviction policies, such as LRU (Least Recently Used) and TTL (Time To Live), to automatically remove old or expired entries from the cache, ensuring optimal cache performance. Additionally, Ehcache supports caching strategies like caching-through and caching-aside. Caching-through involves intercepting all data access requests and serving them from the cache if possible, while also updating the cache with the latest data from the underlying data source. Caching-aside, on the other hand, leaves the decision of when to populate or evict the cache to the application logic.Ehcache also provides features like cache replication and clustering, allowing distributed caching across multiple nodes for improved scalability and fault tolerance.Overall, Ehcache's underlying implementation principles and logic are designed to offer a robust and flexible caching solution that can be seamlessly integrated into a wide range of Java applications.详细解析Ehcache的底层实现原理和逻辑（中文介绍）：Ehcache是一个广泛使用的基于Java的开源缓存库。

Ehcache架构

WSO2采用Ehcache缓存1、快速轻量过去几年，诸多测试表明Ehcache是最快的Java缓存之一。

Ehcache的线程机制是为大型高并发系统设计的。

大量性能测试用例保证Ehcache在不同版本间性能表现得一致性。

很多用户都不知道他们正在用Ehcache，因为不需要什么特别的配置。

API易于使用，这就很容易部署上线和运行。

很小的jar包，Ehcache 2.2.3才668kb。

最小的依赖：唯一的依赖就是SLF4J了。

2、伸缩性缓存在内存和磁盘存储可以伸缩到数G，Ehcache为大数据存储做过优化。

大内存的情况下，所有进程可以支持数百G的吞吐。

为高并发和大型多CPU服务器做优化。

线程安全和性能总是一对矛盾，Ehcache的线程机制设计采用了Doug Lea的想法来获得较高的性能。

单台虚拟机上支持多缓存管理器。

通过Terracotta服务器矩阵，可以伸缩到数百个节点。

3、灵活性Ehcache 1.2具备对象API接口和可序列化API接口。

不能序列化的对象可以使用除磁盘存储外Ehcache的所有功能。

除了元素的返回方法以外，API都是统一的。

只有这两个方法不一致：getObjectValue和getKeyValue。

这就使得缓存对象、序列化对象来获取新的特性这个过程很简单。

支持基于Cache和基于Element的过期策略，每个Cache的存活时间都是可以设置和控制的。

提供了LRU、LFU和FIFO缓存淘汰算法，Ehcache 1.2引入了最少使用和先进先出缓存淘汰算法，构成了完整的缓存淘汰算法。

提供内存和磁盘存储，Ehcache和大多数缓存解决方案一样，提供高性能的内存和磁盘存储。

动态、运行时缓存配置，存活时间、空闲时间、内存和磁盘存放缓存的最大数目都是可以在运行时修改的。

4、标准支持Ehcache提供了对JSR107 JCACHE API最完整的实现。

因为JCACHE在发布以前，Ehcache的实现（如net.sf.jsr107cache）已经发布了。

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

转ehcache 基本原理hjp222发表于2011-03-22 16:30 最后修改于2011-05-16 15:32 浏览(105) 评论(0)分类：ehcache 举报ehcache是一个用Java实现的使用简单，高速，实现线程安全的缓存管理类库，ehcache 提供了用内存，磁盘文件存储，以及分布式存储方式等多种灵活的cache管理方案。

同时ehcache作为开放源代码项目，采用限制比较宽松的Apache License V2.0作为授权方式，被广泛地用于Hibernate, Spring，Cocoon等其他开源系统。

Ehcache的类层次模型主要为三层，最上层的是CacheManager，他是操作Ehcache的入口。

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

每个CacheManager都管理着多个Cache。

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

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

ehcache的刷新策略ehcache的刷新策略是当缓存在放入的时候记录一个放入时间，它是用Lazy Evict的方式，在取的时候同设置的TTL比较ehcache缓存的3种清空策略：1 FIFO，先进先出2 LFU，最少被使用，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。

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

事件处理可以为CacheManager添加事件监听，当对CacheManager增删Cache时，事件处理器将会得到通知。

要配置事件处理，需要通过ehcache的配置文件来完成。

可以为Cache添加事件监听，当对Cache增删Element时，事件处理器将会得到通知。

要配置事件处理，需要通过ehcache的配置文件来完成。

ehcache参数配置：maxInMemory - 设定内存中创建对象的最大值。

eternal - 设置元素（译注：内存中对象）是否永久驻留。

如果是，将忽略超时限制且元素永不消亡。

timeToIdleSeconds - 设置某个元素消亡前的停顿时间。

也就是在一个元素消亡之前，两次访问时间的最大时间间隔值。

这只能在元素不是永久驻留时有效（译注：如果对象永恒不灭，则设置该属性也无用）。

如果该值是0 就意味着元素可以停顿无穷长的时间。

timeToLiveSeconds - 为元素设置消亡前的生存时间。

也就是一个元素从构建到消亡的最大时间间隔值。

这只能在元素不是永久驻留时有效。

overflowToDisk - 设置当内存中缓存达到maxInMemory 限制时元素是否可写到磁盘上。

1.ehcache使用了LinkedHashMap来存放Element。

jdk要1.5以上。

Ehcache1.5可以使用jdk1.42.如果在添加Elemtent时，缓存中的Element个数达到了最大缓存数并且overflowToDisk配置的属性为true，Ehcache会更具配置项MemoryStoreEvictionPolicy的失效策略将Element输出到磁盘。

如果overflowToDisk为fasle，Ehcache将删除内存中Element3.值得注意的是缓存中失效的Element并不会别马上清理掉，所以想得到内存的真实大小应该调用方法calculateInMemorySize()方法。

4.一个ehcache.xml对应一个CacheManager5.不同的缓存应该对应不同的硬盘上的路径，否则会报错6.注意要想使用磁盘缓存，缓存的Element必须实现序列化接口。

否则会抛出NotSerializableException异常。

7.Ehcache会将每个缓存配置的文件路径下创建一个cache_name.data文件，如果使用的磁盘持久化技术，还会生成一个cache name.index文件。

8.Ehcache有一个后台线程专门做Ellment失效监测以及清除工作。

设置线程运行间隔时间，可通过设置diskExpiryThreadIntervalSeconds属性来完成，此值不宜设置过低，否则会导致清理线程占用大量CPU资源。

默认值是120秒。

9.持久化可在Element的diskPersistent配置项中配置，如果配置为“false”或是“omitted”在CacheManager shutdown或是startup后，用来缓存Element的文件将被清除掉。

如果设置为“true”，data和index文件会被保存下来，对于新创建的CacheManager Element 也是可用的。

10.使用时必须显示调用cache. Flush()才会将数据缓存到磁盘中。

11.磁盘缓存步骤：从MemoryStore中把没有失效的Element刷新到DiskStore，Element被写入到data文件，Element将被序列化到index文件。

12.磁盘缓存大小默认是没有限制的，不过可通过maxElementsOnDisk来指定。

当磁盘缓存达到maxElementsOnDisk指定的值时，Ehcache会清理磁盘中的缓存使用默认策略是LFU （使用频率最低）。

13.在使用完Ehcache后，必须要shutdown缓存。

Ehcache中有自己的关闭机制，不过最好在你的代码中显示调用CacheManager.getInstance().shutdown();14.Cache:对于getValue()能取到可序列化的值；getObjectValue()取得非序列化的值15.cache.getSize();得到缓存中元素的个数；获得当前MemoryStore中的element数量：cache.getMemoryStoreSize();获得当前DiskStore中element数量：cache.getDiskStoreSize();16.在使用完Ehcache后，必须要shutdown缓存。

Ehcache中有自己的关闭机制，不过最好在你的代码中显示调用CacheManager.getInstance().shutdown();17.ehcache-core-1.6—1.7没有任何依赖；ehcache1.7.1依赖SLF4J，以及相应的log的jar包。

18.CacheManager可以通过单例（factory的静态方法）或者构造函数（constructors）创建。

分别叫做single model和instance model。

当两种情况都有的时候，系统会采用单例模式，构造器每次都生成单例模式19.对于想存储数据到硬盘，或者集群时复制到其他缓存区域的数据，必须可序列化。

如果不可序列化，该数据在进行上述操作时会被丢弃，且没有报错，只是在debug级别有日志信息。

20.读取cache的数据，有以下几种方式：Cache-aside: 直接操作数据Cache-as-sor:read-through、write-through和write-behind的结合Read-through:Write-through:Write-behind:21.从ehcache2.0开始，以下属性可以在运行时改变：• timeToLive• timeToIdle• maxElementsInMemory• maxElementsOnDisk• memory store eviciton policy• CacheEventListeners can be added and removed dynamically []当eternal属性为“true”时，timeToLive和timeToIdle会失效22.以下代码演示怎么运行时修改缓存属性This example shows how to dynamically modify the cache configuration of an alreadyrunning cache:Cache cache = manager.getCache("sampleCache");CacheConfiguration config = cache.getCacheConfiguration();config.setTimeToIdleSeconds(60);config.setTimeToLiveSeconds(120);config.setMaxElementsInMemory(10000);config.setMaxElementsOnDisk(1000000);Dynamic cache configurations can also be frozen to prevent future changes:Cache cache = manager.getCache("sampleCache");cache.disableDynamicFeatures();23.2.5之前是通过元素的个数来表示内存或者硬盘的大小；2.5之后，通过字节数来表示。

2.5暂时还没有出来。

新属性将会是：The new cache attributes are:• maxBytesOnHeap• maxBytesOffHeap (formerly maxMemoryOffHeap)• maxBytesOnDisk甚至，还可以指定比例，如：maxBytesOnHeap="20%".24.Ehcache可以将一些数据一直放到缓存或者堆栈或者硬盘或者terracotta的L2中。

主要是为了满足Hibernate等一些情况下的需求。

但是，这样很容易造成内存溢出的错误25.当缓存刚启动时，ehcache提供一个机制可以先加载数据：BootstrapCacheLoader<bootstrapCacheLoaderFactoryclass="net.sf.ehcache.distribution.jgroups.JGroupsBootstrapCacheLoaderFactory"properties="bootstrapAsynchronously=true"/>DiskStoreBootstrapCacheLoaderFactory：从硬盘加载数据到堆栈<bootstrapCacheLoaderFactoryclass="net.sf.ehcache.store.DiskStoreBootstrapCacheLoaderFactory"properties="bootstrapAsynchronously=true"/>TerracottaBootstrapCacheLoaderFactory：从terracotta的L2中加载数据<bootstrapCacheLoaderFactoryclass="net.sf.ehcache.store.TerracottaStoreBootstrapCacheLoaderFactory"properties="bootstrapAsynchronously=true"/>26.可以配置ehcache在读或者写的时候，做些事情。