EhCache缓存学习(转)

在看hibernate的官方文档时，看到关于缓存的介绍。

hibernate在缓存管理上做的很好，具体使用，本章不做讲解，本篇主要研究EhCache的用法。其中hibernate使用到的缓存提供商列表如下：

Cache	Provider class	Type	Cluster Safe	Query Cache Supported
Hashtable （not intended for production use）	org.hibernate.cache.HashtableCacheProvider	memory		yes
EHCache	org.hibernate.cache.EhCacheProvider	memory, disk, transactional, clustered	yes	yes
OSCache	org.hibernate.cache.OSCacheProvider	memory，disk		yes
SwarmCache	org.hibernate.cache.SwarmCacheProvider	clustered (ip multicast)	yes (clustered invalidation)
JBoss Cache 1.x	org.hibernate.cache.TreeCacheProvider	clustered (ip multicast), transactional	yes (replication)	yes (clock sync req.)
JBoss Cache 2	org.hibernate.cache.jbc.JBossCacheRegionFactory	clustered (ip multicast), transactional	yes (replication or invalidation)	yes (clock sync req.)

其中，我对EHCache比较感兴趣。看它支持的类型包括对内存，硬盘，传统，集群都支持。

我们可以单独研究一下Ehcache缓存的使用，这样方便以后我们对其他使用到缓存的地方进行缓存的自定义管理（不单单在hibernate查询数据方面）。

ehcache下载地址：   http://sourceforge.net/projects/ehcache/files/ehcache/  

先写个例子，看看它的api如何使用：

EhcacheTest

package org.base.cache.test;

import java.net.MalformedURLException;
import java.net.URL;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.config.Configuration;

/**
 * Ehcache缓存管理的api测试小例子
 * @author lushuaiyin
 *
 */
public class EhcacheTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws MalformedURLException {
		net.sf.ehcache.config.Configuration config=new Configuration();
		
		//如果不使用ehcache.xml配置文件，那么必须用代码配置一个defaultCacheConfiguration
		CacheConfiguration defaultCacheConfiguration=new CacheConfiguration();
		defaultCacheConfiguration.setMaxEntriesLocalHeap(0);
		defaultCacheConfiguration.setEternal(false);
		defaultCacheConfiguration.setTimeToIdleSeconds(30);
		defaultCacheConfiguration.setTimeToLiveSeconds(30);
		
		config.addDefaultCache(defaultCacheConfiguration);//设置默认cache
		
		net.sf.ehcache.CacheManager cacheManager=CacheManager.create(config);
		
		//创建缓存信息
		/*构造方法有多种，详见文档
		 public Cache(String name,
             int maxElementsInMemory,
             boolean overflowToDisk,
             boolean eternal,
             long timeToLiveSeconds,
             long timeToIdleSeconds)
		 */
		//自定义配置缓存
		net.sf.ehcache.Cache cache1=new Cache("mycache-one", 1000, false, false, 30, 30);
		cacheManager.addCache(cache1);
		
		//只有配置了defaultCacheConfiguration，这个方法才可以使用。因为用字符串命名的缓存必须有实际配置。
		cacheManager.addCache("mycache-two");//添加一个空缓存
		
		
		
		//往缓存中放值
		String objkey1="key1",objvalue1="value1";
		cache1.put(new Element(objkey1,objvalue1));//直接放
		
		//遍历取出某个缓存中的所有值
		if(cacheManager.getCache("mycache-one")!=null){
			Cache cache11=cacheManager.getCache("mycache-one");
			if(cache11.getKeys().size()==0){
				System.out.println("mycache-one exits,but no value.");
			}else{
				for(int i=0;i<cache11.getKeys().size();i++){
					Object thekey=cache11.getKeys().get(i);
					Object thevalue=cache11.get(thekey);
					System.out.println("mycache-one-"+i+",key:"+thekey.toString()+",value:"+thevalue.toString());
				}
			}
		}else{
			System.out.println("mycache-one-is null");
		}
		
