java架构搭建（八）--EhCache缓存在web下的使用实例

本是古典何须时尚 2022-03-01 04:40 199阅读 0赞

以前对EhCache做过api的学习与测试，api就不多讲了，这次把在web下如何使用EhCache以及出现的问题说一下。

同时这篇还写了EhCache的监听。

在web下使用缓存，就是把常用的变动很少的数据放入缓存提高查询效率。如果需要查看实时的数据，需要把缓存清空再查询。

比如有一张字典表，定义了整个工程使用到了配置信息，这个基本上是不变的，所以可以用缓存来提高查询效率。

Dictionary，值得注意的是要实现Serializable接口，因为缓存可能要往硬盘写对象。

package org.base.common.dictionary.bean;
    
    import java.io.Serializable;
    import java.util.Date;
    
    /**
     * 公用的字典表对象
     * @author lushuaiyin
     *
     */
    public class Dictionary  implements Serializable{
    	/**
    	 * 需要implements Serializable，因为ehcache需要往硬盘写对象
    	 */
    	private static final long serialVersionUID = 1L;
    	
    	private String id;
    	private String code_no;
    	private String code_name;
    	private String code_parent_no;
    	private int show_order;
    	private Date create_time;
    	private String remark;
    	private String create_user;
    	private String valid;
    	private String bak1;
    	private String bak2;
    	private String bak3;
    	
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public String getCode_no() {
    		return code_no;
    	}
    	public void setCode_no(String code_no) {
    		this.code_no = code_no;
    	}
    	public String getCode_name() {
    		return code_name;
    	}
    	public void setCode_name(String code_name) {
    		this.code_name = code_name;
    	}
    	public String getCode_parent_no() {
    		return code_parent_no;
    	}
    	public void setCode_parent_no(String code_parent_no) {
    		this.code_parent_no = code_parent_no;
    	}
    	public int getShow_order() {
    		return show_order;
    	}
    	public void setShow_order(int show_order) {
    		this.show_order = show_order;
    	}
    	public Date getCreate_time() {
    		return create_time;
    	}
    	public void setCreate_time(Date create_time) {
    		this.create_time = create_time;
    	}
    	public String getRemark() {
    		return remark;
    	}
    	public void setRemark(String remark) {
    		this.remark = remark;
    	}
    	public String getCreate_user() {
    		return create_user;
    	}
    	public void setCreate_user(String create_user) {
    		this.create_user = create_user;
    	}
    	public String getValid() {
    		return valid;
    	}
    	public void setValid(String valid) {
    		this.valid = valid;
    	}
    	public String getBak1() {
    		return bak1;
    	}
    	public void setBak1(String bak1) {
    		this.bak1 = bak1;
    	}
    	public String getBak2() {
    		return bak2;
    	}
    	public void setBak2(String bak2) {
    		this.bak2 = bak2;
    	}
    	public String getBak3() {
    		return bak3;
    	}
    	public void setBak3(String bak3) {
    		this.bak3 = bak3;
    	}
    	
    
    }

同时我定义了一个MyCacheObject用于公用的实现了Serializable

package org.base.cache;
    
    import java.io.Serializable;
    
    import net.sf.ehcache.CacheEntry;
    import net.sf.ehcache.Element;
    
    /**
     * 
     * @author lushuaiyin
     *
     */
    public class MyCacheObject implements Serializable{
    	private static final long serialVersionUID = 1L;
    	public Object object;
    
    	public Object getObject() {
    		return object;
    	}
    
    	public void setObject(Object object) {
    		this.object = object;
    	}
    	
    	public MyCacheObject(){}
    	public MyCacheObject(Object object){
    		this.object=(Serializable)object;
    	}
    	
    	
    
    }

