一个利用ehcache和AOP做的缓存切面类。

缓存操作类。
package cache;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

public class OACache {

private static Log logger = LogFactory.getLog(OACache.class);

private static Map<String,Cache> cacheMap=new ConcurrentHashMap<String,Cache>();

static{
CacheManager.create();
}

/**
* 取得cache
* @param cacheName
* @return
*/
public synchronized static Cache getCache(String cacheName){

Cache cache=cacheMap.get(cacheName);

if(cache!=null){
logger.debug("return");
return cache;
}
else
{
logger.debug("create");
cache = CacheManager.getInstance().getCache(cacheName);
cacheMap.put(cacheName,cache);
return cache;
}
}

/**
* 向cache中输入值
* @param cacheName
* @param id
* @param obj
*/
public synchronized static void putObject(String cacheName,String id,Object obj){
Element element=new Element(id,obj);

getCache(cacheName).put(element);
}

/**
* 从cache中取值。
* @param cacheName
* @param id
* @return
*/
public synchronized static Object getObject(String cacheName,String id){
Cache cache=getCache(cacheName);

try{
    return cache.get(id).getObjectValue();
}catch(NullPointerException e){
return null;
}
}

/**
* 从cache中删除值。
* @param cacheName
* @param id
* @return
*/
public synchronized static void removeObject(String cacheName,String id){
Cache cache=getCache(cacheName);

cache.remove(id);
}

/**
* 清除所有的缓存。
*/
public synchronized static void shutDownAllCache(){
CacheManager.getInstance().shutdown();
}

}
缓存切面类
package advice;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;

import util.string.StringUtil;
import cache.OACache;

public class CacheAdvice {

private static Log logger = LogFactory.getLog(CacheAdvice.class);

private List<String> cacheMethodList;
private Map<String,String> updateMethodList;

private String cacheName;

/**
* cache的名称,根据ehcache设置。
* @param cacheName
*/
public void setCacheName(String cacheName) {
this.cacheName = cacheName;
}
/**
* 需要缓存的方法名，
* @param cacheMethodList
*/
public void setCacheMethodList(List<String> cacheMethodList) {
this.cacheMethodList = cacheMethodList;
}
/**
* 当执行这些方法时，需要更新缓存。
* @param updateMethodList
*/
public void setUpdateMethodList(Map<String, String> updateMethodList) {
this.updateMethodList = updateMethodList;
}

/**
* 缓存。
* @param point
* @return
* @throws Throwable
*/
public Object cache(ProceedingJoinPoint point) throws Throwable{ 

//注意监视的对象如果有返回值本方法也要有返回值

String methodName  = point.getSignature().getName();
String targetName  = point.getTarget().getClass().getName();
    Object[] arguments = point.getArgs();
    Object result;
   
   
     if(needToUpdate(methodName)){
   
        String[] updateMethodArray=updateMethodList.get(methodName).split(",");
       
        for(String method:updateMethodArray){
       
          logger.debug("remove "+method.trim()+" from  cache!!");
         
      OACache.removeObject(cacheName,method.trim());      
        }
       
        return point.proceed();
          }
           else if(!needToCache(methodName))
           {
       
    logger.debug(targetName+"-"+methodName+" need not to cache!!");
   
    return point.proceed();
   
        }
           else
           {
           String cacheKey=getCacheKey(targetName,methodName,arguments);
          
           Map<String,Object> mapResult=(Map<String,Object>)OACache.getObject(cacheName,methodName);
          
           if(mapResult!=null){
          
           if(mapResult.get(cacheKey)!=null){
           logger.debug(cacheKey+" has already cached,load from cache!!");
          
           return mapResult.get(cacheKey);
           }
           else
           {
           result=point.proceed();
           mapResult.put(cacheKey,result);
          
           OACache.putObject(cacheName,methodName,mapResult);
           logger.debug("use old map and "+cacheKey+" caching!!");
          
           return result;
           }
           }
           else
           {
                       result=point.proceed();
          
           mapResult=new ConcurrentHashMap();
          
           mapResult.put(cacheKey,result);           
           OACache.putObject(cacheName,methodName,mapResult);
          
           logger.debug("make new map and "+cacheKey+" caching!!");
          
           return result;
           }
          
           }
   
}

/**
* 根据执行的类，方法名和参数返回cachekey。
* @param targetName
* @param methodName
* @param arguments
* @return
*/
private String getCacheKey(String targetName,String methodName,Object[] arguments) {
StringBuffer sb = new StringBuffer();

sb.append(targetName).append(".").append(methodName);

if ((arguments != null) && (arguments.length != 0)) {
for (int i=0; i<arguments.length; i++) {
sb.append(".").append(arguments[i]);
}
}

return sb.toString();
    }

/**
* 检测是否需要更新。
* @param methodName
* @return
*/
private boolean needToUpdate(String methodName){

if(updateMethodList.get(methodName)==null)
  {
return false;
  }
  else
  {
return true;
  }
}

/**
* 检测是否需要缓存。
* @param methodName
* @return
*/
private boolean needToCache(String methodName){
return StringUtil.inStr(methodName,cacheMethodList.toArray(new String[0]));
}

}
切面在spring中的设置。
<bean id="cacheAdvice" class="advice.CacheAdvice" scope="singleton" >

  <property name="cacheMethodList">
        <list>
          <value>findMessageReceiveByMessageTypeAndStaffid</value>
          <value>getCountBulletinReceiveByDeptid</value>
          <value>findBulletinReceiveByDeptid</value>
          <value>getCountMessageReceiveByMessageTypeAndStaffid</value>         
          <value>findNewMessageByStaffid</value>
          <value>getCountNewMessageByStaffid</value>
          <value>getCountMessageSentByTypeAndStaffid</value>
          <value>findMessageSentByMessageTypeAndStaffid</value>
        </list>
      </property>
     
      <property name="updateMethodList">
        <map>
          <entry key="saveMessage">
            <value>
            findMessageSentByMessageTypeAndStaffid,
            getCountMessageSentByTypeAndStaffid,
            findMessageReceiveByMessageTypeAndStaffid,
            getCountMessageReceiveByMessageTypeAndStaffid,
            findNewMessageByStaffid,
            getCountNewMessageByStaffid
            </value>
          </entry>
          <entry key="senderDel">
            <value>
            findMessageSentByMessageTypeAndStaffid,
            getCountMessageSentByTypeAndStaffid,
            findMessageReceiveByMessageTypeAndStaffid,
            getCountMessageReceiveByMessageTypeAndStaffid,
            findNewMessageByStaffid,
            getCountNewMessageByStaffid
            </value>
          </entry>
          <entry key="receiverDel">
            <value>
            findMessageSentByMessageTypeAndStaffid,
            getCountMessageSentByTypeAndStaffid,
            findMessageReceiveByMessageTypeAndStaffid,
            getCountMessageReceiveByMessageTypeAndStaffid,
            findNewMessageByStaffid,
            getCountNewMessageByStaffid
            </value>
          </entry>
        </map>
      </property>
     
      <property name="cacheName">
        <value>pagecache</value>
      </property>
     
    </bean>