本文内容纲要：

-动态代理的简要说明 -一、InvocationHandler(interface)的描述： -二、Proxy(Class)的描述： -简单的Java代理 -一、先定义一个接口Interface，添加两个方法。 -二、定义一个真实的实现上述接口的类，RealObject： -三、定义一个代理对象，也实现了上述的Interface接口： -四、SimpleMain在Main方法中，测试上述的结果： -五、运行的结果如下： -Java的动态代理 -一、创建一个继承了InvocationHandler的处理器：DynamicProxyHandler -二、我们写一个测试的Main方法，DynamicProxyMain： -三、运行结果如下： -Java动态代理的原理 -一、动态代理的关键代码就是Proxy.newProxyInstance(classLoader,interfaces,handler)，我们跟进源代码看看： -二、我们看一下newInstance方法的源代码： -三、当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke方法来进行调用。 -友情链接

Java动态代理机制的出现，使得Java开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。下面我们开始动态代理的学习。

目录导航

动态代理的简要说明 简单的Java代理 Java的动态代理 Java动态代理的原理 友情链接

动态代理的简要说明

在java的动态代理机制中，有两个重要的类或接口，一个是InvocationHandler(Interface)、另一个则是Proxy(Class)。

一、InvocationHandler(interface)的描述：

InvocationHandleristheinterfaceimplementedbytheinvocationhandlerofaproxyinstance. Eachproxyinstancehasanassociatedinvocationhandler.Whenamethodisinvokedonaproxyinstance,themethodinvocationisencodedanddispatchedtotheinvokemethodofitsinvocationhandler.

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法invoke方法：

Objectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable

这个方法接收三个参数和返回一个Object类型，它们分别代表的意思如下：

proxy：指代我们所代理的那个真实对象 method：指代的是我们所要调用真实对象的方法的Method对象 args：指代的是调用真实对象某个方法时接受的参数

返回的Object是指真实对象方法的返回类型，以上会在接下来的例子中加以深入理解。

thevaluetoreturnfromthemethodinvocationontheproxyinstance.

二、Proxy(Class)的描述：

Proxyprovidesstaticmethodsforcreatingdynamicproxyclassesandinstances,anditisalsothesuperclassofalldynamicproxyclassescreatedbythosemethods.

Proxy这个类的作用就是用来动态创建一个代理对象。我们经常使用的是newProxyInstance这个方法：

publicstaticObjectnewProxyInstance(ClassLoaderloader,Class<?>[]interfaces,InvocationHandlerh)throwsIllegalArgumentException

参数的理解：

//一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载 loader-theclassloadertodefinetheproxyclass //一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口 interfaces-thelistofinterfacesfortheproxyclasstoimplement //一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上 h-theinvocationhandlertodispatchmethodinvocationsto

返回结果的理解：一个代理对象的实例

aproxyinstancewiththespecifiedinvocationhandlerofaproxyclassthatisdefinedbythespecifiedclassloaderandthatimplementsthespecifiedinterfaces

简单的Java代理

我们创建一个Java项目用于对动态代理的测试与理解，项目结构如下：

一、先定义一个接口Interface，添加两个方法。

packagecom.huhx.proxy; publicinterfaceInterface{ voidgetMyName(); StringgetNameById(Stringid); }

二、定义一个真实的实现上述接口的类，RealObject：

packagecom.huhx.proxy; publicclassRealObjectimplementsInterface{ @Override publicvoidgetMyName(){ System.out.println("mynameishuhx"); } @Override publicStringgetNameById(Stringid){ System.out.println("argumentid:"+id); return"huhx"; } }

三、定义一个代理对象，也实现了上述的Interface接口：

packagecom.huhx.proxy; publicclassSimpleProxyimplementsInterface{ privateInterfaceproxied; publicSimpleProxy(Interfaceproxied){ this.proxied=proxied; } @Override publicvoidgetMyName(){ System.out.println("proxygetmyname"); proxied.getMyName(); } @Override publicStringgetNameById(Stringid){ System.out.println("proxygetnamebyid"); returnproxied.getNameById(id); } }

四、SimpleMain在Main方法中，测试上述的结果：

packagecom.huhx.proxy; publicclassSimpleMain{ privatestaticvoidconsume(Interfaceiface){ iface.getMyName(); Stringname=iface.getNameById("1"); System.out.println("name:"+name); } publicstaticvoidmain(String[]args){ consume(newRealObject()); System.out.println("========================================================"); consume(newSimpleProxy(newRealObject())); } }

五、运行的结果如下：

mynameishuhx argumentid:1 name:huhx ======================================================== proxygetmyname mynameishuhx proxygetnamebyid argumentid:1 name:huhx

Java的动态代理

完成了上述简单的Java代理，现在我们开始学习Java的动态代理，它比代理的思想更向前一步，因为它可以动态地创建代理并动态的处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的对策。下面我们通过案例来加深Java动态代理的理解：

一、创建一个继承了InvocationHandler的处理器：DynamicProxyHandler

packagecom.huhx.dynamicproxy; importjava.lang.reflect.InvocationHandler; importjava.lang.reflect.Method; importjava.util.Arrays; publicclassDynamicProxyHandlerimplementsInvocationHandler{ privateObjectproxied; publicDynamicProxyHandler(Objectproxied){ System.out.println("dynamicproxyhandlerconstuctor:"+proxied.getClass()); this.proxied=proxied; } @Override publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{ System.out.println("dynamicproxyname:"+proxy.getClass()); System.out.println("method:"+method.getName()); System.out.println("args:"+Arrays.toString(args)); ObjectinvokeObject=method.invoke(proxied,args); if(invokeObject!=null){ System.out.println("invokeobject:"+invokeObject.getClass()); }else{ System.out.println("invokeobjectisnull"); } returninvokeObject; } }