		/*打印
mycache-one-0,key:key1,value:[ key = key1, value=value1, version=1, hitCount=1, CreationTime = 1366263629054, LastAccessTime = 1366263629054 ]

		 */
		if(cacheManager.getCache("mycache-two")!=null){
			Cache cache2=cacheManager.getCache("mycache-two");
			if(cache2.getKeys().size()==0){
				System.out.println("mycache-two exits,but no value.");
			}else{
				for(int i=0;i<cache2.getKeys().size();i++){
					Object thekey=cache2.getKeys().get(i);
					Object thevalue=cache2.get(thekey);
					System.out.println("mycache-two-"+i+",key:"+thekey.toString()+",value:"+thevalue.toString());
				}
			}
		}else{
			System.out.println("mycache-two-is null");
		}
		/*打印
mycache-two exits,but no value.
		 */
		
		
	}
	
	

}

Ehcache在使用的大多数情况，是用ehcache.xml来配置的。在spring中的集成很方便。

下面我们使用ehcache.xml，但不在web环境下，对缓存进行自定义。

org/base/cache/test/myehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd"
         updateCheck="true" monitoring="autodetect"
         dynamicConfig="true">

    
    <diskStore path="java.io.tmpdir"/>
    
    <!-- JTA事务配置。class属性若为空，则默认会按照一个顺序寻找TransactionManager对象。
              也可以自定义，需要实现接口net.sf.ehcache.transaction.manager.TransactionManagerLookup
    -->
    <!--
    <transactionManagerLookup class="net.sf.ehcache.transaction.manager.DefaultTransactionManagerLookup"
                              properties="jndiName=java:/TransactionManager" propertySeparator=";"/>
    -->

    <!-- CacheManagerEventListener  缓存监听，根据需要自定义监听类  
    <cacheManagerEventListenerFactory class="" properties=""/>
    -->
    
    <!-- Terracotta服务器集群配置，详细看文档 -->
    <!--
    <terracottaConfig url="localhost:9510"/>
    -->
    
    <defaultCache
           maxEntriesLocalHeap="0"
           eternal="false"
           timeToIdleSeconds="30"
           timeToLiveSeconds="30">
     <!-- <terracotta/>-->
    </defaultCache>

    <!--
           缓存名为myCache1,
    这个缓存最多包含10000个元素在内存中，并将
    闲置超过5分钟和存在超过10分钟的元素释放。
    如果超过10000元素，将溢流到磁盘缓存，并且硬盘缓存最大数量是1000.
           硬盘路径是定义的java.io.tmp。
    -->
    <cache name="myCache1"
           maxEntriesLocalHeap="500"
           maxEntriesLocalDisk="1000"
           eternal="false"
           diskSpoolBufferSizeMB="20"
           timeToIdleSeconds="300"
           timeToLiveSeconds="600"
           memoryStoreEvictionPolicy="LFU"
           transactionalMode="off">
        <persistence strategy="localTempSwap"/>
    </cache>


    <!--
            缓存名为sampleCache2。
    此缓存在内存中最大元素的数量是1000。
            没有设置溢出到磁盘，所以1000就是这个缓存的最大值。
            注意，当一个缓存eternal设置成true，那么TimeToLive
    和timeToIdle江不起作用。
    
    <cache name="sampleCache2"
           maxEntriesLocalHeap="1000"
           eternal="true"
           memoryStoreEvictionPolicy="FIFO"/>
-->

    <!-- 
           缓存名为sampleCache3的。
           这个缓存溢出会到磁盘。磁盘缓存存储在虚拟机重新启动前会持久有效。
           磁盘的终止线程的时间间隔设置为3分钟，覆盖默认的2分钟。
     
    <cache name="sampleCache3"
           maxEntriesLocalHeap="500"
           eternal="false"
           overflowToDisk="true"
           diskPersistent="true"
           timeToIdleSeconds="300"
           timeToLiveSeconds="600"
           diskExpiryThreadIntervalSeconds="180"
           memoryStoreEvictionPolicy="LFU">
    </cache>
