开源缓存包 EHCache 全接触

EHCache 是一个纯java的，在Hibernate2.1充当可插入的的在进程中的缓存，它具有以下缓存，最小的依赖性，全面的文特性：快速，简单，丰富的文档和测试用例。

    官方网站 http://ehcache.sourceforge.net/

－－－－－－－－－－－－－－－－－－－－－－－－－－
－－－－－－－－－－使用简介－－－－－－－－－－－－
－－－－－－－－－－－－－－－－－－－－－－－－－－
    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.');
        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();
        }


    添加和删除缓存元素

        设置一个名为test 的新cache,test属性为默认
        CacheManager singletonManager = CacheManager.create();
        singletonManager.addCache('testCache');
        Cache test = singletonManager.getCache('testCache');

        设置一个名为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 属性说明：

            构造函数：
            public Cache(java.lang.String name,
                         int maxElementsInMemory,
                         boolean overflowToDisk,
                         boolean eternal,
                         long timeToLiveSeconds,
                         long timeToIdleSeconds)

            参数说明：
            name                          - 元素名字。
                maxElementsInMemory           - 设定内存中创建对象的最大值。
                overflowToDisk                - 设置当内存中缓存达到 maxInMemory 限制时元素是否可写到磁盘
                                                       上。
                eternal                       - 设置元素（译注：内存中对象）是否永久驻留。如果是，将忽略超
                                                      时限制且元素永不消亡。
                timeToIdleSeconds             - 设置某个元素消亡前的停顿时间。
                                                      也就是在一个元素消亡之前，两次访问时间的最大时间间隔值。
                                                      这只能在元素不是永久驻留时有效（译注：如果对象永恒不灭，则
                                                      设置该属性也无用）。
                                                      如果该值是 0 就意味着元素可以停顿无穷长的时间。
                timeToLiveSeconds             - 为元素设置消亡前的生存时间。
                                                       也就是一个元素从构建到消亡的最大时间间隔值。
                                                       这只能在元素不是永久驻留时有效。

        删除缓存元素：
        CacheManager singletonManager = CacheManager.create();
        singletonManager.removeCache('test');


    关闭缓存管理器 CacheManager
       
        CacheManager.getInstance().shutdown();


    对于缓存对象的操作：
        放入一个简单的对象到缓存元素；
        Cache cache = manager.getCache('sampleCache1');
        Element element = new Element('key1', 'value1');
        cache.put(element);

        得到一个序列化后的对象属性值；
        Cache cache = manager.getCache('sampleCache1');
        Element element = cache.get('key1');
        Serializable value = element.getValue();

        得到一个没有序列化后的对象属性值；
        Cache cache = manager.getCache('sampleCache1');
        Element element = cache.get('key1');
        Object value = element.getObjectValue();
       
        删除一个对象从元素；
        Cache cache = manager.getCache('sampleCache1');
        Element element = new Element('key1', 'value1'
        cache.remove('key1');

    对于永固性磁盘存储，立即存储到磁盘：

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


    获得缓存大小：
        得到缓存的对象数量；
        Cache cache = manager.getCache('sampleCache1');
        int elementsInMemory = cache.getSize();

        得到缓存对象占用内存的数量
        Cache cache = manager.getCache('sampleCache1');
        long elementsInMemory = cache.getMemoryStoreSize();

        得到缓存对对象占用磁盘的数量
        Cache cache = manager.getCache('sampleCache1');
        long elementsInMemory = cache.getDiskStoreSize();

    关于缓存的读取和丢失的记录
        得到缓存读取的命中次数；
        Cache cache = manager.getCache('sampleCache1');
        int hits = cache.getHitCount();
       
        得到内存中缓存读取的命中次数；
        Cache cache = manager.getCache('sampleCache1');
        int hits = cache.getMemoryStoreHitCount();

        得到磁盘中缓存读取的命中次数；
        Cache cache = manager.getCache('sampleCache1');
        int hits = cache.getDiskStoreCount();
       
        得到缓存读取的丢失次数；
        Cache cache = manager.getCache('sampleCache1');
        int hits = cache.getMissCountNotFound();

        得到缓存读取的已经被销毁的对象丢失次数；
        Cache cache = manager.getCache('sampleCache1');
        int hits = cache.getMissCountExpired();

－－－－－－－－－－－－－－－－－－－－－－－－－－
－－－－－－－－－－简单例子－－－－－－－－－－－－
－－－－－－－－－－－－－－－－－－－－－－－－－－

    实战：
        XML文件格式:

           

               

                                         maxElementsInMemory='10000'
                        eternal='false'
                        timeToIdleSeconds='120'
                        timeToLiveSeconds='120'
                        overflowToDisk='true'
                        diskPersistent='false'
                        diskExpiryThreadIntervalSeconds='120'
                        memoryStoreEvictionPolicy='LRU'
                        />
                                    maxElementsInMemory='10000'
                       eternal='false'
                       overflowToDisk='true'
                       timeToIdleSeconds='2'
                       timeToLiveSeconds='3'
                       memoryStoreEvictionPolicy='LFU'
                        />
                       
           

    源码：

        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                    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('得到缓存的对象数量：'+elementsInMemory);
               
                long elementsInMemory1 = cache.getMemoryStoreSize();
                System.out.println('得到缓存对象占用内存的数量：'+elementsInMemory1);
               
                long elementsInMemory2 = cache.getDiskStoreSize();
                System.out.println('得到缓存对对象占用磁盘的数量：'+elementsInMemory2);       
               
                int hits = cache.getHitCount();
                System.out.println('得到缓存读取的命中次数：'+hits);       
               
                int hits1 = cache.getMemoryStoreHitCount();
                System.out.println('得到内存中缓存读取的命中次数：'+hits1);       
               
                int hits2 =cache.getDiskStoreHitCount();
                System.out.println('得到磁盘中缓存读取的命中次数：'+hits2);       
               
                int hits3 = cache.getMissCountNotFound();
                System.out.println('得到缓存读取的丢失次数：'+hits3);       
               
                int hits4 = cache.getMissCountExpired();
                System.out.println('得到缓存读取的已经被销毁的对象丢失次数：'+hits4);   
            }

        }