Ehcache

Ehcache是基于Java实现的一套简单、高效、线程安全的缓存管理类库。Ehcache提供了内存、磁盘文件及分布式存储方式等多种灵活的Cache管理方案，特点是快速、轻量、可伸缩、操作灵活、支持持久化等。

1.Ehcache的原理

Ehcache是基于Java实现的高效缓存框架，其内部采用多线程实现，采用LinkedHashMap存储元素，同时支持将数据持久化到物理磁盘上。

2.Ehcache的特点

（1）快速：Ehcache内部采用多线程机制实现，数据存取性能高。

（2）轻量：Ehcache的安装包大小只有1.6MB，可以被快速、方便地继承到系统中。

（3）可伸缩：Ehcache缓存在内存和硬盘的存储可以伸缩到数几十GB，可轻松应对大数据场景。

（4）操作灵活：Ehcache提供了丰富的API接口，可实现基于主键、条件进行数据读取等。同时，Ehcache支持在运行时修改缓存配置（存活时间、空闲时间、内存的最大数据、磁盘的最大数量），提高了系统维护的灵活性。

（5）支持多种淘汰算法：Ehcache支持最近最少被使用、最少被使用和先进先出缓存策略。

（6）支持持久化：Ehcache支持将缓存数据持久化到磁盘上，在机器重启后从磁盘上重新加载缓存数据。

3.Ehcache的架构

Ehcache在架构上由Cache Replication、In-Process API和Core组成。其中，Cache Replication存储缓存副本；In-Process API封装操作缓存数据的API，包括Hibernate API、JMX API、Servlet Cacheing FilterAPI等；Core是Ehcache的核心部分，包括用于管理缓存的CacheManger、用于存储缓存的Store和用于操作缓存的Cache API等；NetWork APIs提供RESTful API、SOAP API等Web API接口

4.Ehcache的存储方式

Ehcache的存储方式包括堆存储、堆外存储和磁盘存储。

（1）堆存储：将缓存数据存储在Java堆内存中，其特点是存取速度快，但容量有限。

（2）堆外存储：基于NIO的DirectByteBuffers实现，将缓存数据存储在堆外内存上。其特点是比磁盘存取速度快，而且不受GC的影响，可以保证响应时间的稳定性，在内存分配上开销比堆内存大，而且要求必须以字节数组方式存储，因此对象必须在存储过程中进行序列化，对读取操作则进行反序列化，数据存取速度比堆内存慢一个数量级。

（3）磁盘存储：将数据存储在磁盘上，保障服务重启后内存数据能够重新从磁盘上加载，其读取效率最低，是内存数据持久化的一种方式。

5.Ehcache的扩展模块

Ehcache是开放的缓存系统，除自身的实现外还有其他扩展模型，这些扩展模型是相互独立的库，每个都为Ehcache添加新的功能。


	
ehcache-core：API，标准缓存引擎，RMI复制和Hibernate支持
	
	

	
ehcache：分布式Ehcache，包括Ehcache的核心和Terracotta的库
	
	

	
ehcache-monitor：企业级监控和管理
	
	

	
ehcache-web：为Java Servlet Container提供缓存，gzip压缩支持的filters
	
	

	
ehcache-jcache：JSR 107 JCACHE的实现
	
	

	
ehcache-jgroupsreplication：使用JGroup的复制
	
	

	
ehcache-jmsreplication：使用JMS的复制
	
	

	
ehcache-openjpa：OpenJPA插件
	
	

	
ehcache-server：在war内部署或者单独部署的RESTful cache server
	
	

	
ehcache-unlockedreadsview：允许Terracotta cache 的无锁读
	
	

	
ehcache-debugger：记录RMI分布式调用事件
	
	

	
Ehcache for Ruby：Jruby和Rails支持
	
6.Ehcache的应用

在Spring Boot中使用Ehcache组件比较简单，分为引入jar包、配置ehcache.xml和使用Ehcache缓存。

（1）引入jar包。

（2）设置ehcache.xml。在项目resource的目录下新建ehcache.xml配置文件，

<ehcache>
    <cache name="user" eternal="true" overflowToDisk="true" maxElementsInMemory="1000"/>
</ehcache>

