【Java】：ehcache

      ehcache是一个纯Java进程内缓存框架，是hibernate默认的Cacheprovider。（出自百度百科）。

      1. 快速2. 简单3. 多种缓存策略4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题5. 缓存数据会在虚拟机重启的过程中写入磁盘6. 可以通过RMI、可插入API等方式进行分布式缓存7. 具有缓存和缓存管理器的侦听接口8. 支持多缓存管理器实例，以及一个实例的多个缓存区域9. 提供Hibernate的缓存实现

    

      ⑴、简单代码实现：

            配置文件2个ehcache.xml 、ehcache.xsd       

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd"
         updateCheck="true" monitoring="autodetect"
         dynamicConfig="true">
    <diskStore path="d:/file"/>
 <cache name="ehcache1"   
    maxElementsInMemory="100"   
    maxElementsOnDisk="0"
    eternal="false"   
    timeToIdleSeconds="300000"   
    timeToLiveSeconds="300000"   
    diskPersistent="true" 
    overflowToDisk="true"  
    />  

</ehcache>
View Code

            demo调用：

这种调用方式若属性配置了虚拟机重启缓存数据将会报错：

package com.jws.app.junt;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
/**
 * ehcache框架测试
 * @author Administrator
 *
 */
public class ehcacheDemo {
    public static void main(String[] args) {
            //CacheManager manager1 = CacheManager.newInstance("src/config/ehcache1.xml"); 
            CacheManager manager = CacheManager.create();
            Cache cache = manager.getCache("ehcache1");
            // manager.addCache("ehcache2");
             //Cache test = manager.getCache("ehcache2");
            cache.put(new Element("key1", "values1"));
            cache.put(new Element("key2", "values2"));
            cache.put(new Element("key3", "values3"));
            Element element = cache.get("key1");
            System.out.println(element.getValue());
            cache.flush();
    }

}
View Code

          

 　　　　配置文件详解：

            maxElementsInMemory：    内存中允许缓存的最大数量，若超过这个数量，数据将缓存在磁盘。

            maxElementsOnDisk：   硬盘中缓存的最大数量，0表示无限大。

 　　　　eternal： 对象是否永久有效，一但设置了，timeout将不起作用。

　　　　timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。

　　　　timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。

　　　　overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。

　　　　diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。

　　　　maxElementsOnDisk：硬盘最大缓存个数。

　　　　diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.

　　　　diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
      　  memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
          clearOnFlush：内存数量最大时是否清除。

　　　　

以下属性是可选的：
timeToIdleSeconds： 对象空闲时间，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0，表示一直可以访问。
timeToLiveSeconds： 对象存活时间，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0，表示一直可以访问。
diskPersistent： 是否在磁盘上持久化。指重启jvm后，数据是否有效。默认为false。
diskExpiryThreadIntervalSeconds： 对象检测线程运行时间间隔。标识对象状态的线程多长时间运行一次。
diskSpoolBufferSizeMB： DiskStore使用的磁盘大小，默认值30MB。每个cache使用各自的DiskStore。
memoryStoreEvictionPolicy： 如果内存中数据超过内存限制，向磁盘缓存时的策略。默认值LRU，可选FIFO、LFU。
 
缓存的3 种清空策略 ：
FIFO ，first in first out (先进先出).
LFU ， Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存。
LRU ，Least Recently Used(最近最少使用). (ehcache 默认值).缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

           

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="http://ehcache.sf.net/ehcache.xsd">

    <diskStore path="d:/file" />

    <defaultCache 
        maxElementsInMemory="10000" 
        eternal="false"
        overflowToDisk="true" 
        timeToIdleSeconds="10" 
        timeToLiveSeconds="20"
        diskPersistent="false" />

    

    <cache name="requestCache" 
        maxElementsInMemory="100000" 
        eternal="false"
        overflowToDisk="false" 
        timeToIdleSeconds="180" 
        timeToLiveSeconds="180"
        diskPersistent="false" 
        memoryStoreEvictionPolicy="LFU" />
    
    
    <cache name="myCache" 
        maxElementsInMemory="2" 
        eternal="false"
        overflowToDisk="true" 
        timeToIdleSeconds="180" 
        timeToLiveSeconds="180"
        maxElementsOnDisk="0"
        diskPersistent="true" 
        memoryStoreEvictionPolicy="LFU" />
</ehcache>
package com.jws.app.junt;

import java.util.List;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
/**
 * ehcache框架测试
 * @author Administrator
 *
 */
public class ehcacheDemo {
     public static void main(String[] args) {
            // 指定ehcache.xml的位置
            String fileName = "src/main/resources/ehcache.xml";
            CacheManager manager = new CacheManager(fileName);
            // 取出所有的cacheName
            Cache cache = manager.getCache("myCache");
            System.out.println(cache.getSize());
            //获取单个节点
            Element el =  cache.get("key1812");
            System.out.println("【单个节点】"+el.getValue());
            el  =  cache.get(1);
            //System.out.println("【单个节点2】"+el.getValue());
             List<Element> cl = cache.getKeys();
           //  cl.size();
            
//       
//        for(int i=0;i<1000;i++){
//                cache.put(new Element("key1"+ i , "values1"+i));
//            }
//            
            
//            cache.flush();
            
            manager.shutdown();
        }
}
package com.jws.common.util;

import java.util.List;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

/**
 * ＥＨｃａｃｈｅ工具类　
 * @author Administrator
 *
 */
public class EHCacheConfig {
        
        /**
         * 当前采用的缓存对象
         */
        public static String cacheObject = "myCache";
        private static CacheManager cacheManager = null;  
        private static Cache cache = null;  
        
         
        static{  
            EHCacheConfig.initCacheManager();  
            EHCacheConfig.initCache();
        }  
        
           /** 
         *  
         * 初始化缓存管理容器 
         */  
        public static CacheManager initCacheManager() {  
            try {  
                if (cacheManager == null)  
                    System.out.println("【EHcache start............】");
                    cacheManager = CacheManager.getInstance();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return cacheManager;  
        }  
        
        
        
        
        /**
         * 初始化cache
         * @return
         */
        public static Cache initCache() {  
            if(cache ==null){
                  cache = cacheManager.getCache("myCache");
                    System.out.println("【EHcache cache start............】");
            }
            return cache;
        }
        /** 
         *  
         * 添加缓存 
         *  
         * @param key 
         *            关键字 
         * @param value 
         *            值 
         */  
        public static void put(Object key, Object value) {  
            // 创建Element,然后放入Cache对象中  
            Element element = new Element(key, value);  
            cache.put(element);  
        }  
      
        /** 
         * 获取cache 
         *  
         * @param key 
         *            关键字 
         * @return 
         */  
        public static Object get(Object key) {  
            Element element = cache.get(key);  
            if (null == element) {  
                return null;  
            }  
            return element.getObjectValue();  
        }  
        /** 
         * 移除所有cache 
         */  
        
        /** 
         * 释放CacheManage 
         */  
      
        public static void shutdown() {  
            cacheManager.shutdown();  
        }  
      
        public static void removeAllCache() {  
            cacheManager.removalAll();  
        }  
        /** 
         *  
         * 移除所有Element 
         */  
        public static void removeAllKey() {  
            cache.removeAll();  
        }  
        /** 
         *  
         * 获取所有的cache名称 
         * @return 
         */  
        public static String[] getAllCaches() {  
            return cacheManager.getCacheNames();  
        }  
        /** 
         *  
         * 获取Cache所有的Keys 
         * @return 
         */  
        public static List<Element> getKeys() {  
            return cache.getKeys();  
        }  
        
    
}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/kimobolo/p/5254315.html