以下属性是可选的：
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();

        }  

}