EhCache缓存学习(转)

最新推荐文章于 2023-07-21 18:32:04 发布

weixin_33895516

最新推荐文章于 2023-07-21 18:32:04 发布

阅读量62

点赞数

文章标签： java 运维数据库

在看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来获取，而不是直接

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

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

就是错误的做法。

weixin_33895516

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
EhCache缓存学习(转)

在看hibernate的官方文档时，看到关于缓存的介绍。hibernate在缓存管理上做的很好，具体使用，本章不做讲解，本篇主要研究EhCache的用法。其中hibernate使用到的缓存提供商列表如下： CacheProvider classTypeCluster SafeQuery Cache SupportedHashtable （not inte...
复制链接

扫一扫