你必须会的 JDK 动态代理和 CGLIB 动态代理

我们在阅读一些 java 框架的源码时，基本上常会看到使用动态代理机制，它可以无感的对既有代码进行方法的增强，使得代码拥有更好的拓展性。
通过从静态代理、jdk 动态代理、cglib 动态代理来进行本文的分析。

静态代理

静态代理就是在程序运行之前，代理类字节码.class就已编译好，通常一个静态代理类也只代理一个目标类，代理类和目标类都实现相同的接口。
接下来就先通过 demo 进行分析什么是静态代理，当前创建一个 animal 接口，里面包含call函数。

package top.ytao.demo.proxy;

/**
 * created by yangtao
 */
public interface animal {

    void call();

}

创建目标类 cat，同时实现 animal 接口，下面是 cat 发出叫声的实现。

package top.ytao.demo.proxy;

/**
 * created by yangtao
 */
public class cat implements animal {

    @override
    public void call() {
        system.out.println("喵喵喵 ~");
    }
}

由于 cat 叫之前是因为肚子饿了，所以我们需要在目标对象方法cat#call之前说明是饥饿，这是使用静态代理实现猫饥饿然后发出叫声。

package top.ytao.demo.proxy.jdk;

import top.ytao.demo.proxy.animal;

/**
 * created by yangtao
 */
public class staticproxyanimal implements animal {

    private animal impl;

    public staticproxyanimal(animal impl) {
        this.impl = impl;
    }

    @override
    public void call() {
        system.out.println("猫饥饿");
        impl.call();
    }
}

通过调用静态代理实现猫饥饿和叫行为。

public class main {

    @test
    public void staticproxy(){
        animal staticproxy = new staticproxyanimal(new cat());
        staticproxy.call();
    }
}  

执行结果

代理类、目标类、接口之间关系如图：

以上内容可以看到代理类中通过持有目标类对象，然后通过调用目标类的方法，实现静态代理。
静态代理虽然实现了代理，但在一些情况下存在比较明显不足之处：

1. 当我们在 animal 接口中增加方法，这时不仅实现类 cat 需要新增该方法的实现，同时，由于代理类实现了 animal 接口，所以代理类也必须实现 animal 新增的方法，这对项目规模较大时，在维护上就不太友好了。
2. 代理类实现animal#call是针对 cat 目标类的对象进行设置的，如果再需要添加 dog 目标类的代理，那就必须再针对 dog 类实现一个对应的代理类，这样就使得代理类的重用型不友好，并且过多的代理类对维护上也是比较繁琐。

上面问题，在 jdk 动态代理中就得到了较友好的解决。

jdk 动态代理

动态代理类与静态代理类最主要不同的是，代理类的字节码不是在程序运行前生成的，而是在程序运行时再虚拟机中程序自动创建的。
继续用上面 cat 类和 animal 接口实现 jdk 动态代理。

实现 invocationhandler 接口

jdk 动态代理类必须实现反射包中的 java.lang.reflect.invocationhandler 接口，在此接口中只有一个 invoker 方法：

在invocationhandler#invoker中必须调用目标类被代理的方法，否则无法做到代理的实现。下面为实现 invocationhandler 的代码。

/**
 * created by yangtao
 */
public class targetinvoker implements invocationhandler {
    // 代理中持有的目标类
    private object target;

    public targetinvoker(object target) {
        this.target = target;
    }

    @override
    public object invoke(object proxy, method method, object[] args) throws throwable {
        system.out.println("jdk 代理执行前");
        object result = method.invoke(target, args);
        system.out.println("jdk 代理执行后");
        return result;
    }
}

在实现invocationhandler#invoker时，该方法里有三个参数：

• proxy 代理目标对象的代理对象，它是真实的代理对象。
• method 执行目标类的方法
• args 执行目标类的方法的参数

创建 jdk 动态代理类

创建 jdk 动态代理类实例同样也是使用反射包中的 java.lang.reflect.proxy 类进行创建。通过调用proxy#newproxyinstance静态方法进行创建。

/**
 *
 * created by yangtao
 */
public class dynamicproxyanimal {

    public static object getproxy(object target) throws exception {
        object proxy = proxy.newproxyinstance(
                target.getclass().getclassloader(), // 指定目标类的类加载
                target.getclass().getinterfaces(),  // 代理需要实现的接口，可指定多个，这是一个数组
                new targetinvoker(target)   // 代理对象处理器
        );
        return proxy;
    }

}

