Java JDK 动态代理使用及实现原理分析

http://blog.jobbole.com/104433/

1、什么是代理？

代理是一种经常使用的设计模式，其目的就是为其余对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

代理模式UML图：

为了保持行为的一致性，代理类和委托类一般会实现相同的接口，因此在访问者看来二者没有丝毫的区别。经过代理类这中间一层，能有效控制对委托类对象的直接访问，也能够很好地隐藏和保护委托类对象，同时也为实施不一样控制策略预留了空间，从而在设计上得到了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

2、Java 动态代理类

Java动态代理类位于java.lang.reflect包下，通常主要涉及到如下两个类：

(1)Interface InvocationHandler：该接口中仅定义了一个方法

publicobject invoke(Object obj,Method method, Object[] args)

在实际使用时，第一个参数obj通常是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

(2)Proxy：该类即为动态代理类，其中主要包含如下内容：

protected Proxy(InvocationHandler h)：构造函数，用于给内部的h赋值。

static Class getProxyClass (ClassLoaderloader, Class[] interfaces)：得到一个代理类，其中loader是类装载器，interfaces是真实类所拥有的所有接口的数组。

static Object newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类能够看成被代理类使用(可以使用被代理类的在Subject接口中声明过的方法)

所谓DynamicProxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，而后该class就宣称它实现了这些interface。你固然能够把该class的实例看成这些interface中的任何一个来用。固然，这个DynamicProxy其实就是一个Proxy，它不会替你做实质性的工做，在生成它的实例时你必须提供一个handler，由它接管实际的工做。

在使用动态代理类时，咱们必须实现InvocationHandler接口

经过这种方式，被代理的对象(RealSubject)能够在运行时动态改变，须要控制的接口(Subject接口)能够在运行时改变，控制的方式(DynamicSubject类)也能够动态改变，从而实现了很是灵活的动态代理关系。

动态代理步骤：
1.建立一个实现接口InvocationHandler的类，它必须实现invoke方法
2.建立被代理的类以及接口
3.经过Proxy的静态方法
newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)建立一个代理
4.经过代理调用方法

3、JDK的动态代理怎么使用？

一、须要动态代理的接口：

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

package jiankunking;   /** * 须要动态代理的接口 */ public interface Subject {     /**      * 你好      *      * @param name      * @return      */     public String SayHello(String name);       /**      * 再见      *      * @return      */     public String SayGoodBye(); }

 

二、须要代理的实际对象

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

package jiankunking;   /** * 实际对象 */ public class RealSubject implements Subject {       /**      * 你好      *      * @param name      * @return      */     public String SayHello(String name)     {         return "hello " + name;     }       /**      * 再见      *      * @return      */     public String SayGoodBye()     {         return " good bye ";     } }

 

三、调用处理器实现类

 

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

