动态代理原理解析 (一)：Proxy

常用动态代理主要有两种：Java自带的Proxy动态代理和cglib的动态代理。

Proxy动态代理是基于接口的，只能对实现了接口的类生成代理，而对于普通类的代理cglib能胜任。
例如在Spring中有接口默认JDK代理，无接口使用CGLIB，但可以配置强制全部使用CGLIB代理。
XML

<aop:aspectj-autoproxy proxy-target-class="true"/>

配置文件或注解

#配置文件
spring.aop.proxy-target-class=true
#注解
@EnableAspectJAutoProxy(proxyTargetClass = true

JDK Proxy

使用实例：三个参数：ClassLoader，Interface，InvocationHandler。
method.invoke(实例,参数);

   public class ProxyTest {public static void main(String[] args) throws RuntimeException{Hello hello=new DogHello();Hello o = (Hello)Proxy.newProxyInstance(hello.getClass().getClassLoader(), DogHello.class.getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("start--");method.invoke(hello,args);System.out.println("end--");return null;}});o.say("aa");}
}

其实，对于以上的简写的代码类，编译后会出现两个Class文件，一个普通的ProxyTest.class，另一个名字为ProxyTest$1.class. 如果手动创建类实现InvocationHandler接口则没有。为什么是1呢，因为0被生成的代理类占用了

final class ProxyTest$1 implements InvocationHandler {ProxyTest$1(Hello var1) {this.val$hello = var1;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("start--");method.invoke(this.val$hello, args);System.out.println("end--");return null;}
}

原理讲解

首先我们来看一下基于JDK的动态代理源码：

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);}//前面的代码基本都是安全检查/*关键代码，动态构造代理类* Look up or generate the designated proxy class.*/Class<?> cl = getProxyClass0(loader, intfs);/*开始调用构造函数* Invoke its constructor with the designated invocation handler.*/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);}}
private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}// If the proxy class defined by the given loader implementing// the given interfaces exists, this will simply return the cached copy;// otherwise, it will create the proxy class via the ProxyClassFactoryreturn proxyClassCache.get(loader, interfaces);}

首先从缓存里取代理类，如果没有则通过Proxy里的ProxyClassFactory创建

ublic V get(K key, P parameter) {Objects.requireNonNull(parameter);expungeStaleEntries();Object cacheKey = CacheKey.valueOf(key, refQueue);// lazily install the 2nd level valuesMap for the particular cacheKeyConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);if (valuesMap == null) {ConcurrentMap<Object, Supplier<V>> oldValuesMap= map.putIfAbsent(cacheKey,valuesMap = new ConcurrentHashMap<>());if (oldValuesMap != null) {valuesMap = oldValuesMap;}}// create subKey and retrieve the possible Supplier<V> stored by that// subKey from valuesMapObject subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));Supplier<V> supplier = valuesMap.get(subKey);........}

/*** A factory function that generates, defines and returns the proxy class given* the ClassLoader and array of interfaces.*/private static final class ProxyClassFactory

被代理类
因此我们可以通过ProxyClassFactory尝试手动获取一下代理类的代码：
ps:另一个简单方法：1.8 版本代码前加System.getProperties().put(""sun.misc.ProxyGenerator.saveGeneratedFiles", "true");新版：System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");

//MyHelloProxy是类名，随便取的
byte[] classFile = ProxyGenerator.generateProxyClass("MyHelloProxy", DogHello.class.getInterfaces());String path = "D:/MyHelloProxy.class";try(FileOutputStream fos = new FileOutputStream(path)) {fos.write(classFile);fos.flush();System.out.println("ok");} catch (Exception e) {System.out.println("error");}

接下来看看里面的具体内容：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//import com.baiye.proxy.Hello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;public final class MyHelloProxy extends Proxy implements Hello {private static Method m1;private static Method m2;private static Method m3;private static Method m0;public MyHelloProxy(InvocationHandler var1) throws  {super(var1);}public final boolean equals(Object var1) throws  {......}public final String toString() throws  {......}public final void say(String var1) throws  {try {super.h.invoke(this, m3, new Object[]{var1});} catch (RuntimeException | Error var3) {throw var3;} catch (Throwable var4) {throw new UndeclaredThrowableException(var4);}}public final int hashCode() throws  {.....}static {try {m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));m2 = Class.forName("java.lang.Object").getMethod("toString");m3 = Class.forName("com.baiye.proxy.Hello").getMethod("say", Class.forName("java.lang.String"));m0 = Class.forName("java.lang.Object").getMethod("hashCode");} catch (NoSuchMethodException var2) {throw new NoSuchMethodError(var2.getMessage());} catch (ClassNotFoundException var3) {throw new NoClassDefFoundError(var3.getMessage());}}
}

可以看到，先在静态代码块中初始化所有方法，被代理类持有这些方法，然后在方法调用时：

super.h.invoke(this, m3, new Object[]{var1});

自此Proxy的原理也就明白了：上面这句话super.h指的是父类Proxy里的 protected InvocationHandler h;对象，也就是说被代理类继承Proxy并且所以InvocationHandler h对象，调用的最终是h的方法。