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();*/

}
}