-->
    <!-- 
    Terracotta集群缓存sampleTerracottaCache。
     
    <cache name="sampleTerracottaCache"
           maxBytesLocalHeap="10m"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="1800">
        <terracotta/>
    </cache>
-->
    

    
</ehcache>

关于配置的属性的含义，可以到官网的文档中查看，这里给出一些常用的属性。

    Cache的以下属性是必须的。

    name:
    cache的唯一标识。

    maxEntriesLocalHeap:
    在内存创建对象的最大数量。0=无限制。
    无限制实际指Integer.MAX_SIZE (2147483647)。

    maxEntriesLocalDisk:
    设置在硬盘上存储的对象的最大数量。默认0，即无限制。

    eternal:
    设置元素是否持久化。如果是，元素不会过期。









    Cache的以下属性是可选的。

    overflowToOffHeap:
    此功能仅在企业版的Ehcache。
    当设置为true，可利用无限制的离堆内存的缓存
    存储，以提高性能。离堆内存是不受Java
    GC限制的。默认值是false。

    maxBytesLocalHeap:
    定义多少字节缓存可能会使用虚拟机的堆。如果一个CacheManager的
    maxBytesLocalHeap已经被定义，这个缓存的指定金额将
    减去从CacheManager的。其他的高速缓存将分享剩下的人。
    此属性的值是<数字> K | K |米| M| G| G
    千字节（K| K），兆字节（M| M）或千兆字节（G| G）。
    例如，maxBytesLocalHeap的“2G”下发2 GB的堆内存。
    如果您指定一个maxBytesLocalHeap，就不能再使用属性maxEntriesLocalHeap。

    maxBytesLocalOffHeap:
    此功能仅在企业版的Ehcache。
    离堆内存量，可以使用这个缓存设置，将保留。
    此设置将设置overflowToOffHeap为true 。设置explicitly为false来禁用溢出行为。
    需要注意的是使用时离堆，设置maxEntriesLocalHeap建议至少100个元素，
    否则性能会出现严重退化，并提出警告。
    可分配的最低金额为128MB。没有最大值。



    maxBytesLocalDisk:
    As for maxBytesLocalHeap, but specifies the limit of disk storage this cache will ever use.

    timeToIdleSeconds:
    设置元素闲置时长。单位：秒。(在eternal设置成false的情况下有效)
    可选属性。值为0意味着元素可以闲置无穷。
    默认值是0。

    timeToLiveSeconds:
    设置元素过期时长。单位：秒。(在eternal设置成false的情况下有效)
    可选属性。值为0意味着，元素可以住无穷。
    默认值是0。

    diskExpiryThreadIntervalSeconds:
    磁盘到期线程运行之间的秒数。默认值为120秒。

    diskSpoolBufferSizeMB:
    这是分配硬盘存储的缓冲区的大小。信息被写入
    这个区域，然后异步写入到磁盘中。默认大小为30MB。
    每个缓冲区仅用于由其缓存。如果你遇到内存溢出错误试着
    降低此值。为了提高硬盘存储性能应考虑增加此值。

    clearOnFlush:
    调用flush（）方法时，硬盘存储缓存被清除。
    默认值是true。

    memoryStoreEvictionPolicy:
    内存管理策略，默认是最近最少使用策略（即Least Recently Used，LRU）。
    其他可选的有先进先出策略（即 First In First Out，FIFO），最少使用频率策略
    （即Less Frequently Used，LFU）。

    copyOnRead:
    一个元素被复制时是否从缓存中读取。
    默认false。

    copyOnWrite:
    一个元素被添加到缓存中时是否被复制。
    默认false。

EhcacheManagerTest

package org.base.cache.test;

import java.net.URL;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.Status;

/**
 * Ehcache缓存管理的初步学习实例
 * @author lushuaiyin
 *
 */
public class EhcacheManagerTest {
	public static net.sf.ehcache.CacheManager cacheManager = null;
	private static String configPath="org/base/cache/test/myehcache.xml";//配置文件路径,一般会放在源文件夹
	