二、我们写一个测试的Main方法，DynamicProxyMain：

packagecom.huhx.dynamicproxy; importjava.lang.reflect.InvocationHandler; importjava.lang.reflect.Proxy; importcom.huhx.proxy.Interface; importcom.huhx.proxy.RealObject; publicclassDynamicProxyMain{ publicstaticvoidconsumer(Interfaceiface){ iface.getMyName(); Stringname=iface.getNameById("1"); System.out.println("name:"+name); } publicstaticvoidmain(String[]args)throwsException,SecurityException,Throwable{ RealObjectrealObject=newRealObject(); consumer(realObject); System.out.println("=============================="); //动态代理 ClassLoaderclassLoader=Interface.class.getClassLoader(); Class<?>[]interfaces=newClass[]{Interface.class}; InvocationHandlerhandler=newDynamicProxyHandler(realObject); Interfaceproxy=(Interface)Proxy.newProxyInstance(classLoader,interfaces,handler); System.out.println("indynamicproxyMainproxy:"+proxy.getClass()); consumer(proxy); } }

三、运行结果如下：

mynameishuhx argumentid:1 name:huhx ============================== dynamicproxyhandlerconstuctor:classcom.huhx.proxy.RealObject indynamicproxyMainproxy:classcom.sun.proxy.$Proxy0 dynamicproxyname:classcom.sun.proxy.$Proxy0 method:getMyName args:null mynameishuhx invokeobjectisnull dynamicproxyname:classcom.sun.proxy.$Proxy0 method:getNameById args:[1] argumentid:1 invokeobject:classjava.lang.String name:huhx

从以上输出结果，我们可以得出以下结论：

与代理对象相关联的InvocationHandler，只有在代理对象调用方法时，才会执行它的invoke方法 invoke的三个参数的理解：Objectproxy是代理的对象,Methodmethod是真实对象中调用方法的Method类,Object[]args是真实对象中调用方法的参数

Java动态代理的原理

一、动态代理的关键代码就是Proxy.newProxyInstance(classLoader,interfaces,handler)，我们跟进源代码看看：

publicstaticObjectnewProxyInstance(ClassLoaderloader,Class<?>[]interfaces,InvocationHandlerh)throwsIllegalArgumentException{ //handler不能为空 if(h==null){ thrownewNullPointerException(); } finalClass<?>[]intfs=interfaces.clone(); finalSecurityManagersm=System.getSecurityManager(); if(sm!=null){ checkProxyAccess(Reflection.getCallerClass(),loader,intfs); } /* *Lookuporgeneratethedesignatedproxyclass. */ //通过loader和接口，得到代理的Class对象 Class<?>cl=getProxyClass0(loader,intfs); /* *Invokeitsconstructorwiththedesignatedinvocationhandler. */ try{ finalConstructor<?>cons=cl.getConstructor(constructorParams); finalInvocationHandlerih=h; if(sm!=null&&ProxyAccessHelper.needsNewInstanceCheck(cl)){ //createproxyinstancewithdoPrivilegeastheproxyclassmay //implementnon-publicinterfacesthatrequiresaspecialpermission returnAccessController.doPrivileged(newPrivilegedAction<Object>(){ publicObjectrun(){ returnnewInstance(cons,ih); } }); }else{ //创建代理对象的实例 returnnewInstance(cons,ih); } }catch(NoSuchMethodExceptione){ thrownewInternalError(e.toString()); } }

二、我们看一下newInstance方法的源代码：

privatestaticObjectnewInstance(Constructor<?>cons,InvocationHandlerh){ try{ returncons.newInstance(newObject[]{h}); }catch(IllegalAccessException|InstantiationExceptione){ thrownewInternalError(e.toString()); }catch(InvocationTargetExceptione){ Throwablet=e.getCause(); if(tinstanceofRuntimeException){ throw(RuntimeException)t; }else{ thrownewInternalError(t.toString()); } } }

三、当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke方法来进行调用。

体现这句话的代码，我在源码中没有找到，于是我在测试类的main方法中加入以下代码：

if(proxyinstanceofProxy){ InvocationHandlerinvocationHandler=Proxy.getInvocationHandler(proxy); invocationHandler.invoke(proxy,realObject.getClass().getMethod("getMyName"),null);System.out.println("--------------------------------------");}

这段代码的输出结果如下，与上述中调用代理对象中的getMyName方法输出是一样的，不知道Jvm底层是否是这样判断的：

dynamicproxyhandlerconstuctor:classcom.huhx.proxy.RealObject dynamicproxyname:classcom.sun.proxy.$Proxy0 method:getMyName args:nullmynameishuhxinvokeobjectisnull--------------------------------------

友情链接

测试动态代理的源代码下载访问密码7d08

本文内容总结：动态代理的简要说明，一、InvocationHandler(interface)的描述：，二、Proxy(Class)的描述：，简单的Java代理，一、先定义一个接口Interface，添加两个方法。，二、定义一个真实的实现上述接口的类，RealObject：，三、定义一个代理对象，也实现了上述的Interface接口：，四、SimpleMain在Main方法中，测试上述的结果：，五、运行的结果如下：，Java的动态代理，一、创建一个继承了InvocationHandler的处理器：DynamicProxyHandler，二、我们写一个测试的Main方法，DynamicProxyMain：，三、运行结果如下：，Java动态代理的原理，一、动态代理的关键代码就是Proxy.newProxyInstance(classLoader,interfaces,handler)，我们跟进源代码看看：，二、我们看一下newInstance方法的源代码：，三、当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke方法来进行调用。，友情链接，

原文链接：https://www.cnblogs.com/huhx/p/dynamicTheoryAdvance.html