一、简介
　　EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点。Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。

     主要的特性有：

 快速
 简单
 多种缓存策略
缓存数据有两级：内存和磁盘，因此无需担心容量问题
 缓存数据会在虚拟机重启的过程中写入磁盘
可以通过RMI、可插入API等方式进行分布式缓存
 具有缓存和缓存管理器的侦听接口
支持多缓存管理器实例，以及一个实例的多个缓存区域
提供Hibernate的缓存实现
二、详细配置
EhCache 给我们提供了丰富的配置来配置缓存的设置。

cache元素的属性：  

    name：缓存名称  

    maxElementsInMemory：内存中最大缓存对象数  

    maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大  

    eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false  

    overflowToDisk：true表示当内存缓存的对象数目达到了maxElementsInMemory界限后，会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。

　 diskSpoolBufferSizeMB：磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区。  

    diskPersistent：是否缓存虚拟机重启期数据  

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

    timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态  

    timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义  

    memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。

三、持久化到硬盘
在一些系统中，使用EhCache来缓存数据的时候，有时是不需要持久化到硬盘的，但是在爬虫系统，就需要将数据 持久化到硬盘，用来判断URL是否重复，也就是对爬取过去的URL进行过滤，避免重复爬取。

　　参考配置：

<?xml version="1.0" encoding="UTF-8"?>
 
<ehcache>
   <!-- 
         磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存
          path:指定在硬盘上存储对象的路径
   -->
   <diskStore path="C:\ehcache" />
    
   <!-- 
        defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理
        maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象
        eternal:代表对象是否永不过期
        overflowToDisk:当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中
   -->
   <defaultCache
      maxElementsInMemory="100"
      eternal="true"
      overflowToDisk="true"/>
 
    <!-- 
        maxElementsInMemory设置成1，overflowToDisk设置成true，只要有一个缓存元素，就直接存到硬盘上去
        eternal设置成true，代表对象永久有效
        maxElementsOnDisk设置成0 表示硬盘中最大缓存对象数无限大
        diskPersistent设置成true表示缓存虚拟机重启期数据 
     -->
    <cache 
      name="a"
      maxElementsInMemory="1" 
      eternal="true"
      overflowToDisk="true" 
      maxElementsOnDisk="0"
      diskPersistent="true"/>
 
</ehcache>
四、实例
　　此处使用的EhCache版本为2.X，此版本比较稳定。

1.pom.xml

<dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>2.10.4</version>
    </dependency>
2.代码实现

public static void main(String[] args) {
        String path = System.getProperty("user.dir");
        // 创建Cache管理器
        CacheManager manager = CacheManager.create(path + "\\src\\main\\resources\\ehcache.xml");
        // 获取指定Cache
        Cache cache = manager.getCache("a");
        // 把一个元素添加到Cache中
        cache.put(new Element("name", "Joe"));
        // 根据Key获取缓存元素
        Element ele = cache.get("name");
        System.out.println("name==" + ele.getObjectValue());
        
        cache.flush(); // 刷新缓存
        manager.shutdown();  // 关闭缓存管理器
    }
3.查看C盘中的ehcache文件夹，有如下文件，说明缓存到磁盘中了。
原文链接：https://blog.csdn.net/qq_42969074/article/details/85642873

 

使用代码编写的方式使用ehcache：

准备一个可用的maven项目：并加入依赖；

               <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.8.3</version>
        </dependency>

首先您得准备一些ehcache的配置文件：

 ehcache.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
    updateCheck="false">
    <diskStore path="java.io.tmpdir/Tmp_EhCache" />
    
    <!-- defaultCache，是默认的缓存策略 -->
    <!-- 如果你指定的缓存策略没有找到，那么就用这个默认的缓存策略 -->
    <!-- external：缓存对象是否一直存在，如果设置为true的话，那么timeout就没有效果，缓存就会一直存在，一般默认就是false -->
    <!-- maxElementsInMemory：内存中可以缓存多少个缓存条目 -->
    <!-- overflowToDisk：如果内存不够的时候，是否溢出到磁盘 -->
    <!-- diskPersistent：是否启用磁盘持久化的机制，在jvm崩溃的时候和重启之间 -->
    <!-- timeToIdleSeconds：对象最大的闲置的时间，如果超出闲置的时间，可能就会过期  单位：秒 当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大-->
    <!-- timeToLiveSeconds：对象最多存活的时间  单位：秒 当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是存活时间无穷大-->
    <!-- memoryStoreEvictionPolicy：当缓存数量达到了最大的指定条目数的时候，需要采用一定的算法，从缓存中清除一批数据，LRU，最近最少使用算法，最近一段时间内，最少使用的那些数据，就被干掉了 -->
    <defaultCache
        eternal="false"
        maxElementsInMemory="1000"
        overflowToDisk="false"
        diskPersistent="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="0"
        memoryStoreEvictionPolicy="LRU" />
 
     <!-- 手动指定的缓存策略 -->
     <!-- 对不同的数据，缓存策略可以在这里配置多种 -->
    <cache
        name="local"  
        eternal="false"
        maxElementsInMemory="1000"
        overflowToDisk="false"
        diskPersistent="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="0"
        memoryStoreEvictionPolicy="LRU" />    
