AOP实现JDK中的动态代理和cglib代理

java.lang.reflect  Interface InvocationHandler

可参考http://www.gznc.edu.cn/yxsz/jjglxy/book/Java_api/java/lang/reflect/InvocationHandler.html

http://www.gznc.edu.cn/yxsz/jjglxy/book/Java_api/java/lang/reflect/Proxy.html

invocation是“调用”的意思。这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事.InvocationHandler接口把我们的代理对象和被代理对象解耦了.动态代理类可以对任何实现某一接口的类进行功能性的增强。

关于Method对象的invoke方法，根据java的反射机制可以获得某个对象的某个方法，也可以动态调用，假设已经获取了这个方法method.那么method.invoke(owner,args)就是动态调用，owner表示方法所属的对象，args为Object[]类型的方法参数。

接口InvocationHandler的方法

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:在其上调用方法的代理实例（Proxy类型的对象）。

method:对应于在代理实例上调用的接口方法的 Method 实例。。

args:为方法的参数

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynProxy implements InvocationHandler{
    private Object src;//被代理对象
//bind为自定义方法，将src绑定到某个代理中
//把当前对象(实现了InvocationHandler接口)传递给代理对象
//返回代理对象
    public Object bind(Object src){
        this.src=src;
        Object proxy=Proxy.newProxyInstance(
            src.getClass().getClassLoader(),//被代理对象的类加载器
            src.getClass().getInterfaces(),//被代理对象实现的接口们，代理对象可以实现全部接口
            this //当前对象(实现了InvocationHandler接口) 回调，拦截到一个方法后可以触发哪个类中的哪个方法。
            );
        //返回的是一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口
        return proxy;
    }
    //InvocationHandler接口方法
//src（目标对象）中的每个方法会被此方法送去JVM调用,也就是说,src的方法只能通过此方法调用
//此方法不能自己调用
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println(method.getName()+"调用前");
        Object result=method.invoke(src, args);
        return result;
    }
    public static void main(String[] args) {
        Login src=new Login();  //被代理对象
        DynProxy dp=new DynProxy();
        ILogin proxy=(ILogin)dp.bind(src);  //返回代理对象
        String username="tazi",password="123";
        proxy.login(username, password); //在代理实例上调用接口方法
    }
}

代理对象实现了目标对象的接口，使用时要用接口来引用代理对象。

以上的代码改个名字更好理解：

package com.tazi.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//JDK方式的动态代理对象的创建工厂
public class JDKProxyFactory implements InvocationHandler{
    private Object target;//目标对象
//创建代理对象的方法
//返回的是已经实现了目标对象所有接口的代理对象
    public Object createProxy(Object target){
        this.target=target;
        //以下前两个参数跟目标对象有关
//第三个参数是一个包含回调方法(invoke)的对象(实现InvocationHandler接口)
        return Proxy.newProxyInstance(target.getClass().getClassLoader()
                , target.getClass().getInterfaces(),this);
    }
    //当拦截到目标对象某个方法时的回调方法
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("方法执行前");
        Object result=method.invoke(target, args);
        System.out.println("方法执行后");
        
        return result;
    }
}

测试用例：

package junit.test;

import static org.junit.Assert.*;

import org.junit.BeforeClass;
import org.junit.Test;



import com.tazi.aop.JDKProxyFactory;
import com.tazi.aop.PersonService;
import com.tazi.aop.PersonServiceBean;

public class ProxyTest {
    private static JDKProxyFactory proxyFactory;
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        proxyFactory=new JDKProxyFactory();
    }
    @Test
    public void proxy() throws Exception {
        PersonService pService=(PersonService)proxyFactory.createProxy(new PersonServiceBean());
        pService.save("xxx");
    }
}

CGLIB实现动态代理

但实际中情况会比较复杂，有可能目标对象没有实现接口。如果没有就不能创建代理对象。此时用到第三方的jar包来创建代理对象。cglib.jar。这时目标对象可以不实现接口。

cglib的实现方式是创建被代理对象的子类，这个子类覆盖了目标对象的所有的非final的所有方法。然后设置回调方法。

package com.tazi.aop;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxyFactory implements MethodInterceptor{
    private Object target;
    public Object createProxy(Object target){
        this.target=target;
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
    public Object intercept(Object proxy, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {
        System.out.println("方法执行前00");
        Object result=method.invoke(target, args);
        System.out.println("方法执行后00");
        return result;
    }
}