proxy#newproxyinstance中的三个参数（classloader loader、class<?>[] interfaces、invocationhandler h）：

• loader 加载代理对象的类加载器
• interfaces 代理对象实现的接口，与目标对象实现同样的接口
• h 处理代理对象逻辑的处理器，即上面的 invocationhandler 实现类。

最后实现执行 dynamicproxyanimal 动态代理：

public class main {

    @test
    public void dynamicproxy() throws exception {
        cat cat = new cat();
        animal proxy = (animal) dynamicproxyanimal.getproxy(cat);
        proxy.call();
    }
}    

执行结果：

通过上面的代码，有两个问题：代理类是怎么创建的和代理类怎么调用方法的？

分析

从proxy#newproxyinstance入口进行源码分析：

public static object newproxyinstance(classloader loader,
                                      class<?>[] interfaces,
                                      invocationhandler h)
    throws illegalargumentexception
{
    objects.requirenonnull(h);

    final class<?>[] intfs = interfaces.clone();
    final securitymanager sm = system.getsecuritymanager();
    if (sm != null) {
        checkproxyaccess(reflection.getcallerclass(), loader, intfs);
    }

    // 查找或生成指定的代理类
    class<?> cl = getproxyclass0(loader, intfs);

    try {
        if (sm != null) {
            checknewproxypermission(reflection.getcallerclass(), cl);
        }

        // 获取代理的构造器
        final constructor<?> cons = cl.getconstructor(constructorparams);
        final invocationhandler ih = h;
        // 处理代理类修饰符，使得能被访问
        if (!modifier.ispublic(cl.getmodifiers())) {
            accesscontroller.doprivileged(new privilegedaction<void>() {
                public void run() {
                    cons.setaccessible(true);
                    return null;
                }
            });
        }
        // 创建代理类实例化
        return cons.newinstance(new object[]{h});
    } catch (illegalaccessexception|instantiationexception e) {
        throw new internalerror(e.tostring(), e);
    } catch (invocationtargetexception e) {
        throwable t = e.getcause();
        if (t instanceof runtimeexception) {
            throw (runtimeexception) t;
        } else {
            throw new internalerror(t.tostring(), t);
        }
    } catch (nosuchmethodexception e) {
        throw new internalerror(e.tostring(), e);
    }
}

newproxyinstance 方法里面获取到代理类，如果类的作用不能访问，使其能被访问到，最后实例化代理类。这段代码中最为核心的是获取代理类的getproxyclass0方法。

private static final weakcache<classloader, class<?>[], class<?>> proxyclasscache = new weakcache<>(new keyfactory(), new proxyclassfactory());

private static class<?> getproxyclass0(classloader loader,
                                       class<?>... interfaces) {
    // 实现类的接口不能超过 65535 个
    if (interfaces.length > 65535) {
        throw new illegalargumentexception("interface limit exceeded");
    }

    // 获取代理类
    return proxyclasscache.get(loader, interfaces);
}

如果 proxyclasscache 缓存中存在指定的代理类，则从缓存直接获取；如果不存在，则通过 proxyclassfactory 创建代理类。
至于为什么接口最大为 65535，这个是由字节码文件结构和 java 虚拟机规定的，具体可以通过研究字节码文件了解。

进入到proxyclasscache#get，获取代理类:

继续进入factory#get查看，

最后到proxyclassfactory#apply，这里实现了代理类的创建。

private static final class proxyclassfactory implements bifunction<classloader, class<?>[], class<?>>{
    // 所有代理类名称都已此前缀命名
    private static final string proxyclassnameprefix = "$proxy";

    // 代理类名的编号
    private static final atomiclong nextuniquenumber = new atomiclong();

    @override
    public class<?> apply(classloader loader, class<?>[] interfaces) {

        map<class<?>, boolean> interfaceset = new identityhashmap<>(interfaces.length);
        for (class<?> intf : interfaces) {
            
            // 校验代理和目标对象是否实现同一接口
            class<?> interfaceclass = null;
            try {
                interfaceclass = class.forname(intf.getname(), false, loader);
            } catch (classnotfoundexception e) {
            }
            if (interfaceclass != intf) {
                throw new illegalargumentexception(
                    intf + " is not visible from class loader");
            }
            
            // 校验 interfaceclass 是否为接口
            if (!interfaceclass.isinterface()) {
                throw new illegalargumentexception(
                    interfaceclass.getname() + " is not an interface");
            }
            
            // 判断当前 interfaceclass 是否被重复
            if (interfaceset.put(interfaceclass, boolean.true) != null) {
                throw new illegalargumentexception(
                    "repeated interface: " + interfaceclass.getname());
            }
        }

        // 代理类的包名
        string proxypkg = null;     
        int accessflags = modifier.public | modifier.final;

        // 记录非 public 修饰符代理接口的包，使生成的代理类与它在同一个包下
        for (class<?> intf : interfaces) {
            int flags = intf.getmodifiers();
            if (!modifier.ispublic(flags)) {
                accessflags = modifier.final;
                // 获取接口类名
                string name = intf.getname();
                // 去掉接口的名称，获取所在包的包名
                int n = name.lastindexof('.');
                string pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxypkg == null) {
                    proxypkg = pkg;
                } else if (!pkg.equals(proxypkg)) {
                    throw new illegalargumentexception(
                        "non-public interfaces from different packages");
                }
            }
        }

        if (proxypkg == null) {
            // 如果接口类是 public 修饰，则用 com.sun.proxy 包名
            proxypkg = reflectutil.proxy_package + ".";
        }

        // 创建代理类名称
        long num = nextuniquenumber.getandincrement();
        string proxyname = proxypkg + proxyclassnameprefix + num;

        // 生成代理类字节码文件
        byte[] proxyclassfile = proxygenerator.generateproxyclass(
            proxyname, interfaces, accessflags);
        try {
            // 加载字节码，生成指定代理对象
            return defineclass0(loader, proxyname,
                                proxyclassfile, 0, proxyclassfile.length);
        } catch (classformaterror e) {
            throw new illegalargumentexception(e.tostring());
        }
    }
}

以上就是创建字节码流程，通过检查接口的属性，决定代理类字节码文件生成的包名及名称规则，然后加载字节码获取代理实例。操作生成字节码文件在proxygenerator#generateproxyclass中生成具体的字节码文件，字节码操作这里不做详细讲解。
生成的字节码文件，我们可以通过保存本地进行反编译查看类信息，保存生成的字节码文件可以通过两种方式：设置jvm参数或将生成 byte[] 写入文件。

上图的proxygenerator#generateproxyclass方法可知，是通过 savegeneratedfiles 属性值控制，该属性的值来源：

private static final boolean savegeneratedfiles = ((boolean)accesscontroller.doprivileged(new getbooleanaction("sun.misc.proxygenerator.savegeneratedfiles"))).booleanvalue();

所以通过设置将生成的代理类字节码保存到本地。

-dsun.misc.proxygenerator.savegeneratedfiles=true

反编译查看生成的代理类：

生成的代理类继承了 proxy 和实现了 animal 接口，调用call方法，是通过调用 proxy 持有的 invocationhandler 实现targetinvoker#invoker的执行。

cglib 动态代理

cglib 动态代理的实现机制是生成目标类的子类，通过调用父类（目标类）的方法实现，在调用父类方法时再代理中进行增强。

实现 methodinterceptor 接口

相比于 jdk 动态代理的实现，cglib 动态代理不需要实现与目标类一样的接口，而是通过方法拦截的方式实现代理，代码实现如下，首先方法拦截接口 net.sf.cglib.proxy.methodinterceptor。

/**
 * created by yangtao
 */
public class targetinterceptor implements methodinterceptor {

    @override
    public object intercept(object obj, method method, object[] args, methodproxy proxy) throws throwable {
        system.out.println("cglib 调用前");
        object result = proxy.invokesuper(obj, args);
        system.out.println("cglib 调用后");
        return result;
    }
}

通过方法拦截接口调用目标类的方法，然后在该被拦截的方法进行增强处理，实现方法拦截器接口的 intercept 方法里面有四个参数：

• obj 代理类对象
• method 当前被代理拦截的方法
• args 拦截方法的参数
• proxy 代理类对应目标类的代理方法

创建 cglib 动态代理类

创建 cglib 动态代理类使用 net.sf.cglib.proxy.enhancer 类进行创建，它是 cglib 动态代理中的核心类，首先创建个简单的代理类：

/**
 * created by yangtao
 */
public class cglibproxy {

    public static object getproxy(class<?> clazz){
        enhancer enhancer = new enhancer();
        // 设置类加载
        enhancer.setclassloader(clazz.getclassloader());
        // 设置被代理类
        enhancer.setsuperclass(clazz);
        // 设置方法拦截器
        enhancer.setcallback(new targetinterceptor());
        // 创建代理类
        return enhancer.create();
    }

}

设置被代理类的信息和代理类拦截的方法的回调执行逻辑，就可以实现一个代理类。
实现 cglib 动态代理调用：

public class main {

    @test
    public void dynamicproxy() throws exception {
        animal cat = (animal) cglibproxy.getproxy(cat.class);
        cat.call();
    }
}

执行结果：

cglib 动态代理简单应用就这样实现，但是 enhancer 在使用过程中，常用且有特色功能还有回调过滤器 callbackfilter 的使用，它在拦截目标对象的方法时，可以有选择性的执行方法拦截，也就是选择被代理方法的增强处理。使用该功能需要实现 net.sf.cglib.proxy.callbackfilter 接口。
现在增加一个方法拦截的实现：

/**
 * created by yangtao
 */
public class targetinterceptor2 implements methodinterceptor {

    @override
    public object intercept(object obj, method method, object[] args, methodproxy proxy) throws throwable {
        system.out.println("cglib 调用前 targetinterceptor2");
        object result = proxy.invokesuper(obj, args);
        system.out.println("cglib 调用后 targetinterceptor2");
        return result;
    }
}

然后在 cat 中增加 hobby 方法，因为 cglib 代理无需实现接口，可以直接代理普通类，所以不需再 animal 接口中增加方法：

package top.ytao.demo.proxy;

/**
 * created by yangtao
 */
public class cat implements animal {

    @override
    public void call() {
        system.out.println("喵喵喵 ~");
    }
    
    public void hobby(){
        system.out.println("fish ~");
    }
}

实现回调过滤器 callbackfilter

/**
 * created by yangtao
 */
public class targetcallbackfilter implements callbackfilter {
    @override
    public int accept(method method) {
        if ("hobby".equals(method.getname()))
            return 1;
        else
            return 0;
    }
}

为演示调用不同的方法拦截器，在 enhancer 设置中，使用enhancer#setcallbacks设置多个方法拦截器，参数是一个数组，targetcallbackfilter#accept返回的数字即为该数组的索引，决定调用的回调选择器。

/**
 * created by yangtao
 */
public class cglibproxy {

    public static object getproxy(class<?> clazz){
        enhancer enhancer = new enhancer();
        enhancer.setclassloader(clazz.getclassloader());
        enhancer.setsuperclass(clazz);
        enhancer.setcallbacks(new callback[]{new targetinterceptor(), new targetinterceptor2()});
        enhancer.setcallbackfilter(new targetcallbackfilter());
        return enhancer.create();
    }

}

按代码实现逻辑，call 方法会调用 targetinterceptor 类，hobby 类会调用 targetinterceptor2 类，执行结果：

cglib 的实现原理是通过设置被代理的类信息到 enhancer 中，然后利用配置信息在enhancer#create生成代理类对象。生成类是使用 asm 进行生成，本文不做重点分析。如果不关注 asm 的操作原理，只看 cglib 的处理原理还是比较容易读懂。这里主要看生成后的代理类字节码文件，通过设置

system.setproperty(debuggingclasswriter.debug_location_property, "f:\\xxx");

可保存生成的字节到 f:\xxx 文件夹中

通过反编译可看到

代理类继承了目标类 cat，同时将两个方法拦截器加载到了代理类中，通过 callbacks 下标作为变量名后缀进行区分，最后调用指定的方法拦截器中的 intercept 实现代理的最终的执行结果。
这里需要注意的是 cglib 动态代理不能代理 final 修饰的类和方法。

最后

通过反编译生成的 jdk 代理类和 cglib 代理类，我们可以看到它们两种不同机制的实现：
jdk 动态代理是通过实现目标类的接口，然后将目标类在构造动态代理时作为参数传入，使代理对象持有目标对象，再通过代理对象的 invocationhandler 实现动态代理的操作。
cglib 动态代理是通过配置目标类信息，然后利用 asm 字节码框架进行生成目标类的子类。当调用代理方法时，通过拦截方法的方式实现代理的操作。
总的来说，jdk 动态代理利用接口实现代理，cglib 动态代理利用继承的方式实现代理。

动态代理在 java 开发中是非常常见的，在日志，监控，事务中都有着广泛的应用，同时在大多主流框架中的核心组件中也是少不了使用的，掌握其要点，不管是开发还是阅读其他框架源码时，都是必须的。

个人博客：
关注公众号 【ytao】，更多原创好文