</ehcache>
b.在编码中读取ehcache配置文件，并得到EhCacheCacheManager操作：

import net.sf.ehcache.Cache;
     import net.sf.ehcache.CacheManager;
     import net.sf.ehcache.Element;
@org.junit.Test  
        public void testEhcache (){  
            CacheManager create = CacheManager.create(this.getClass().getResourceAsStream("/ehcache.xml"));
            Cache cache = create.getCache("local");
            cache.put(new Element("key1", "value1"));
            Element element = cache.get("key1");
            System.out.println(element.getObjectKey()+" : "+element.getObjectValue());
            
        }

如此，可以自己封装到单例中作为工具提供。

2.使用springboot注解方法：

 准备工作：一个可以正常使用的springboot项目：也要添加上面的ehcache依赖和ehcache配置 。

a.读取ehcache配置 生成EhCacheCacheManager：

EhcacheConfiguration.java:


import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
 
@Configuration
@EnableCaching
public class EhcacheConfiguration {
    @Bean
    public EhCacheManagerFactoryBean cacheManagerFactoryBean(){
        EhCacheManagerFactoryBean bean = new EhCacheManagerFactoryBean();
        bean.setConfigLocation(new ClassPathResource("ehcache.xml"));
        bean.setShared(true);
        return bean;
    }
    @Bean
    public EhCacheCacheManager ehCacheCacheManager(EhCacheManagerFactoryBean bean){
      return new EhCacheCacheManager(bean.getObject());
    }    
}
在service中使用ehcache：
EhcahceServiceImpl.java:


@Service
public class EhcahceServiceImpl implements EhcahceService {
 
    private Log log = LogFactory.getLog(EhcahceServiceImpl.class);
//    @Resource
//    private JedisCluster cluster;
    @Resource
    private Jedis cluster;
    private static final String CACHE_STRATEGY = "local";
    
    @CachePut(value=CACHE_STRATEGY,key="'key_'+#info.getProduct_id()")
    @Override
    public ProductInfo saveProductInfo(ProductInfo info) throws Exception {
        return info;
    }
    //@CacheEvict(value="myCache", key="'get'+#userNo")  
    allEntries为true表示清除value中的全部缓存,默认为false  
   // @CacheEvict(value="myCache", allEntries=true)  
    @Cacheable(value=CACHE_STRATEGY,key="'key_'+#id")
    @Override
    public ProductInfo getProductInfoById(Long id) throws Exception {
        return null;
    }}
到此我们就可以简单的使用ehcache到我们的项目中了。ehcache被更多的作为本地的缓存机制，但是在业务复杂频频的系统中，单靠ehcache貌似有些吃力，这时我们可以加上Redis，
让Redis做为分布式缓存，ehcache做本地的缓存，形成拥有2种缓存的系统。在一个请求被路由到某台服务上时，系统先去Redis中找，Reids中有

对应的缓存就返回，没有的话再从本地的Ehcache中找，找到则返回，找不到就从数据库中查询了，查询了之后我们可以保持在Redis

和本地的Ehcache中。
原文链接：https://blog.csdn.net/u014104286/article/details/79125141

如下也可直接注入CacheManager对象缓存

@Component
public class EhcacheUtil {
    /**
     * 管理员菜单缓存
     */
    public final static String ADMINMENUEHCACHENAME = "adminMenuCache";

    @Resource
    public CacheManager manager;

    /**
     * 获得一个Cache
     *
     * @param cacheName 缓存名
     * @param key       缓存key
     * @return Object
     */
    public Object get(String cacheName, Object key) {
        Cache cache = manager.getCache(cacheName);
        if (cache != null) {
            Element element = cache.get(key);
            if (element != null) {
                return element.getObjectValue();
            }
        }
        return null;
    }

    /**
     * 添加一个Cache
     *
     * @param cacheName 缓存名
     * @param key       缓存key
     * @param value     缓存value
     */
    public void put(String cacheName, Object key, Object value) {
        Cache cache = manager.getCache(cacheName);
        if (cache != null) {
            cache.put(new Element(key, value));
        }
    }

    /**
     * 移除一个Cache
     *
     * @param cacheName 缓存名
     * @param key       缓存key
     * @return boolean
     */
    public boolean remove(String cacheName, Object key) {
        Cache cache = manager.getCache(cacheName);
        if (cache != null) {
            return cache.remove(key);
        }
        return false;
    }

}

具体使用见：https://www.cnblogs.com/sunxucool/p/3159076.html

Logo
华为开发者空间

华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。

更多推荐

cover

华为云数据仓库专业级开发者认证重磅发布

avatar 华为开发者空间
cover

一文带你搞懂GaussDB数据库性能调优

avatar 华为开发者空间
cover

KubeEdge 新版本5大特性解读：更完备的节点设备能力，全新的Dashboard体验

avatar 华为开发者空间