	private static String CACHE_MYCACHE1="myCache1";//定义文件中配置的缓存
	//实例化cacheManager，单例模式
	public static CacheManager getCacheManagerInstance(){
		if (cacheManager == null) {
			URL configUrl=null;
			configUrl = EhcacheManagerTest.class.getClassLoader().getResource(configPath);
			cacheManager = CacheManager.create(configUrl);
		}
		return cacheManager;
	}
	public static net.sf.ehcache.CacheManager getCacheManager() {
		return getCacheManagerInstance();//单例缓存管理
	}
	//这个set可以不开放
	public static void setCacheManager(net.sf.ehcache.CacheManager cacheManager) {
		EhcacheManagerTest.cacheManager = cacheManager;
	}
	
	//添加新缓存
	public static void addCacheByName(String cacheName){
		if(cacheName==null||cacheName.trim().equals("")){
			System.out.println("cacheName is null");
		}else{
			if(getCacheManager().getCache(cacheName.trim())!=null){
				getCacheManager().removeCache(cacheName.trim());
			}
			getCacheManager().addCache(cacheName.trim());
			System.out.println(cacheName+ "重新添加");
		}
	}
	//得到cache对象
	public static Cache getCacheByName(String cacheName){
		Cache cache=null;
		if(cacheName==null||cacheName.trim().equals("")){
			System.out.println("cacheName is null");
		}else{
			if(getCacheManager().getCache(cacheName.trim())!=null){
				cache=getCacheManager().getCache(cacheName.trim());
			}
		}
		
		return cache;
	}
	
	
	//往缓存中添加元素
	public static void putElementToCache(String cacheName,String elementKey,Object elementValue){
		Cache cache=null;
		if(cacheName==null||cacheName.trim().equals("")){
			System.out.println("添加缓存元素失败，cacheName is null");
		}else if(elementKey==null||elementValue==null){
			System.out.println("添加缓存元素失败，elementKey or elementValue is null");
		}else{
			if(getCacheByName(cacheName.trim())!=null){//缓存存在
				cache=getCacheByName(cacheName.trim());
			}else{//缓存不存在
				addCacheByName(cacheName.trim());
				cache=getCacheByName(cacheName.trim());
			}
			//对cache对象添加Element
			Element element=null;
			if(cache.get(elementKey.trim())!=null){
				cache.remove(elementKey.trim());
			}
			element=new Element(elementKey.trim(),elementValue);
			cache.put(element);
			System.out.println("添加缓存元素:"+elementKey+"成功！");
		}
		
	}
	
	//从缓存中获取指定key的值
	public static Object getElementValueFromCache(String cacheName,String elementKey){
		Object result=null;
		Cache cache=null;
		if(cacheName==null||cacheName.trim().equals("")){
			System.out.println("获取缓存元素失败，cacheName is null");
		}else if(elementKey==null){
			System.out.println("获取缓存元素失败，elementKey  is null");
		}else{
			if(getCacheByName(cacheName.trim())!=null){//缓存存在
				cache=getCacheByName(cacheName.trim());
				
				Element element=null;
				if(cache.get(elementKey.trim())!=null){
					element=cache.get(elementKey.trim());
					if(element.getObjectValue()==null){
						System.out.println("缓存中"+elementKey+" 的值为空.");
					}else{
						result=element.getObjectValue();
					}
				}else{
					System.out.println("缓存中"+elementKey+" 的Element值为空.");
				}
			}else{//缓存不存在
				System.out.println("获取缓存元素失败，缓存"+cacheName+" 为空.");
			}
		}
		
		return result;
	}
	
	/**
	 * 把所有cache中的内容删除，但是cache对象还是保留.
	 * Clears the contents of all caches in the CacheManager,
	 *  but without removing any caches.
	 */
	public static void clearAllFromCacheManager(){
		if(getCacheManager()!=null){
			getCacheManager().clearAll();
			System.out.println("CacheManager was clearAll...");
		}
	} 
	
