Java动态代理

Java提供动态代理的功能，spring AOP即利用动态代理的方式来实现面向切面编程，我们用一个很简单的例子来看一下Java本身的动态代理怎么用的。

可以看到，要实现对对象的动态代理，要调用Proxy.newProxyInstance()方法，改方法的入参需要传入被代理对象的类加载器、被代理对象的接口、一个InvocationHandler的实例。

代理对象执行被代理对象方法时，会调用InvocationHandler实例的invoke()方法，在invoke()方法中可以执行被代理对象对应的方法，并且可以编写其他的逻辑，这也是spring AOP的原理。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * java 动态代理
 */
public class JavaDynProxy implements InvocationHandler {
    private Object target;

    /**
     * 获取动态代理对象，入参要传入被代理对象的类加载器、被代理对象接口、对应InvocationHandler实例
     * 使用代理对象调用被代理对象的方法时，会调用InvocationHandler实例的invoke方法，从而达到对象方法被代理执行的目的
     * spring的核心功能AOP即利用此方式来执行面向切面编程
     * @param target 被代理对象
     * @return 动态代理对象
     */
    public Object getProxyInstance(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        System.out.println("before target method...");
        result = method.invoke(target, args);
        System.out.println("after target method...");
        return result;
    }

    public static void main(String[] args){
        JavaDynProxy proxy = new JavaDynProxy();
        Hello hello = (Hello) proxy.getProxyInstance(new HelloImpl());
        String s = hello.sayHello("Leon");
        System.out.println(s);

        UserDao userDao = (UserDao) proxy.getProxyInstance(new UserDaoImpl());
        userDao.login("Leon", "1234");
        System.out.println(userDao.getClass().getName());
    }

}

除了使用java原生支持的动态代理外，还可以使用CGLib来编写动态代理。

使用方法和原生的动态代理方法很相似，可以看到要实现动态代理要实例化一个MethodInterceptor的实例，并实现他的intercept()方法，和原生动态代理的区别从代码即可看出，不用传入被代理对象的接口。

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

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {
    private Object target;

    public Object getProxyInstance(Object target){
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);  // call back method
        return enhancer.create();  // create proxy instance
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before target method...");
        Object result = methodProxy.invokeSuper(target, objects);
        System.out.println("after target method...");
        return result;
    }

    public static void main(String[] args){
        CglibProxy proxy = new CglibProxy();
        Hello hello = (Hello) proxy.getProxyInstance(new HelloImpl());
        System.out.println(hello.sayHello("Leon"));
        UserDaoImpl userDao = (UserDaoImpl) proxy.getProxyInstance(new UserDaoImpl());
        userDao.login("Leon", "1234");
        System.out.println(userDao.getClass().getSuperclass());//看动态代理实例的父类
    }
}

java的动态代理为很多框架的实现都提供了必要的功能基础，动态代理涉及到动态代理对象的创建、方法的反射调用、以及参数的拆装包，效率必将收到影响。

最后总结一句原生java动态代理和CGLib的区别：

JDK原生动态代理是Java原生支持的，不需要任何外部依赖，但是它只能基于接口进行代理；CGLIB通过继承的方式进行代理，无论目标对象有没有实现接口都可以代理，但是无法处理final的情况。----（转载自：http://www.importnew.com/27772.html）