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);
     }