配置文件ehcache.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"/>
        
        
        
    
         
        <cacheManagerEventListenerFactory class="org.base.cache.MyCacheManagerEventListener" />
        
        
        
        
        
        <defaultCache
               maxEntriesLocalHeap="10000"
               maxEntriesLocalDisk="20000"
               eternal="false"
               diskSpoolBufferSizeMB="20"
               overflowToDisk="true"
               diskPersistent="true"
               timeToIdleSeconds="30"
               timeToLiveSeconds="30">
         
        </defaultCache>
    
        
        <cache name="myCommonCache"
               maxEntriesLocalHeap="500"
               maxEntriesLocalDisk="1000"
               eternal="false"
               diskSpoolBufferSizeMB="20"
               timeToIdleSeconds="15"
               timeToLiveSeconds="30"
               memoryStoreEvictionPolicy="LFU"
               transactionalMode="off">
            <persistence strategy="localTempSwap"/>
        </cache>
    
    
        
    
        
        
        
    </ehcache>

缓存管理类MyEhcacheManager

package org.base.cache;
    
    import java.io.Serializable;
    import java.net.URL;
    import java.util.List;
    
    import org.base.cache.dao.MyEhcacheDao;
    
    import net.sf.ehcache.Cache;
    import net.sf.ehcache.CacheEntry;
    import net.sf.ehcache.CacheManager;
    import net.sf.ehcache.Element;
    import net.sf.ehcache.Status;
    
    /**
     * Ehcache缓存管理在web下的使用实例
     * @author lushuaiyin
     *
     */
    public class MyEhcacheManager {
    	public static net.sf.ehcache.CacheManager cacheManager = null;
    	private static String configPath="/ehcache.xml";//配置文件
    	private MyEhcacheDao myEhcacheDao;//查询
    	
    	//缓存定义
    	private static String CACHE_MYCOMMONCACHE="myCommonCache";//定义文件中配置的缓存
    	
    	//缓存中的Element定义
    	private static String ELEMENT_MYCOMMONCACHE_DICTIONARY="dictionaryList";//缓存元素 
    	
    	
    	//实例化cacheManager，单例模式
    	public static CacheManager getCacheManagerInstance(){
    		if (cacheManager == null) {
    			URL configUrl=null;
    			configUrl = MyEhcacheManager.class.getClassLoader().getResource(configPath);
    			cacheManager = CacheManager.create(configUrl);
    		}
    		return cacheManager;
    	}
    	public static net.sf.ehcache.CacheManager getCacheManager() {
    		return getCacheManagerInstance();//单例缓存管理
    	}
    	
    	public static void setCacheManager(net.sf.ehcache.CacheManager cacheManager) {
    		MyEhcacheManager.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=MyEhcacheManager.getCacheByName(MyEhcacheManager.CACHE_MYCOMMONCACHE);
    		printCache(cache1);
    		
    		MyEhcacheManager.putElementToCache(MyEhcacheManager.CACHE_MYCOMMONCACHE, "111", "111haah");
    		MyEhcacheManager.putElementToCache(MyEhcacheManager.CACHE_MYCOMMONCACHE, "222", "222haah");
    		MyEhcacheManager.putElementToCache(MyEhcacheManager.CACHE_MYCOMMONCACHE, "333", "333haah");
    		
    		printCache(cache1);
    		
    		MyEhcacheManager.putElementToCache(MyEhcacheManager.CACHE_MYCOMMONCACHE, "111", "111的新值。");
    		
    		System.out.println(MyEhcacheManager.getElementValueFromCache(MyEhcacheManager.CACHE_MYCOMMONCACHE, "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...
    
    	 */
    	public MyEhcacheDao getMyEhcacheDao() {
    		return myEhcacheDao;
    	}
    	public void setMyEhcacheDao(MyEhcacheDao myEhcacheDao) {
    		this.myEhcacheDao = myEhcacheDao;
    	}
        ///上面是对缓存操作的Demo，实际使用逻辑需要改变 /
    	
    	
    	
    	
    	///以下是web环境下对字典表的缓存操作/
    	
    	//得到字典表cache对象（"myCommonCache"）
    	public Cache getMyCommonCache(){
    		Cache cache=null;
    		if(getCacheManager().getCache(MyEhcacheManager.CACHE_MYCOMMONCACHE)!=null){
    			cache=getCacheManager().getCache(MyEhcacheManager.CACHE_MYCOMMONCACHE);
    		}else{//如果缓存没有了，这里直接添加，因为在实际中我们不可能告诉应用没有了这个缓存就返回了。
    			//而是应该先去查数据，放入缓存，然后再从缓存中取数据。
    			//当然，如果缓存有数据，那就直接取数据就行了。
    			getCacheManager().addCache(MyEhcacheManager.CACHE_MYCOMMONCACHE);
    		}
    		return cache;
    	}
    	
    	//从mycommon缓存中获取字典表数据(这里只是简单的把所有值取出来了，实际应用可以更加细化)
    	public List getDictionaryListFromMyCommonCache(String codeNo){
    		codeNo=(codeNo==null||codeNo.trim().equals(""))?"":codeNo.trim();
    		List dictionaryList=null;
    		Cache cache=getMyCommonCache();//字典表公用缓存
    		Element element=null;
    		if(cache.get(MyEhcacheManager.ELEMENT_MYCOMMONCACHE_DICTIONARY)!=null){
    			element=cache.get(MyEhcacheManager.ELEMENT_MYCOMMONCACHE_DICTIONARY);
    			
    			if(element.getObjectValue()==null){//值为空，需要从新添加到缓存
    				List list=this.getMyEhcacheDao().querydictionaryByCodeNo(codeNo);//查询
    				if(list!=null){
    					MyCacheObject myCacheObject = new MyCacheObject(list);
    					element=new Element((Serializable)MyEhcacheManager.ELEMENT_MYCOMMONCACHE_DICTIONARY,(Serializable)myCacheObject);
    					//java.io.NotSerializableException:
    					cache.put(element);
    					System.out.println("缓存中的字典表元素为空，重新查询添加..");
    				}
    				dictionaryList=list;
    			}else{//有值
    				MyCacheObject myObj=(MyCacheObject)element.getObjectValue();
    				dictionaryList=(List)myObj.getObject();
    				System.out.println("缓存中存在字典表数据，直接获取到。");
    			}
    		}else{//获取Element空，需要从新添加到缓存
    			List list=this.getMyEhcacheDao().querydictionaryByCodeNo("");//查询
    			if(list!=null){
    				MyCacheObject myCacheObject = new MyCacheObject(list);
    				element=new Element((Serializable)MyEhcacheManager.ELEMENT_MYCOMMONCACHE_DICTIONARY,(Serializable)myCacheObject);
    				cache.put(element);
    				System.out.println("缓存中的字典表元素为空，重新查询添加......");
    			}
    			dictionaryList=list;
    		}
    		return dictionaryList;
    	}
    	
    	/**
    	 * 有时需要强制从数据库查询最新的实际数据，所以需要刷新缓存,保证数据的实时性。
    	 * 这里的刷新是指把缓存中所有Element清除
    	 */
    	public void refreshDictionaryListInMyCommonCache(){
    		Cache cache=getMyCommonCache();//字典表公用缓存
    		Element element=null;
    		if(cache.get(MyEhcacheManager.ELEMENT_MYCOMMONCACHE_DICTIONARY)!=null){
    			for(int i=0;i<cache.getKeys().size();i++){
    				cache.remove(cache.getKeys().get(i));
    			}
    		}
    		//如果某些缓存刷新后需要马上填充，就可以像下面直接放数据
    //		if(this.getMyEhcacheDao().querydictionaryByCodeNo("")!=null){
    //			List list=this.getMyEhcacheDao().querydictionaryByCodeNo("");//查询
    //			MyCacheObject myCacheObject = new MyCacheObject(list);
    //			element=new Element((Serializable)MyEhcacheManager.ELEMENT_MYCOMMONCACHE_DICTIONARY,(Serializable)myCacheObject);
    //			cache.put(element);
    //			System.out.println("已经强制刷新字典表缓存。。。");
    //		}
    		System.out.println("已经强制清空字典表所有缓存。。。");
    	}
    	
    	
    	
    	///
    	
    }

监听类MyCacheManagerEventListener

package org.base.cache;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Properties;
    
    import net.sf.ehcache.CacheException;
    import net.sf.ehcache.CacheManager;
    import net.sf.ehcache.Status;
    import net.sf.ehcache.event.CacheManagerEventListener;
    import net.sf.ehcache.event.CacheManagerEventListenerFactory;
    
    
    /**
     * ehcache监听自定义
     * @author lushuaiyin
     *
     */
    public class MyCacheManagerEventListener  extends CacheManagerEventListenerFactory implements CacheManagerEventListener{
    	
    	private static MyCacheManagerEventListener myCacheManagerEventListener=null;
    	
    	public static MyCacheManagerEventListener getInstance(){
    		if(myCacheManagerEventListener==null){
    			myCacheManagerEventListener=new MyCacheManagerEventListener();
    		}
    		return myCacheManagerEventListener;
    	}
    
    	
    	public void dispose() throws CacheException {
    		// TODO Auto-generated method stub
    		System.out.println("CacheManager was disposed.."+getTimeNow()+"(MyCacheManagerEventListener)");
    	}
    
    	public Status getStatus() {
    		// TODO Auto-generated method stub
    		return null;
    	}
    
    	public void init() throws CacheException {
    		// TODO Auto-generated method stub
    		System.out.println("CacheManager was inited.."+getTimeNow()+"(MyCacheManagerEventListener)");
    		
    	}
    
    	public void notifyCacheAdded(String s) {
    		// TODO Auto-generated method stub
    		System.out.println(s+" was added.."+getTimeNow()+"(MyCacheManagerEventListener)");
    	}
    
    	public void notifyCacheRemoved(String s) {
    		// TODO Auto-generated method stub
    		System.out.println(s+" was removed.."+getTimeNow()+"(MyCacheManagerEventListener)");
    	}
    
    	@Override
    	public CacheManagerEventListener createCacheManagerEventListener(
    			CacheManager cachemanager, Properties properties) {
    		// TODO Auto-generated method stub
    		return getInstance();
    	}
    	
    	public static String getTimeNow(){
    		Date dd=new Date();
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		return sdf.format(dd);
    	}
    	
    }

查询数据的公用dao

MyEhcacheDao

package org.base.cache.dao;
    
    import java.util.List;
    
    public interface MyEhcacheDao {
    	
    	public List querydictionaryByCodeNo(String codeNo);
    
    }

MyEhcacheDaoImpl

package org.base.cache.dao.impl;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import org.base.MyHibernateDao;
    import org.base.cache.dao.MyEhcacheDao;
    
    public class MyEhcacheDaoImpl  extends MyHibernateDao implements MyEhcacheDao {
    	
    	public List querydictionaryByCodeNo(String codeNo){
    		List list=new ArrayList();
    		if(codeNo==null||codeNo.trim().equals("")){
    			System.out.println("参数codeNo为空，查询所有值。");
    			String hql="select d from Dictionary d ";
    			list=this.queryListHql(hql);
    		}else{
    			String hql="select d from Dictionary d where d.code_no like '"+codeNo.trim()+"%'";
    			list=this.queryListHql(hql);
    		}
    		return list;
    	}
    }

spring配置context\_mycache.xml，注意除了dao的注入，还需要org.base.cache.MyEhcacheManager的注入，

org.base.cache.MyEhcacheManager在大多数情况其实相当于做了dao的代理。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
    
        <bean id="myEhcacheDaoTarget" class="org.base.cache.dao.impl.MyEhcacheDaoImpl">
    		<property name="sessionFactory">
    			<ref bean="sessionFactory"/>
    		</property>
    	</bean>
    	<bean id="myEhcacheDao" parent="transactionProxyTemplate">
    		<property name="target" ref="myEhcacheDaoTarget" />
    		<property name="proxyInterfaces">
    			<value>org.base.cache.dao.MyEhcacheDao</value>
    		</property>
    	</bean>
    	
    	
    	<bean id="myEhcacheManager" class="org.base.cache.MyEhcacheManager">
    		<property name="myEhcacheDao">
    			<ref bean="myEhcacheDao"/>
    		</property>
    	</bean>
    </beans>

///以下是对公用配置表的一个查询实例

DictionaryAction

package org.base.common.dictionary.action;
    
    import java.util.List;
    
    import org.base.MyBaseAction;
    import org.base.cache.MyEhcacheManager;
    
    /**
     * 字典表缓存实例
     * @author lushuaiyin
     *
     */
    public class DictionaryAction  extends MyBaseAction {
    	private static final long serialVersionUID = 1L;
    	private MyEhcacheManager myEhcacheManager;
    	
    	public String execute() throws Exception{
    		
    		return SUCCESS;
    	}
    	
    	//查询字典表数据（注意缓存是怎么使用的）
    	public String queryDictionary() throws Exception{
    		String codeNo="";
    		if(this.getValueFromRequest("codeNo")!=null){
    			codeNo=(String)this.getValueFromRequest("codeNo");
    		}
    		//数据的查询通过缓存来获取
    		List list=this.getMyEhcacheManager().getDictionaryListFromMyCommonCache(codeNo);
    		this.setValueToRequest("dictionaryList", list);
    		
    		return SUCCESS;
    	}
    	
    	//刷新字典表缓存
    	public String refreshDictionaryInCache() throws Exception{
    		this.getMyEhcacheManager().refreshDictionaryListInMyCommonCache();
    		this.getPrintWriter().println("字典表缓存已刷新！");
    		return NONE;
    	}
    
    	public MyEhcacheManager getMyEhcacheManager() {
    		return myEhcacheManager;
    	}
    
    	public void setMyEhcacheManager(MyEhcacheManager myEhcacheManager) {
    		this.myEhcacheManager = myEhcacheManager;
    	}
    	
    }

struts\_dictionary.xml

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
    <struts>
    	<package name="dictionary" extends="base-struts-default" namespace="/dictionary">
    	    	
    		<action name="queryDictionary" class="org.base.common.dictionary.action.DictionaryAction" method="queryDictionary">
    		   <result name="success">/jsp/dictionary/dictionary_list.jsp</result>
    		</action>
    		<action name="refreshDictionaryInCache" class="org.base.common.dictionary.action.DictionaryAction" method="refreshDictionaryInCache">
    		</action>
    	</package>
    </struts>

dictionary\_list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
    <%@ taglib prefix="s" uri="/struts-tags"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    <%@ page import="java.util.*"%>
    <%@page import="java.text.*"%>
    <%@ page import="org.base.common.dictionary.bean.Dictionary"%>
    <% 
    String path = request.getContextPath();
    %>
    <% 
    List list=null;
    if(request.getAttribute("dictionaryList")!=null){
    	list=(List)request.getAttribute("dictionaryList");
    }
    %>
    <html>
    	<head>
    	    <meta name="author" content="lushuaiyin">
    	    <meta name="description" content="http://blog.csdn.net/lushuaiyin">
    	    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    		<title>uploadFile</title>
    		<link rel="stylesheet" type="text/css" href="<%=path%>/resource/css/table.css" />
    		<script src="<%=path%>/script/jquery-1.7.1.min.js" type="text/javascript"></script>	
    	</head>
    	<body>
    	<input type="hidden" value="<%=path%>" id="path">
    	
    	
    
    	<table  align="center" width="80%" class="table2">
    	          <tr>
    			    <td><input type="text" value="" id="codeNo"/></td>
    			  </tr>	
    			   <tr>
    			    <td><input type="button" value="查询" οnclick="chaxun()"/></td>
    			    <td><input type="button" value="刷新缓存" οnclick="refreshcache()"/></td>
    			  </tr>	
    		</table>
    		<table id="mytable1" align="center" width="80%" class="table1">
    			  <tr>
    			    <th>code_no</th>
    			    <th>code_name</th>
    			    <th>create_time</th>
    			    <th>create_user</th>
    			  </tr>
    			  <% 
    			  if(list!=null){
    				
    			      for(int i=0;i<list.size();i++){
    			    	  Dictionary vo=(Dictionary)list.get(i);
    			    	  String code_no="",code_name="",create_time="",create_user="";
    			    	  code_no=vo.getCode_no()==null?"":vo.getCode_no().trim();
    			    	  code_name=vo.getCode_name()==null?"":vo.getCode_name().trim();
    			    	  
    			    	  Date date=vo.getCreate_time();
    					  SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    					  create_time=sdf.format(date);
    					  
    					  create_user=vo.getCreate_user()==null?"":vo.getCreate_user().trim();
    			    	 if(i%2==0){
    			    		 %>
    			  <tr class="interval">
    			   <td><%=code_no%></td>
    			    <td><%=code_name%></td>
    			    <td><%=create_time%></td>
    			    <td><%=create_user%></td>
    			  </tr>
    			    		 
    			    		 <% 
    			    	 }else{
    			    		 %>
    			   <tr>
    			    <td><%=code_no%></td>
    			    <td><%=code_name%></td>
    			    <td><%=create_time%></td>
    			    <td><%=create_user%></td>
    			  </tr>		 
    			    		 <%
    			    	 } 
    			      }
    			  }
    			  %>
    		</table>
    	</body>
    </html>
    
    <script type="text/javascript">
    var path=document.getElementById("path").value;
    
    
    function chaxun(){
    	var codeNo=document.getElementById("codeNo").value;
    	var url=path+"/dictionary/queryDictionary.action?codeNo="+codeNo;
    	window.location.href=url;
    }
    
    function refreshcache(){
    	var url=path+"/dictionary/refreshDictionaryInCache.action";
    	$.ajax({
    		   type: "POST",
    		   url: url,
    		   success: callbackrefreshcache
    		});
    }
    function callbackrefreshcache(data){
    	alert(data);
    	window.location.reload();
    }
    </script>

///测试打印

2013-5-1 15:26:29 org.apache.catalina.core.AprLifecycleListener init  
信息: The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: C:\\Program Files\\Java\\jdk1.6.0\_06\\bin;.;C:\\Windows\\Sun\\Java\\bin;C:\\Windows\\system32;C:\\Windows;C:\\Program Files\\Java\\jdk1.6.0\_06\\jre\\bin;C:/Program Files/Java/jre1.6.0\_06/bin/client;C:/Program Files/Java/jre1.6.0\_06/bin;C:/Program Files/Java/jre1.6.0\_06/lib/i386;D:\\app\\lushuaiyin\\product\\11.2.0\\client\_1\\bin;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Program Files\\Java\\jdk1.6.0\_06\\bin;C:\\Program Files\\TortoiseSVN\\bin;D:\\MySql\\bin;C:\\Program Files\\QuickTime\\QTSystem\\;C:\\Windows\\System32;C:\\Program Files\\VanDyke Software\\Clients\\;D:\\ChinaDevelopmentBankAct\\eclipse;  
2013-5-1 15:26:30 org.apache.coyote.http11.Http11Protocol init  
信息: Initializing Coyote HTTP/1.1 on http-8080  
2013-5-1 15:26:30 org.apache.catalina.startup.Catalina load  
信息: Initialization processed in 674 ms  
2013-5-1 15:26:30 org.apache.catalina.core.StandardService start  
信息: Starting service Catalina  
2013-5-1 15:26:30 org.apache.catalina.core.StandardEngine start  
信息: Starting Servlet Engine: Apache Tomcat/6.0.35  
2013-5-1 15:26:30 org.apache.catalina.startup.HostConfig deployDescriptor  
信息: Deploying configuration descriptor frame.xml  
2013-5-1 15:26:30 org.apache.catalina.loader.WebappClassLoader validateJarFile  
信息: validateJarFile(D:\\ChinaDevelopmentBankAct\\workSpace\\frame\\webapp\\WEB-INF\\lib\\servlet-api-2.5.jar) - jar not loaded. See Servlet Spec 2.3, section 9.7.2. Offending class: javax/servlet/Servlet.class  
2013-5-1 15:26:31 org.apache.catalina.core.ApplicationContext log  
信息: Initializing Spring root WebApplicationContext  
log4j:WARN No appenders could be found for logger (org.springframework.web.context.ContextLoader).  
log4j:WARN Please initialize the log4j system properly.  
CacheManager was inited..2013-05-01 15:26:34(MyCacheManagerEventListener)  
myCommonCache was added..2013-05-01 15:26:35(MyCacheManagerEventListener)  
2013-5-1 15:26:39 org.activiti.engine.impl.ProcessEngineImpl <init>  
信息: ProcessEngine default created  
 TestServlet init---  
2013-5-1 15:26:42 org.apache.catalina.startup.HostConfig deployDescriptor  
信息: Deploying configuration descriptor host-manager.xml  
2013-5-1 15:26:42 org.apache.catalina.startup.HostConfig deployDescriptor  
信息: Deploying configuration descriptor manager.xml  
2013-5-1 15:26:42 org.apache.catalina.startup.HostConfig deployDirectory  
信息: Deploying web application directory docs  
2013-5-1 15:26:42 org.apache.catalina.startup.HostConfig deployDirectory  
信息: Deploying web application directory examples  
2013-5-1 15:26:42 org.apache.catalina.core.ApplicationContext log  
信息: ContextListener: contextInitialized()  
2013-5-1 15:26:42 org.apache.catalina.core.ApplicationContext log  
信息: SessionListener: contextInitialized()  
2013-5-1 15:26:42 org.apache.coyote.http11.Http11Protocol start  
信息: Starting Coyote HTTP/1.1 on http-8080  
2013-5-1 15:26:42 org.apache.jk.common.ChannelSocket init  
信息: JK: ajp13 listening on /0.0.0.0:8009  
2013-5-1 15:26:42 org.apache.jk.server.JkMain start  
信息: Jk running ID=0 time=0/44  config=null  
2013-5-1 15:26:42 org.apache.catalina.startup.Catalina start  
信息: Server startup in 12418 ms  
参数codeNo为空，查询所有值。  
Hibernate: select dictionary0\_.id as id3\_, dictionary0\_.code\_no as code2\_3\_, dictionary0\_.code\_name as code3\_3\_, dictionary0\_.code\_parent\_no as code4\_3\_, dictionary0\_.show\_order as show5\_3\_, dictionary0\_.create\_time as create6\_3\_, dictionary0\_.remark as remark3\_, dictionary0\_.create\_user as create8\_3\_, dictionary0\_.valid as valid3\_, dictionary0\_.bak1 as bak10\_3\_, dictionary0\_.bak2 as bak11\_3\_, dictionary0\_.bak3 as bak12\_3\_ from LSY\_DICTIONARY dictionary0\_  
缓存中的字典表元素为空，重新查询添加......  
缓存中存在字典表数据，直接获取到。  
参数codeNo为空，查询所有值。  
Hibernate: select dictionary0\_.id as id3\_, dictionary0\_.code\_no as code2\_3\_, dictionary0\_.code\_name as code3\_3\_, dictionary0\_.code\_parent\_no as code4\_3\_, dictionary0\_.show\_order as show5\_3\_, dictionary0\_.create\_time as create6\_3\_, dictionary0\_.remark as remark3\_, dictionary0\_.create\_user as create8\_3\_, dictionary0\_.valid as valid3\_, dictionary0\_.bak1 as bak10\_3\_, dictionary0\_.bak2 as bak11\_3\_, dictionary0\_.bak3 as bak12\_3\_ from LSY\_DICTIONARY dictionary0\_  
缓存中的字典表元素为空，重新查询添加......  
已经强制清空字典表所有缓存。。。  
参数codeNo为空，查询所有值。  
Hibernate: select dictionary0\_.id as id3\_, dictionary0\_.code\_no as code2\_3\_, dictionary0\_.code\_name as code3\_3\_, dictionary0\_.code\_parent\_no as code4\_3\_, dictionary0\_.show\_order as show5\_3\_, dictionary0\_.create\_time as create6\_3\_, dictionary0\_.remark as remark3\_, dictionary0\_.create\_user as create8\_3\_, dictionary0\_.valid as valid3\_, dictionary0\_.bak1 as bak10\_3\_, dictionary0\_.bak2 as bak11\_3\_, dictionary0\_.bak3 as bak12\_3\_ from LSY\_DICTIONARY dictionary0\_  
缓存中的字典表元素为空，重新查询添加......  
  
  
  
  
  
  
操作步骤说明：  
  
  
第一次查询打印：  
参数codeNo为空，查询所有值。  
Hibernate: select dictionary0\_.id as id3\_, dictionary0\_.code\_no as code2\_3\_, dictionary0\_.code\_name as code3\_3\_, dictionary0\_.code\_parent\_no as code4\_3\_, dictionary0\_.show\_order as show5\_3\_, dictionary0\_.create\_time as create6\_3\_, dictionary0\_.remark as remark3\_, dictionary0\_.create\_user as create8\_3\_, dictionary0\_.valid as valid3\_, dictionary0\_.bak1 as bak10\_3\_, dictionary0\_.bak2 as bak11\_3\_, dictionary0\_.bak3 as bak12\_3\_ from LSY\_DICTIONARY dictionary0\_  
缓存中的字典表元素为空，重新查询添加......  
  
  
  
  
  
  
第二次查询打印：  
缓存中存在字典表数据，直接获取到。  
  
  
  
  
  
  
等待60秒以后，缓存已经过期，再查询，打印：  
参数codeNo为空，查询所有值。  
Hibernate: select dictionary0\_.id as id3\_, dictionary0\_.code\_no as code2\_3\_, dictionary0\_.code\_name as code3\_3\_, dictionary0\_.code\_parent\_no as code4\_3\_, dictionary0\_.show\_order as show5\_3\_, dictionary0\_.create\_time as create6\_3\_, dictionary0\_.remark as remark3\_, dictionary0\_.create\_user as create8\_3\_, dictionary0\_.valid as valid3\_, dictionary0\_.bak1 as bak10\_3\_, dictionary0\_.bak2 as bak11\_3\_, dictionary0\_.bak3 as bak12\_3\_ from LSY\_DICTIONARY dictionary0\_  
缓存中的字典表元素为空，重新查询添加......  
  
  
强制刷新缓存打印：  
已经强制清空字典表所有缓存。。。  
参数codeNo为空，查询所有值。  
Hibernate: select dictionary0\_.id as id3\_, dictionary0\_.code\_no as code2\_3\_, dictionary0\_.code\_name as code3\_3\_, dictionary0\_.code\_parent\_no as code4\_3\_, dictionary0\_.show\_order as show5\_3\_, dictionary0\_.create\_time as create6\_3\_, dictionary0\_.remark as remark3\_, dictionary0\_.create\_user as create8\_3\_, dictionary0\_.valid as valid3\_, dictionary0\_.bak1 as bak10\_3\_, dictionary0\_.bak2 as bak11\_3\_, dictionary0\_.bak3 as bak12\_3\_ from LSY\_DICTIONARY dictionary0\_  
缓存中的字典表元素为空，重新查询添加......  
  
  
  
  
  
  
  
  
注意我们定义的MyCacheManagerEventListener也正确打印了：  
CacheManager was inited..2013-05-01 15:26:34(MyCacheManagerEventListener)  
myCommonCache was added..2013-05-01 15:26:35(MyCacheManagerEventListener)