package jiankunking;   import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method;     /** * 调用处理器实现类 * 每次生成动态代理类对象时都须要指定一个实现了该接口的调用处理器对象 */ public class InvocationHandlerImpl implements InvocationHandler {       /**      * 这个就是咱们要代理的真实对象      */     private Object subject;       /**      * 构造方法，给咱们要代理的真实对象赋初值      *      * @param subject      */     public InvocationHandlerImpl(Object subject)     {         this.subject = subject;     }       /**      * 该方法负责集中处理动态代理类上的全部方法调用。      * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行      *      * @param proxy  代理类实例      * @param method 被调用的方法对象      * @param args   调用参数      * @return      * @throws Throwable      */     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable     {         //在代理真实对象前咱们能够添加一些本身的操做         System.out.println("在调用以前，我要干点啥呢？");           System.out.println("Method:" + method);           //当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用         Object returnValue = method.invoke(subject, args);           //在代理真实对象后咱们也能够添加一些本身的操做         System.out.println("在调用以后，我要干点啥呢？");           return returnValue;     } }

 

四、测试

 

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

package jiankunking;   import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy;   /** * 动态代理演示 */ public class DynamicProxyDemonstration {     public static void main(String[] args)     {         //代理的真实对象         Subject realSubject = new RealSubject();                  /**          * InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发          * 其内部一般包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用.          * 即：要代理哪一个真实对象，就将该对象传进去，最后是经过该真实对象来调用其方法          */         InvocationHandler handler = new InvocationHandlerImpl(realSubject);             ClassLoader loader = realSubject.getClass().getClassLoader();         Class[] interfaces = realSubject.getClass().getInterfaces();         /**          * 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例          */         Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);           System.out.println("动态代理对象的类型："+subject.getClass().getName());           String hello = subject.SayHello("jiankunking");         System.out.println(hello); //        String goodbye = subject.SayGoodBye(); //        System.out.println(goodbye);     }   }

 

五、输出结果以下：

演示demo下载地址：http://download.csdn.net/detail/xunzaosiyecao/9597388

4、动态代理怎么实现的？

从使用代码中能够看出，关键点在：

 

 

 

 

 

 

Java

 

1	Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);

经过跟踪提示代码能够看出：当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用。

 

也就是说，当代码执行到：

subject.SayHello( “jiankunking”)这句话时，会自动调用InvocationHandlerImpl的invoke方法。这是为啥呢？

 

======横线之间的是代码跟分析的过程，不想看的朋友能够直接看结论======

如下代码来自:JDK1.8.0_92

既然生成代理对象是用的Proxy类的静态方newProxyInstance，那么咱们就去它的源码里看一下它到底都作了些什么？

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

public static Object newProxyInstance(ClassLoader loader,                                           Class>[] interfaces,                                           InvocationHandler h)         throws IllegalArgumentException     { //检查h 不为空，不然抛异常         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);             } //获取代理对象的构造方法（也就是$Proxy0(InvocationHandler h)）             final Constructor> cons = cl.getConstructor(constructorParams);             final InvocationHandler ih = h;             if (!Modifier.isPublic(cl.getModifiers())) {                 AccessController.doPrivileged(new PrivilegedAction() {                     public Void run() {                         cons.setAccessible(true);                         return null;                     }                 });             } //生成代理类的实例并把InvocationHandlerImpl的实例传给它的构造方法             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);         }     }

咱们再进去getProxyClass0方法看一下：

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

/**      * 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);     }

真相仍是没有来到，继续，看一下proxyClassCache

 

 

 

 

 

 

 

Java

 

1 2 3 4 5

/**      * a cache of proxy classes      */     private static final WeakCache[], Class>>         proxyClassCache = new WeakCache(new KeyFactory(), new ProxyClassFactory());

 

奥，原来用了一下缓存啊

那么它对应的get方法啥样呢？

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

/**      * 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> valuesMap = map.get(cacheKey);         if (valuesMap == null) { //putIfAbsent这个方法在key不存在的时候加入一个值,若是key存在就不放入             ConcurrentMap> oldValuesMap                 = map.putIfAbsent(cacheKey,                                   valuesMap = new ConcurrentHashMap());             if (oldValuesMap != null) {                 valuesMap = oldValuesMap;             }         }           // create subKey and retrieve the possible Supplier stored by that         // subKey from valuesMap         Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));         Supplier supplier = valuesMap.get(subKey);         Factory factory = null;           while (true) {             if (supplier != null) {                 // supplier might be a Factory or a CacheValue 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);                 }             }         }     }

咱们能够看到它调用了 supplier.get(); 获取动态代理类，其中supplier是Factory,这个类定义在WeakCach的内部。

 

来瞅瞅，get里面又作了什么？

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

public synchronized V get() { // serialize access             // re-check             Supplier supplier = valuesMap.get(subKey);             if (supplier != this) {                 // something changed while we were waiting:                 // might be that we were replaced by a CacheValue                 // or were removed because of failure ->                 // return null to signal WeakCache.get() to retry                 // the loop                 return null;             }             // else still us (supplier == this)               // create new value             V value = null;             try {                 value = Objects.requireNonNull(valueFactory.apply(key, parameter));             } finally {                 if (value == null) { // remove us on failure                     valuesMap.remove(subKey, this);                 }             }             // the only path to reach here is with non-null value             assert value != null;               // wrap value with CacheValue (WeakReference)             CacheValue cacheValue = new CacheValue(value);               // try replacing us with CacheValue (this should always succeed)             if (valuesMap.replace(subKey, this, cacheValue)) {                 // put also in reverseMap                 reverseMap.put(cacheValue, Boolean.TRUE);             } else {                 throw new AssertionError("Should not reach here");             }               // successfully replaced us with new CacheValue -> return the value             // wrapped by it             return value;         }     }

发现重点仍是木有出现，但咱们能够看到它调用了valueFactory.apply(key, parameter)方法：

 

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

/**      * A factory function that generates, defines and returns the proxy class given      * the ClassLoader and array of interfaces.      */     private static final class ProxyClassFactory         implements BiFunction[], Class>>     {         // prefix for all proxy class names         private static final String proxyClassNamePrefix = "$Proxy";           // next number to use for generation of unique proxy class names         private static final AtomicLong nextUniqueNumber = new AtomicLong();           @Override         public Class> apply(ClassLoader loader, Class>[] interfaces) {               Map, Boolean> interfaceSet = new IdentityHashMap(interfaces.length);             for (Class> intf : interfaces) {                 /*                  * Verify that the class loader resolves the name of this                  * interface to the same Class object.                  */                 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");                 }                 /*                  * Verify that the Class object actually represents an                  * interface.                  */                 if (!interfaceClass.isInterface()) {                     throw new IllegalArgumentException(                         interfaceClass.getName() + " is not an interface");                 }                 /*                  * Verify that this interface is not a duplicate.                  */                 if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {                     throw new IllegalArgumentException(                         "repeated interface: " + interfaceClass.getName());                 }             }               String proxyPkg = null;     // package to define proxy class in             int accessFlags = Modifier.PUBLIC | Modifier.FINAL;               /*              * Record the package of a non-public proxy interface so that the              * proxy class will be defined in the same package.  Verify that              * all non-public proxy interfaces are in the same package.              */             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) {                 // if no non-public proxy interfaces, use com.sun.proxy package                 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";             }               /*              * Choose a name for the proxy class to generate.              */             long num = nextUniqueNumber.getAndIncrement();             String proxyName = proxyPkg + proxyClassNamePrefix + num;               /*              * Generate the specified proxy class.              */             byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                 proxyName, interfaces, accessFlags);             try {                 return defineClass0(loader, proxyName,                                     proxyClassFile, 0, proxyClassFile.length);             } catch (ClassFormatError e) {                 /*                  * A ClassFormatError here means that (barring bugs in the                  * proxy class generation code) there was some other                  * invalid aspect of the arguments supplied to the proxy                  * class creation (such as virtual machine limitations                  * exceeded).                  */                 throw new IllegalArgumentException(e.toString());             }         }     }

经过看代码终于找到了重点：

 

 

 

 

 

 

 

Java

 

1 2	//生成字节码 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);

那么接下来咱们也使用测试一下，使用这个方法生成的字节码是个什么样子：

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

package jiankunking;   import sun.misc.ProxyGenerator;   import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy;   /** * 动态代理演示 */ public class DynamicProxyDemonstration {     public static void main(String[] args)     {         //代理的真实对象         Subject realSubject = new RealSubject();           /**          * InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发          * 其内部一般包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用.          * 即：要代理哪一个真实对象，就将该对象传进去，最后是经过该真实对象来调用其方法          */         InvocationHandler handler = new InvocationHandlerImpl(realSubject);           ClassLoader loader = handler.getClass().getClassLoader();         Class[] interfaces = realSubject.getClass().getInterfaces();         /**          * 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例          */         Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);           System.out.println("动态代理对象的类型："+subject.getClass().getName());           String hello = subject.SayHello("jiankunking");         System.out.println(hello);         // 将生成的字节码保存到本地，         createProxyClassFile();     }     private static void createProxyClassFile(){         String name = "ProxySubject";         byte[] data = ProxyGenerator.generateProxyClass(name,new Class[]{Subject.class});         FileOutputStream out =null;         try {             out = new FileOutputStream(name+".class");             System.out.println((new File("hello")).getAbsolutePath());             out.write(data);         } catch (FileNotFoundException e) {             e.printStackTrace();         } catch (IOException e) {             e.printStackTrace();         }finally {             if(null!=out) try {                 out.close();             } catch (IOException e) {                 e.printStackTrace();             }         }     }   }

咱们用jd-jui 工具将生成的字节码反编译：

 

 

 

 

 

 

 

Java

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; import jiankunking.Subject;   public final class ProxySubject   extends Proxy   implements Subject {   private static Method m1;   private static Method m3;   private static Method m4;   private static Method m2;   private static Method m0;      public ProxySubject(InvocationHandler paramInvocationHandler)   {     super(paramInvocationHandler);   }      public final boolean equals(Object paramObject)   {     try     {       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();     }     catch (Error|RuntimeException localError)     {       throw localError;     }     catch (Throwable localThrowable)     {       throw new UndeclaredThrowableException(localThrowable);     }   }      public final String SayGoodBye()   {     try     {       return (String)this.h.invoke(this, m3, null);     }     catch (Error|RuntimeException localError)     {       throw localError;     }     catch (Throwable localThrowable)     {       throw new UndeclaredThrowableException(localThrowable);     }   }      public final String SayHello(String paramString)   {     try     {       return (String)this.h.invoke(this, m4, new Object[] { paramString });     }     catch (Error|RuntimeException localError)     {       throw localError;     }     catch (Throwable localThrowable)     {       throw new UndeclaredThrowableException(localThrowable);     }   }      public final String toString()   {     try     {       return (String)this.h.invoke(this, m2, null);     }     catch (Error|RuntimeException localError)     {       throw localError;     }     catch (Throwable localThrowable)     {       throw new UndeclaredThrowableException(localThrowable);     }   }      public final int hashCode()   {     try     {       return ((Integer)this.h.invoke(this, m0, null)).intValue();     }     catch (Error|RuntimeException localError)     {       throw localError;     }     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("jiankunking.Subject").getMethod("SayGoodBye", new Class[0]);       m4 = Class.forName("jiankunking.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());     }   } }

这就是最终真正的代理类，它继承自Proxy并实现了咱们定义的Subject接口
也就是说：

 

 

 

 

 

 

 

Java

 

1	Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);

这里的subject实际是这个类的一个实例，那么咱们调用它的：

 

 

 

 

 

Java

 

1	public final String SayHello(String paramString)

就是调用咱们定义的InvocationHandlerImpl的 invoke方法：

======横线之间的是代码跟分析的过程，不想看的朋友能够直接看结论=======

5、结论

到了这里，终于解答了：
subject.SayHello(“jiankunking”)这句话时，为何会自动调用InvocationHandlerImpl的invoke方法？

由于JDK生成的最终真正的代理类，它继承自Proxy并实现了咱们定义的Subject接口，在实现Subject接口方法的内部，经过反射调用了InvocationHandlerImpl的invoke方法。

包含生成本地class文件的demo：http://download.csdn.net/detail/xunzaosiyecao/9597474

经过分析代码能够看出Java 动态代理，具体有以下四步骤：

1. 经过实现 InvocationHandler 接口建立本身的调用处理器；
2. 经过为 Proxy 类指定 ClassLoader 对象和一组 interface 来建立动态代理类；
3. 经过反射机制得到动态代理类的构造函数，其惟一参数类型是调用处理器接口类型；
4. 经过构造函数建立动态代理类实例，构造时调用处理器对象做为参数被传入。