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

评论

2 楼 jiangm520 2011-08-12  

你自己可以看api 测试哈嘛

1 楼 java_pad 2011-07-28  

cache.getHitCount();
cache.getMemoryStoreHitCount();  
以及一下的方法都没有了么?