JDK动态代理与CGLIB动态代理应用及源码解析

代理模式

代理模式：为其他对象提供一种代理以控制对这个对象的访问。

代理模式中有三种角色：Subject抽象主题角色、RealSubject真实主题角色、Proxy代理主题角色。Subject描述了业务行为，RealSubject执行具体的业务逻辑，Proxy代理会拦截对RealSubject对象方法的调用，并在方法调用前后做预处理以及一些善后工作。

代理模式可以很好地在不侵入原代码的情况下，拓展原来的功能。

下图为Proxy模式的静态类图：

下图为Proxy模式的调用关系：

动态代理

静态代理由于硬编码，难以应对真实对象和调用方法灵活多变的情况，动态代理则对这些场景应付自如。

动态代理主要有两种实现方式：1、JDK自带的Proxy 2、CGLIB字节码生成库

基于JDK的动态代理

基于JDK的动态代理关键在于两个类：InvocationHandler和Proxy。
其主要实现逻辑是，由InvocationHandler定义方法执行前后的增强逻辑，由Proxy类去生成一个继承自Proxy并且实现了真实对象接口的新对象–代理对象，对该代理对象的方法调用经由InvocationHandler拦截，执行增强逻辑和调用真实对象执行业务逻辑。

下面我们先看一个例子：
定义接口：

public interface UserService {
    public String getName(int id);

    public Integer getAge(int id);
}

定义真实对象：

public class UserServiceImpl implements UserService {

    public UserServiceImpl() {
    }

    @Override
    public String getName(int id) {
        System.out.println("---getName---");
        return "John";
    }

    @Override
    public Integer getAge(int id) {
        System.out.println("---getAge---");
        return 10;
    }

}

定义InvocationHandler：

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("getName")) {
            System.out.println("+++before get name+++");
            Object res = method.invoke(target, args);
            System.out.println("+++after get name+++");
            return res;
        } else {
            Object res = method.invoke(target, args);
            return res;
        }

    }

    public static void main(String[] args) {
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        UserService us = new UserServiceImpl();
        InvocationHandler ih = new MyInvocationHandler(us);
        UserService usProxy = (UserService) Proxy.newProxyInstance(us.getClass().getClassLoader(),
                us.getClass().getInterfaces(), ih);
        System.out.println(usProxy.getName(1));
        System.out.println(usProxy.getAge(1));
        System.out.println(usProxy.getClass());
    }

}

测试结果：

可以看到，对于getName方法的增强逻辑执行了。

下面我们从源码角度分析一下这个过程的实现原理，先看InvocationHandler：
InvocationHandler是一个接口，只有一个方法：

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

在定义增强逻辑类时，需要实现该接口，并在invoke方法里实现增强逻辑和对真实对象方法的调用。对于invoke方法的三个参数，proxy表示代理对象，method表示真实对象的方法，args表示真实对象方法的参数，这里也可以看出对真实对象方法的调用是通过反射来实现的。

增强逻辑定义好了以后，我们需要一个代理对象来执行，先看如何产生这个代理对象。代理对象的产生是通过调用Proxy类的静态方法：newProxyInstance，以下源码分析部分篇幅原因仅截取部分代码片段。

public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
        //该方法需要三个参数：ClassLoader确保返回的代理对象和真实对象由同一个类

        加载器加载，interfaces用于定义代理类应该实现的方法，
        invocationHandler用于定义代理类的增强逻辑
    {
        if (h == null) {
            throw new NullPointerException();
        }

        final Class[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
         //这一行代码很关键，这里是获取代理对象Class对象，Proxy类内部维护了代理
         //对象的缓存，如果缓存里有则直接返回，如果没有，则生成它
        Class cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            //由Class对象获取构造器
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction