我们在阅读一些 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(); } }执行结果
代理类、目标类、接口之间关系如图：
以上内容可以看到代理类中通过持有目标类对象，然后通过调用目标类的方法，实现静态代理。 静态代理虽然实现了代理，但在一些情况下存在比较明显不足之处：
当我们在 Animal 接口中增加方法，这时不仅实现类 Cat 需要新增该方法的实现，同时，由于代理类实现了 Animal 接口，所以代理类也必须实现 Animal 新增的方法，这对项目规模较大时，在维护上就不太友好了。代理类实现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原文链接：https://juejin.im/post/5e8ad506e51d4547165507b2