	/**
	 * 把所有cache对象都删除。慎用！
	 * Removes all caches using removeCache(String) for each cache.
	 */
	public static void removalAllFromCacheManager(){
		if(getCacheManager()!=null){
			getCacheManager().removalAll();
			System.out.println("CacheManager was removalAll...");
		}
	} 
	//不用缓存时，要关闭，不然会占用cpu和内存资源。
	public static void shutdownCacheManager(){
		if(getCacheManager()!=null){
			getCacheManager().shutdown();
			System.out.println("CacheManager was shutdown...");
		}
	}
	
	
	//打印方法1，为了测试用
	public static void printCache(Cache cache){
		System.out.println("缓存状态： "+cache.getStatus().toString());
		if(cache==null){
			System.out.println("cache is null,no print info.");
		}else if(cache.getStatus().toString().equals(Status.STATUS_UNINITIALISED)){
			System.out.println("缓存状态： 未初始化"+cache.getStatus().toString());
		}else if(cache.getStatus().toString().equals(Status.STATUS_SHUTDOWN)){
			System.out.println("缓存状态： 已关闭"+cache.getStatus().toString());
		}else if(cache.getStatus().toString().equals(Status.STATUS_ALIVE)){
			if(cache.getKeys().size()==0){
				System.out.println(cache.getName()+" exits,but no value.");
			}else{
				for(int i=0;i<cache.getKeys().size();i++){
					Object thekey=cache.getKeys().get(i);
					Object thevalue=cache.get(thekey);
					System.out.println(cache.getName()+"--"+i+",key:"+thekey.toString()+",value:"+thevalue.toString());
				}
			}
		}
		
		
	}
	
	//打印方法2，为了测试用
	public static void printCacheByName(String cacheName){
		if(cacheName==null||cacheName.trim().equals("")){
			System.out.println("cacheName is null,no print info.");
		}else{
			if(getCacheManager().getCache(cacheName.trim())!=null){
				Cache cache=getCacheManager().getCache(cacheName.trim());
				printCache(cache);
			}else{
				System.out.println(cacheName+" --null");
			}
		}
		
		
	}
	
	public static void main(String[] sdfsf){
		Cache cache1=EhcacheManagerTest.getCacheByName(EhcacheManagerTest.CACHE_MYCACHE1);
		printCache(cache1);
		
		EhcacheManagerTest.putElementToCache(EhcacheManagerTest.CACHE_MYCACHE1, "111", "111haah");
		EhcacheManagerTest.putElementToCache(EhcacheManagerTest.CACHE_MYCACHE1, "222", "222haah");
		EhcacheManagerTest.putElementToCache(EhcacheManagerTest.CACHE_MYCACHE1, "333", "333haah");
		
		printCache(cache1);
		
		EhcacheManagerTest.putElementToCache(EhcacheManagerTest.CACHE_MYCACHE1, "111", "111的新值。");
		
		System.out.println(EhcacheManagerTest.getElementValueFromCache(EhcacheManagerTest.CACHE_MYCACHE1, "111"));
		printCache(cache1);
		
		clearAllFromCacheManager();
		printCache(cache1);
		
		removalAllFromCacheManager();
		printCache(cache1);
		
		shutdownCacheManager();
	}
	/*打印
缓存状态： STATUS_ALIVE
添加缓存元素:111成功！
添加缓存元素:222成功！
添加缓存元素:333成功！
缓存状态： STATUS_ALIVE
添加缓存元素:111成功！
111的新值。
缓存状态： STATUS_ALIVE
CacheManager was clearAll...
缓存状态： STATUS_ALIVE
CacheManager was removalAll...
缓存状态： STATUS_SHUTDOWN
CacheManager was shutdown...

	 */
}

通过上面的使用，我们初步了解Ehcache的api。在web环境下，我们可以注入EhcacheManager对象，

把需要的数据，放入缓存。在其他地方取数据的时候，就从过EhcacheManager来获取，而不是直接

从数据库查询。这样就提高了效率。

值得注意的是，缓存的使用一般在一些数据比较固定的地方。如果某个查询需要保证数据的实时性，使用缓存

就是错误的做法。