以上代码在ehcache.xml配置文件中声明了一个名称为user的缓存，其中eternal=true表示缓存对象永不过期，maxElementsInMemory表示内存中该Cache可存储最大的数据量，overflowToDisk=true表示在内存缓存的对象数量达到了maxElementsInMemory界限后，会把溢出的对象写到磁盘缓存中。注意：如果需要将缓存的对象写入磁盘中，则该对象必须实现了Serializable接口。

（3）使用Ehcache缓存：

@CachePut(value="user",key="#user.id")

以上代码定义了名为UserService的类，同时定义了保存用户数据的方法save()和查找用户数据的方法findOne()，并分别在方法上通过@Cacheable(value = "user", key ="#user.id")开启Ehcache缓存。

在用户调用save()保存数据时会在Ehcache内存中也保存一份User对象，其key为User对象的id属性。在用户调用findOne()查询该数据时，首先会去Ehcache缓存中查找数据，如果在缓存中存在该数据，则将该数据返回，如果在缓存中不存在该数据，则会去数据库中查询并返回结果。

    

        

            
ehcache

        
	
        

            

    
ehcache
Java缓存框架 EhCache EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 　　下图是 Ehcache 在应用程序中的位置：
  
主要的特性有： 　　1. 快速. 　　2. 简单. 　　3. 多种缓存策略 　　4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题 　　5. 缓存数据会在虚拟机重启的过程中写入磁盘 　　6. 可以通过RMI、可插入API等方式进行分布式缓存 　　7. 具有缓存和缓存管理器的侦听接口 　　8. 支持多缓存管理器实例，以及一个实例的多个缓存区域 　　9. 提供Hibernate的缓存实现 　　10. 等等
http://ehcache.org/
 
 
What Is Ehcache
Ehcache is an open source, standards-based cache used to boost performance, offload the database and simplify scalability. Ehcache is robust, proven and full-featured and this has made it the most widely-used Java-based cache.
It can scale from in-process with one or more nodes through to a mixed in-process/out-of-process configuration with terabyte-sized caches. For applications needing a coherent distributed cache, Ehcache uses the open source Terracotta Sever Array.
Ehcache is actively developed, maintained and supported as a professional open source project by Terracotta, Inc. and is available under an Apache 2 license. In addition to the full-featured open source Ehcache edition, Terracotta offers enterprise editions of Ehcache with 24x7 Professional Support, Consulting, and Training services worldwide.
BigMemory for Ehcache
Use More Memory Without GC Pauses
Create very large, in-memory caches without having Java garbage collection trash your             app’s performance. BigMemory extends the capabilities of Ehcache, providing an off-heap             store that frees you from GC’s memory and performance constraints—as well as             endless GC tuning. With BigMemory, you can take full advantage of all of the memory on your             machine to increase application throughput and achieve consistently low latencies.
BigMemory is a configurable storage option for Ehcache and works everywhere Ehcache works.             Upgrading to Enterprise Ehcache with BigMemory is an easy, non-disruptive process that             amplifies the speed and scalability benefits of caching.
Find out more about BigMemory for Enterprise Ehcache and             download a free 30-day trial at terracotta.org/bigmemory ›
 
Ehcache Search
Query, Search and Analyze In-Memory Data
Ehcache Search is an addition to the core Ehcache API that lets you query, search and             analyze billions of cache entries in memory, with results to complex searches returned in             less than a second. By querying the cache directly, you can avoid the time-consuming and             expensive process of querying the database, then mapping query results to cache             lookups.




    

    

    


        
	
        

            posted on 
2011-11-18 18:41 lexus 阅读(...) 评论(...)  编辑 收藏

        
    

转载于:https://www.cnblogs.com/lexus/archive/2011/11/18/2254484.html

EhCache

我看到maven仓库上有两个EhCache，一个org，一个net，如下所示

    <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
    <dependency>
        <groupId>org.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>3.8.0</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache -->
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>2.10.4</version>
    </dependency>



但是net的已经一年没有更新了，所以我使用的是org.encache

简介

EhCache是一个基于标准的开源缓存，可提高性能，减轻数据负载并简化可伸缩性。它是最广泛使用的基于java的缓存，因为它健壮、可靠、功能齐全并与其他流行的库和框架集成。EhCache从进程内缓存扩展到混合了TB级缓存的进程内/进程外混合部署。
它与Google的Guava最大的区别在于Guava只支持内存缓存，而EhCache支持磁盘缓存（EhCache支持堆内缓存，堆外缓存和磁盘缓存）

