在《springAOP之代理模式》中说了代理模式，包含静态代理和动态代理，在动态代理模式中又分为JDK动态代理和CGlib动态代理，今天重点来看JDK动态代理。
一、概述
说到JDK动态代理就必须想到JDK动态代理要求有一个统一的接口，那为什么要有接口，下面会说到，下面看我的接口类，
package cn.com.jdk.proxy; public interface Subject { void sayHello(String a); }
接口类很简单就是一个简单的方法定义。下面看实际的接口的实现类SubjectImpl，
package cn.com.jdk.proxy; public class SubjectImpl implements Subject { @Override public void sayHello(String a) { // TODO Auto-generated method stub System.out.println("hello:"+a); } }
实现类简单的事项了Subject接口，进行了打印操作。下面看代理类
package cn.com.jdk.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class JDKProxy implements InvocationHandler { private SubjectImpl si; //此属性不用管 private String a; /** * proxy JDK动态生成的代理类的实例 * method 目标方法的Method对象 Class.forName("cn.com.jdk.proxy.Subject").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") }); * args 目标方法的参数 new Object[] { paramString } */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub System.out.println("before"); //使用反射的放式调用si（被代理类）目标方法 Object o=method.invoke(si, args); System.out.println("after"); return o; } public JDKProxy(SubjectImpl si,String a) { this.si=si; this.a=a; } }
上面是代理类的实现，在代理类中含义被代理类的一个引用，且提供了响应的构造方法。下面具体的使用，
package cn.com.jdk.proxy; import java.lang.reflect.Proxy; public class ProxyTest { public static void main(String[] args) { // TODO Auto-generated method stub //进行此项设置，可以在项目的com/sun/proxy目录下找到JDK动态生成的代理类的字节码文件 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); SubjectImpl si=new SubjectImpl(); Subject subject=(Subject)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), new JDKProxy(si,"111")); subject.sayHello("tom"); } }
上面是使用的代码，通过Proxy类的newProxyInstance方法获得一个Subject的实例，调用sayHello方法，下面看执行结果
before
hello:tom
after
可以看到执行了sayHello方法，且打印了before和after，这不正是代理类中invoke方法的执行吗，看下面
很神奇的一件事，我们不光调用了sayHello方法，实现了打印，而且在加入了自己的打印方法，这不正是AOP的增强功能吗。这一切是怎么发生的那，下面细细说来。
二、详述
上面，我们又复习了JDK动态代理的内容，以及演示了如何使用JDK动态代理，下面我们要看这是怎么实现的，先从测试的下面这段代码说起，也是最重要的代码，JDK动态代理的精华都在这句代码里，
Subject subject=(Subject)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), new JDKProxy(si,"111"));
这句代码是调用了Proxy类的newProxyInstance方法，此方法的入参如下，
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
一共三个参数，一个是ClassLoader，这里传入的是被代理对象的类加载器；一个是Class，这里传入的是被代理对象所实现的接口；一个是InvocationHandler，这里传入的是代理类，代理类实现了InvocationHandler接口。
1、newProxyInstance方法
下面看newProxyInstance方法的定义，
@CallerSensitive 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. */ //1、使用代理类的类加载器和其所实现的接口，动态生成代理类 Class<?> cl = getProxyClass0(loader, intfs); /* * Invoke its constructor with the designated invocation handler. */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } //2、返回JDK生成的代理类的构造方法，该构造方法的参数为 // InvocationHandler 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; } }); }
//3、返回该构造方法的一个实例，也就是使用InvocationHandler为参数的构造方法利用反射的机制返回一个实例。 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); } }
该方法中有三步比较重要，上面的注释已经标出。
1.1、getProxyClass0(loader, intfs)方法
该方法便是上面的第一步，这一步的作用是JDK返回一个代理类的实例，方法上的注释如下，
/* * Look up or generate the designated proxy class. */ Class<?> cl = getProxyClass0(loader, intfs);
注释直译过来是查找或者生成指定的代理类，这里有两层意思，一个是查找，第二个是生成，由此可以想到这个方法中应该有缓存，下面看方法的具体定义，
/** * Generate a proxy class. Must call the checkProxyAccess method * to perform permission checks before calling this. */ 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 ProxyClassFactory return proxyClassCache.get(loader, interfaces); }
这个方法很简单，判断了接口的数量，大于65535便抛异常，接口的数量大于65535的可能性不大。最后调用了proxyClassCache的get方法，首先看proxyClassCache，从字面上理解是代理类的缓存，看其定义，
/** * a cache of proxy classes */ private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
是一个WeakCache对象实例，看下该构造方法，
/** * Construct an instance of {@code WeakCache} * * @param subKeyFactory a function mapping a pair of * {@code (key, parameter) -> sub-key} * @param valueFactory a function mapping a pair of * {@code (key, parameter) -> value} * @throws NullPointerException if {@code subKeyFactory} or * {@code valueFactory} is null. */ public WeakCache(BiFunction<K, P, ?> subKeyFactory, BiFunction<K, P, V> valueFactory) { this.subKeyFactory = Objects.requireNonNull(subKeyFactory); this.valueFactory = Objects.requireNonNull(valueFactory); }
看了该类的构造方法后，回到proxyClassCache.get(loader, interfaces)方法的调用，我们已经知道proxyClassCache是WeakCache的一个实例，那么get方法如下，
/** * Look-up the value through the cache. This always evaluates the * {@code subKeyFactory} function and optionally evaluates * {@code valueFactory} function if there is no entry in the cache for given * pair of (key, subKey) or the entry has already been cleared. * * @param key possibly null key * @param parameter parameter used together with key to create sub-key and * value (should not be null) * @return the cached value (never null) * @throws NullPointerException if {@code parameter} passed in or * {@code sub-key} calculated by * {@code subKeyFactory} or {@code value} * calculated by {@code valueFactory} is null. */ public 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 cacheKey ConcurrentMap<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 valuesMap Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); Supplier<V> supplier = valuesMap.get(subKey); Factory factory = null; while (true) { if (supplier != null) { // supplier might be a Factory or a CacheValue<V> instance V value = supplier.get(); if (value != null) { return value; } } // else no supplier in cache // or a supplier that returned null (could be a cleared CacheValue // or a Factory that wasn't successful in installing the CacheValue) // lazily construct a Factory if (factory == null) { factory = new Factory(key, parameter, subKey, valuesMap); } if (supplier == null) { supplier = valuesMap.putIfAbsent(subKey, factory); if (supplier == null) { // successfully installed Factory supplier = factory; } // else retry with winning supplier } else { if (valuesMap.replace(subKey, supplier, factory)) { // successfully replaced // cleared CacheEntry / unsuccessful Factory // with our Factory supplier = factory; } else { // retry with current supplier supplier = valuesMap.get(subKey); } } } }
上面是WeakCache的get方法，这个方法暂时不作说明，后面会详细介绍WeakCache类，请参见《JDK动态代理之WeakCache 》。这里只需记住该get方法会返回一个代理类的实例即可。那么此代理类是如何定义的那？
1.1.1、$Proxy0.class代理类
这个代理类是JDK动态生成的，其命名规则为以“$”开头+Proxy+“从0开始的序列”。上面在测试的时候，我们加入了下面这行代码，
//进行此项设置，可以在项目的com/sun/proxy目录下找到JDK动态生成的代理类的字节码文件 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
注释中写到可以生成代理类的字节码文件，下面是使用反编译工具过来的java代码，
package com.sun.proxy; import cn.com.jdk.proxy.Subject; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; public final class $Proxy0 extends Proxy implements Subject { private static Method m1; private static Method m3; private static Method m2; private static Method m0; //参数为InvocationHandler的构造方法 public $Proxy0(InvocationHandler paramInvocationHandler) throws { //调用父类Proxy的构造方法，在父类的构造方法中会初始化h属性 super(paramInvocationHandler); } public final boolean equals(Object paramObject) throws { try { return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue(); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } //实现的Subject的sayHello方法 public final void sayHello(String paramString) throws { try { //调用h的invoke方法，这里的h指的是实现了InvocationHandler的类 //调用其中的invoke方法，在本例中是调用JDKProxy类中的invoke方 //法 this.h.invoke(this, m3, new Object[] { paramString }); return; } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } public final String toString() throws { try { return (String)this.h.invoke(this, m2, null); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } public final int hashCode() throws { try { return ((Integer)this.h.invoke(this, m0, null)).intValue(); } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m3 = Class.forName("cn.com.jdk.proxy.Subject").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") }); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { } throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } }
上面是反编译过来的JDK生成的代理类的代码，包含了一个使用InvocationHandler作为参数的构造方法，以及实现了Subject接口的sayHello方法。上面注释中写到该构造方法调用了其父类Proxy的构造方法，下面看其父类Proxy的构造方法，
protected Proxy(InvocationHandler h) { Objects.requireNonNull(h); this.h = h; }
把InvocationHandler的值赋给了h，h的定义如下，
protected InvocationHandler h;
那么在生成的代理类中自然会继承该属性，所以在代理类中的sayHello中使用下面的方法调用，
public final void sayHello(String paramString) throws { try { this.h.invoke(this, m3, new Object[] { paramString }); return; } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); }
上面的this.h便是其父类的h属性。在上面的this.h.invoke中的m3是怎么来的那，看下面，
static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m3 = Class.forName("cn.com.jdk.proxy.Subject").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") }); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { } throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); }
在该类的静态代码块中给出了4个属性。
1.2、getConstructor(constructorParams)方法
在上面的getProxyClass0方法中我们知道该方法会返回一个JDK生成代理类的Class对象，此类的定义便是上面的$Proxy0.class类。其定义在上面已经分析过。getConstructor方法要返回一个以constructorParams为参数的构造方法，
@CallerSensitive public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException { checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true); return getConstructor0(parameterTypes, Member.PUBLIC); }
调用了getConstuctor0方法返回一个public的构造方法，
private Constructor<T> getConstructor0(Class<?>[] parameterTypes, int which) throws NoSuchMethodException { Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC)); for (Constructor<T> constructor : constructors) { if (arrayContentsEq(parameterTypes, constructor.getParameterTypes())) { return getReflectionFactory().copyConstructor(constructor); } } throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes)); }
上面的方法会返回一个public的构造方法。
回到最初的调用，我们看getConstructor方法的参数是constructorParams，此属性定义如下，
/** parameter types of a proxy class constructor */ private static final Class<?>[] constructorParams = { InvocationHandler.class };
是一个Class数组，其类型为InvocationHandler。这样便可以知道是通过代理类的Class对象返回其构造方法cons。有了构造方法下面便是通过构造方法生成实例。
1.3、cons.newInstance(new Object[]{h})方法
此方法便是通过构造方法返回一个代理类的实例。
上面分析了Proxy的newProxyInstance方法，此方法最终会返回一个代理类的实例，会经过下面几个步骤，
从上面的步骤，我们知道在获得代理类的构造方法时，是获得其参数为InvocationHandler的构造方法，所以肯定要实现InvocationHandler接口，在本例中便是JDKProxy类，这个类实现了这个接口。值开篇我们讲到JDK动态代理必须要有统一的接口，从上面的步骤中我们知道在生成代理类的Class对象时使用了两个参数，一个ClassLoader，另一个是接口，这里就是为什么要有统一的接口，因为在生成代理类的Class对象中需要接口，所以被代理类必须要有一个接口。
2、方法调用
这里的方法调用，便是对应使用方法中的下面这行代码，
subject.sayHello("tom");
在上面的分析中获得了一个代理类的实例，即下面这行代码，
Subject subject=(Subject)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), new JDKProxy(si,"111"));
通过使用被代理类的类加载器、被代理类所实现的接口、实现了InvocationHandler接口的类的实例三个参数，返回了一个代理类的实例。上面已经详细分析过。此代理类的实例继承了Proxy，实现了Subject接口。其sayHello方法如下，
public final void sayHello(String paramString) throws { try { this.h.invoke(this, m3, new Object[] { paramString }); return; } catch (RuntimeException localRuntimeException) { throw localRuntimeException; } catch (Throwable localThrowable) { } throw new UndeclaredThrowableException(localThrowable); }
上面已经分析过，this.h是InvocationHandler的实例，这里便是new JDKProxy(si,"111")，m3是m3 = Class.forName("cn.com.jdk.proxy.Subject").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });下面看JDKProxy中的invoke方法，
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub System.out.println("before"); //使用反射的放式调用目标方法 Object o=method.invoke(si, args); System.out.println("after"); return o; }
此方法的三个参数分别为代理类的实例、Method对象（sayHello），调用sayHello时的参数，所以要调用被代理类的sayHello方法，需要这样写：method.invoke(si,args)，即调用被代理类（SubjectImpl）的sayHello方法，参数为args（tom）。下面是一个简单的方法调用过程，
三、总结
本文分析了JDK动态代理的简单使用方法及背后的原理，有不当之处欢迎指正，感谢！