原文地址：http://www.uusam.com/uu/blog/article.asp?id=60

EHCache 是一個(gè)純java的，在Hibernate2.1充當(dāng)可插入的的在進(jìn)程中的緩存，它具有以下緩存，最小的依賴性，全面的文特性：快速，簡(jiǎn)單，豐富的文檔和測(cè)試用例。

    官方網(wǎng)站 http://ehcache.sourceforge.net/

－－－－－－－－－－－－－－－－－－－－－－－－－－
－－－－－－－－－－使用簡(jiǎn)介－－－－－－－－－－－－
－－－－－－－－－－－－－－－－－－－－－－－－－－
    ehcache-1.2 cacheNames 列表的取得；

    方法一：
        CacheManager.create();
        String[] cacheNames = CacheManager.getInstance().getCacheNames();

    方法二：
        CacheManager manager = new CacheManager();
        String[] cacheNames = manager.getCacheNames();

    方法三：
        CacheManager manager1 = new CacheManager("src/config/ehcache1.xml");
        CacheManager manager2 = new CacheManager("src/config/ehcache2.xml");
        String[] cacheNamesForManager1 = manager1.getCacheNames();
        String[] cacheNamesForManager2 = manager2.getCacheNames();


    ehcache-1.2 管理器各種建立的方法：

    方法一：
         CacheManager manager = new CacheManager();

    方法二：
        CacheManager manager = new CacheManager("src/config/ehcache.xml");

    方法三：
        URL url = getClass().getResource("/anotherconfigurationname.xml");
        CacheManager manager = new CacheManager(url);

    方法四：
        InputStream fis = new FileInputStream(new File("src/config/ehcache.xml").getAbsolutePath());
        try {
            CacheManager manager = new CacheManager(fis);
        } finally {
            fis.close();
        }


    添加和刪除緩存元素

        設(shè)置一個(gè)名為test 的新cache,test屬性為默認(rèn)
        CacheManager singletonManager = CacheManager.create();
        singletonManager.addCache("testCache");
        Cache test = singletonManager.getCache("testCache");

        設(shè)置一個(gè)名為test 的新cache,并定義其屬性
        CacheManager singletonManager = CacheManager.create();
        Cache memoryOnlyCache = new Cache("testCache", 5000, false, false, 5, 2);
        manager.addCache(memoryOnlyCache);
        Cache test = singletonManager.getCache("testCache");
        
        Cache 屬性說(shuō)明：

            構(gòu)造函數(shù)：
            public Cache(java.lang.String name,
                         int maxElementsInMemory,
                         boolean overflowToDisk,
                         boolean eternal,
                         long timeToLiveSeconds,
                         long timeToIdleSeconds)

            參數(shù)說(shuō)明：
            name                          - 元素名字。
                maxElementsInMemory           - 設(shè)定內(nèi)存中創(chuàng)建對(duì)象的最大值。
                overflowToDisk                - 設(shè)置當(dāng)內(nèi)存中緩存達(dá)到 maxInMemory 限制時(shí)元素是否可寫到磁盤
                                                       上。
                eternal                       - 設(shè)置元素（譯注：內(nèi)存中對(duì)象）是否永久駐留。如果是，將忽略超
                                                      時(shí)限制且元素永不消亡。
                timeToIdleSeconds             - 設(shè)置某個(gè)元素消亡前的停頓時(shí)間。
                                                      也就是在一個(gè)元素消亡之前，兩次訪問(wèn)時(shí)間的最大時(shí)間間隔值。
                                                      這只能在元素不是永久駐留時(shí)有效（譯注：如果對(duì)象永恒不滅，則
                                                      設(shè)置該屬性也無(wú)用）。
                                                      如果該值是 0 就意味著元素可以停頓無(wú)窮長(zhǎng)的時(shí)間。
                timeToLiveSeconds             - 為元素設(shè)置消亡前的生存時(shí)間。
                                                       也就是一個(gè)元素從構(gòu)建到消亡的最大時(shí)間間隔值。
                                                       這只能在元素不是永久駐留時(shí)有效。

        刪除緩存元素：
        CacheManager singletonManager = CacheManager.create();
        singletonManager.removeCache("test");


    關(guān)閉緩存管理器 CacheManager
        
        CacheManager.getInstance().shutdown();


    對(duì)于緩存對(duì)象的操作：
        放入一個(gè)簡(jiǎn)單的對(duì)象到緩存元素；
        Cache cache = manager.getCache("sampleCache1");
        Element element = new Element("key1", "value1");
        cache.put(element);

        得到一個(gè)序列化后的對(duì)象屬性值；
        Cache cache = manager.getCache("sampleCache1");
        Element element = cache.get("key1");
        Serializable value = element.getValue();

        得到一個(gè)沒(méi)有序列化后的對(duì)象屬性值；
        Cache cache = manager.getCache("sampleCache1");
        Element element = cache.get("key1");
        Object value = element.getObjectValue();
        
        刪除一個(gè)對(duì)象從元素；
        Cache cache = manager.getCache("sampleCache1");
        Element element = new Element("key1", "value1"
        cache.remove("key1");

    對(duì)于永固性磁盤存儲(chǔ)，立即存儲(chǔ)到磁盤：

        Cache cache = manager.getCache("sampleCache1");
        cache.flush();


    獲得緩存大小：
        得到緩存的對(duì)象數(shù)量；
        Cache cache = manager.getCache("sampleCache1");
        int elementsInMemory = cache.getSize();

        得到緩存對(duì)象占用內(nèi)存的數(shù)量
        Cache cache = manager.getCache("sampleCache1");
        long elementsInMemory = cache.getMemoryStoreSize();

        得到緩存對(duì)對(duì)象占用磁盤的數(shù)量
        Cache cache = manager.getCache("sampleCache1");
        long elementsInMemory = cache.getDiskStoreSize();

    關(guān)于緩存的讀取和丟失的記錄
        得到緩存讀取的命中次數(shù)；
        Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getHitCount();
        
        得到內(nèi)存中緩存讀取的命中次數(shù)；
        Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getMemoryStoreHitCount();

        得到磁盤中緩存讀取的命中次數(shù)；
        Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getDiskStoreCount();
        
        得到緩存讀取的丟失次數(shù)；
        Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getMissCountNotFound();

        得到緩存讀取的已經(jīng)被銷毀的對(duì)象丟失次數(shù)；
        Cache cache = manager.getCache("sampleCache1");
        int hits = cache.getMissCountExpired();

－－－－－－－－－－－－－－－－－－－－－－－－－－
－－－－－－－－－－簡(jiǎn)單例子－－－－－－－－－－－－
－－－－－－－－－－－－－－－－－－－－－－－－－－

    實(shí)戰(zhàn)：
        XML文件格式:

            <ehcache>

                <diskStore path="java.io.tmpdir"/>

                <defaultCache
                        maxElementsInMemory="10000"
                        eternal="false"
                        timeToIdleSeconds="120"
                        timeToLiveSeconds="120"
                        overflowToDisk="true"
                        diskPersistent="false"
                        diskExpiryThreadIntervalSeconds="120"
                        memoryStoreEvictionPolicy="LRU"
                        />

                <cache name="cache1"
                       maxElementsInMemory="10000"
                       eternal="false"
                       overflowToDisk="true"
                       timeToIdleSeconds="2"
                       timeToLiveSeconds="3"
                       memoryStoreEvictionPolicy="LFU"
                        />
                        
            </ehcache>

    源碼：

        import java.io.Serializable;

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

        /**
         #############################################################################
         # DESCRIBE ehcache 緩存操作DEMO
         # AUTHOR   悠～游
         # DATE     2006-7-10
         # COMPANY  FLX
         # PORJECT  ehcache-demo
         #############################################################################
         */

        public class Demo {
            
            static CacheManager manager= new CacheManager();

            /**
             *##############################################################################
             *
             * @DESCRIBE    
             * @param args
             * @throws InterruptedException
             *                        
             *##############################################################################
             */
            public static void main(String[] args) throws InterruptedException {
                
                String[] cacheNames = manager.getCacheNames();
                System.out.println("讀取的緩存列表為：");
                for(int i=0;i<cacheNames.length;i++){
                    System.out.println("-- "+(i+1)+" "+cacheNames[i]);
                }
                
                Cache cache = manager.getCache("cache1");
                Element element = new Element("key1", "value1");
                cache.put(element);
                
                element = cache.get("key1");
                Serializable value = element.getValue();
                System.out.println("序列化后的值為："+value.toString());

                element = cache.get("key1");
                Object value1 = element.getObjectValue();
                System.out.println("未序列化的值為："+value1.toString());
                
                int elementsInMemory = cache.getSize();
                System.out.println("得到緩存的對(duì)象數(shù)量："+elementsInMemory);
                
                long elementsInMemory1 = cache.getMemoryStoreSize();
                System.out.println("得到緩存對(duì)象占用內(nèi)存的數(shù)量："+elementsInMemory1);
                
                long elementsInMemory2 = cache.getDiskStoreSize();
                System.out.println("得到緩存對(duì)對(duì)象占用磁盤的數(shù)量："+elementsInMemory2);        
                
                int hits = cache.getHitCount();
                System.out.println("得到緩存讀取的命中次數(shù)："+hits);        
                
                int hits1 = cache.getMemoryStoreHitCount();
                System.out.println("得到內(nèi)存中緩存讀取的命中次數(shù)："+hits1);        
                
                int hits2 =cache.getDiskStoreHitCount();
                System.out.println("得到磁盤中緩存讀取的命中次數(shù)："+hits2);        
                
                int hits3 = cache.getMissCountNotFound();
                System.out.println("得到緩存讀取的丟失次數(shù)："+hits3);        
                
                int hits4 = cache.getMissCountExpired();
                System.out.println("得到緩存讀取的已經(jīng)被銷毀的對(duì)象丟失次數(shù)："+hits4);    
            }

        }