快速使用
    CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
          .withCache("preConfigured",
               CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,ResourcePoolsBuilder.heap(100))
               .build())
          .build(true);

    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(100)).build());

    myCache.put(1L, "da one!");
    String value = myCache.get(1L);
    
    cacheManager.close();

详细介绍

CacheManager是管理Cache的一个类
堆内和堆外代码不需要对CacheManager进行什么特殊处理，代码如下

    CacheManager cacheManager =
    CacheManagerBuilder.newCacheManagerBuilder()
          .build(true);


而对于磁盘缓存就要做一些改变(with后面代表的是持久化所需的存储路径)，代码如下

    CacheManager cacheManager =
    CacheManagerBuilder.newCacheManagerBuilder()
          .with(new CacheManagerPersistenceConfiguration(new File("path")))
          .build(true);


之后创建Cache
堆内缓存代码如下

    ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, EntryUnit.ENTRIES); 
    // or
    ResourcePoolsBuilder.heap(10); 
    // or
    ResourcePoolsBuilder.newResourcePoolsBuilder().heap(10, MemoryUnit.MB); 
    
    Cache<k, v> cache = cacheManager.createCache("keyCache",
            CacheConfigurationBuilder.newCacheConfigurationBuilder(k.class, v.class,ResourcePoolsBuilder.newResourcePoolsBuilder().heap(100, MemoryUnit.MB))
                    .build());


堆外缓存代码如下

    Cache<k, v> cache = cacheManager.createCache("keyCache",
            CacheConfigurationBuilder.newCacheConfigurationBuilder(k.class, v.class,ResourcePoolsBuilder.newResourcePoolsBuilder().offheap(100, MemoryUnit.MB))
                    .build());


磁盘缓存代码如下

    Cache<k, v> cache = cacheManager.createCache("keyCache",
            CacheConfigurationBuilder.newCacheConfigurationBuilder(k.class, v.class,ResourcePoolsBuilder.newResourcePoolsBuilder().disk(100, MemoryUnit.MB))
                    .build());


然后对于cache就可以进行很多操作，具体可以看EhCache官方文档

EHCACHE

1:ehcache.xml



<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <diskStore path="java.io.tmpdir"/>
    <defaultCache
            maxElementsInMemory="10000" 
            eternal="false" 
            overflowToDisk="true"
            timeToIdleSeconds="10"
            timeToLiveSeconds="20"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"/>

     <cache name="cacheTest" 缓存名称
        maxElementsInMemory="1000" 缓存的最大个数
        eternal="false" 是否永久有效，一但设置了，timeout将不起作用。
        overflowToDisk="true" 当数量达到maxElementsInMemory，Ehcache将会对象写到磁盘中。 
        maxElementsOnDisk="500"硬盘最大缓存个数。 
        timeToIdleSeconds="10" 缓存自创建日期起至失效时的间隔时间
        timeToLiveSeconds="20"
        diskPersistent="false"
        memoryStoreEvictionPolicy="FIFO"
        diskExpiryThreadIntervalSeconds="120"/> 缓存创建以后，最后一次访问缓存的日期至失效之时的时间间隔；
</ehcache>

如果仅有 timeToLiveSeconds  

那么 自创建时间开始 间隔20后缓存失效； 

如果没有timeToLiveSeconds 那么自最后一次访问缓存 间隔y后 缓存失效； 

如果两个都存在，失效期是20，如果10内没访问，就失效，如果访问N次，每次都会加上10，但是最长不超过20. 

diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。 

       memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。  

使用@Cacheable(value=”cache”,key=”#root.methodName”)在方法上注解，key在一个value中必须要保证唯一，不然指定找不到哪一个缓存。 

比如Spring mvc的Impl实现类的实现方法

@CacheEvict(value=”accountCache”,key=”#account.getName()”)// 清空accountCache 缓存

@CacheEvict(value=”accountCache”,allEntries=true)// 清空accountCache 缓存  

@CachePut(value=”accountCache”,key=”#account.getName()”)// 更新accountCache 缓存