spring Aop 之方法缓存

    因为公司人手原因，最近在为项目搭建架构，在异常，缓存，日志，方面都打算用Aop来做，在原来的项目中对在对异常，日志方面可能都是Log log=Logfactory.getLog();这样既麻烦，又紧耦合在一起。所以打算用Aop试试。下面是对一些缓存对象的Aop处理。主要是根据方法签名来做key值。

    定义一个注解

  

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MethodCache {
	int second() default 0; 
}

 

    定义一个业务处理类

 

public class Sev {
	@MethodCache(second=3)
	public Map getSort(int type,int parentid){
		System.out.println("no cache----");
		Map m =new HashMap();
		return m;
	}
	
	@MethodCache(second=3)
	public void getSort(){
		System.out.println("no cache----");
	}
}

 

   定义一个Aop

 

import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.Date;

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

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class MethodCacheAspectJ {
	
	private Cache cache;
	
	/**
	 * 设置缓存名
	 */
	public void setCache(Cache cache) {
		this.cache = cache;
	} 
	
	@Pointcut("@annotation(com.zhang.shine.cache.MethodCache)")
	public void methodCachePointcut(){	
	}
	
	@Around("methodCachePointcut()")
	public Object methodCacheHold(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("aop start ");
		String targetName = joinPoint.getTarget().getClass().getName();
		String methodName = joinPoint.getSignature().getName();
		Object[] arguments = joinPoint.getArgs();
		Object result = null;
		String cacheKey = getCacheKey(targetName, methodName, arguments);
		System.out.println("key--"+cacheKey);
		Element element = cache.get(cacheKey);
		if (element == null) {
			try{
				result = joinPoint.proceed();
			}catch(Exception e){
				
			}
			if(result!=null){
				try{
					element = new Element(cacheKey, (Serializable) result);
					Class targetClass = Class.forName(targetName);
					Method[] method = targetClass.getMethods();
					int second = 0;
					for(Method m:method){
						if (m.getName().equals(methodName)) {
							Class[] tmpCs = m.getParameterTypes();
							if(tmpCs.length==arguments.length){
								MethodCache methodCache = m.getAnnotation(MethodCache.class);
								second = methodCache.second();
								break;
							}
						}
					}
					if(second>0){ // annotation没有设second值则使用ehcache.xml中自定义值
						element.setTimeToIdle(second);
						element.setTimeToLive(second);
					}
					cache.put(element);
				}catch(Exception e){
				}
			}
		}
		System.out.println("aop end ");
		return element.getValue();
	}

	 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++) {
				if (arguments[i] instanceof Date) {
					sb.append(".").append(
							DateUtil.datetoString((Date) arguments[i]));
				} else {
					sb.append(".").append(arguments[i]);
				}
			}
		}
		return sb.toString();
	}
}

 

    Spring配置文件

   

<bean id = "methodCacheAspectJ" class="com.zhang.shine.cache.MethodCacheAspectJ" >
		<property name="cache">
			<!-- <ref local="methodCache" /> -->
			<ref bean="methodCache"/>
		</property>
</bean>
<bean id="cacheManager"
		class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
		<property name="configLocation">
			<value>classpath:ehcache.xml</value>
		</property>
	</bean>
	
	<!-- 定义ehCache的工厂，并设置所使用的Cache name -->
	
	<bean id="methodCache"
		class="org.springframework.cache.ehcache.EhCacheFactoryBean">
		<property name="cacheManager">
			<ref local="cacheManager" />
		</property>
		<property name="cacheName">
			<value>DEFAULT_CACHE</value>
		</property>
	</bean>
<bean id="sev" class="com.zhang.shine.cache.Sev"></bean>

 

    ehcache.xml

  

 

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <diskStore path="/home/workspace/gzshine/trunk/ehcache"/>
	
	<defaultCache 
		maxElementsInMemory="50000" 
		eternal="false" 
		overflowToDisk="false" 
		timeToIdleSeconds="7200"
		timeToLiveSeconds="7200" 
		diskPersistent="false" 
		diskExpiryThreadIntervalSeconds="120"/>
		
	<cache name="DEFAULT_CACHE"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="3600"
        timeToLiveSeconds="3600"
        overflowToDisk="true"
        />
</ehcache> 

 

   测试类

 

package test;



import net.sf.cglib.core.DebuggingClassWriter;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zhang.shine.cache.CallImpl;
import com.zhang.shine.cache.MyImpl;
import com.zhang.shine.cache.Sev;
import sun.misc.*;
/**
 * 1.产生代理类$Proxy0类

执行了Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

将产生$Proxy0类，它继承Proxy对象，并根据第二个参数，实现了被代理类的所有接口，自然就可以生成接口要实现的所有方法了（这时候会重写hashcode，toString和equals三个方法），但是还没有具体的实现体；

2.   将代理类$Proxy0类加载到JVM中

这时候是根据Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第一个参数----就是被代理类的类加载器，把当前的代理类加载到JVM中

3.   创建代理类$Proxy0类的对象

调用的$Proxy0类的$Proxy0（InvocationHandler）构造函数，生成$Proxy0类的对象

参数就是Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第三个参数

这个参数就是我们自己实现的InvocationHandler对象，我们知道InvocationHandler对象中组合加入了代理类代理的接口类的实现类；所以，$Proxy0对象调用所有要实现的接口的方法，都会调用InvocationHandler对象的invoke（）方法实现；

4.   生成代理类的class byte

动态代理生成的都是二进制class字节码

 * @author zhang_zengmin
 *
 */
public class TestAOP {
	public static void main(String[] args) throws Exception{
   //cglib 代理对象class文件输出目录 如果是jdk动态代理就不输出
    /**
     * cglib头部信息
       public class Sev$$EnhancerByCGLIB$$bb4c2585 extends Sev
       implements SpringProxy, Advised, Factory
     */
	System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,  "c://class" );
	
	
		
      ApplicationContext ap =new ClassPathXmlApplicationContext("ApplicationContent.xml");
      Sev s = (Sev)ap.getBean("sev");
      //Sev s = new Sev();
      s.getSort(1, 2);
      //Thread.sleep(3010);
      s.getSort(1, 3);
     // s.getSort();
      System.out.println(s.getClass());
      
      MyImpl my=(MyImpl)ap.getBean("my");

       my.pao();
        //动态代理获取字节码  头部信息
       //public final class $Proxy0 extends Proxy implements Manager {

       /*byte[] proxyClassFile =	ProxyGenerator.generateProxyClass(
   		    proxyName, interfaces);*/
       
      /**
       * 接口默认Jdk代理
       */
     // ICall call = (ICall)ap.getBean("call");
      
     // call.cll();
       
     // Thread.sleep(60000);
     
     /* Enhancer enhancer = new Enhancer();//通过类Enhancer创建代理对象   
           enhancer.setSuperclass(Sev.class);//传入创建代理对象的类   
      
      
      ClassReader cr = new ClassReader(enhancer.getClass().getName());
      
      
       byte[] a = cr.b; 
       File f =new File("c://Sev.class");
       FileOutputStream  fout = new FileOutputStream(f);
       fout.write(a);
       fout.flush();
       fout.close();*/
       

     
     
	}
}