1. 全栈程序员必看首页

java动态代理中的invoke方法是如何被自动调用的「建议收藏」

全栈程序员-站长 • • 未分类 • 阅读 119

java动态代理中的invoke方法是如何被自动调用的「建议收藏」Java中动态代理的实现，关键就是这两个东西：Proxy、InvocationHandler，下面从InvocationHandler接口中的invoke方法入手，简单说明一下Java如何实现动态代理的。        首先，invoke方法的完整形式如下： Java代码  public Object invoke(Object proxy, Method m

大家好，又见面了，我是你们的朋友全栈君。

一、动态代理与静态代理的区别。
（1）Proxy类的代码被固定下来，不会因为业务的逐渐庞大而庞大；
（2）可以实现AOP编程，这是静态代理无法实现的；
（3）解耦，如果用在web业务下，可以实现数据层和业务层的分离。
（4）动态代理的优势就是实现无侵入式的代码扩展。
   静态代理这个模式本身有个大问题，如果类方法数量越来越多的时候，代理类的代码量是十分庞大的。所以引入动态代理来解决此类问题

二、动态代理

Java中动态代理的实现，关键就是这两个东西：Proxy、InvocationHandler，下面从InvocationHandler接口中的invoke方法入手，简单说明一下Java如何实现动态代理的。 
        首先，invoke方法的完整形式如下： 

Java代码  
收藏代码

  1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable  
  2.     {  
  3.   
  4.         method.invoke(obj, args);  
  5.   
  6.         return null;  
  7.     }  

        首先猜测一下，method是调用的方法，即需要执行的方法；args是方法的参数；proxy，这个参数是什么？以上invoke()方法的实现即是比较标准的形式，我们看到，这里并没有用到proxy参数。查看JDK文档中Proxy的说明，如下： 

Java代码  
收藏代码

  1. A method invocation on a proxy instance through one of its proxy interfaces will be dispatched to the invoke method of the instance’s invocation handler, passing the proxy instance,a java.lang.reflect.Method object identifying the method that was invoked, and an array of type Object containing the arguments.  

        由此可以知道以上的猜测是正确的，同时也知道，proxy参数传递的即是代理类的实例。 

        为了方便说明，这里写一个简单的例子来实现动态代理。 

       

Java代码  
收藏代码

  1. //抽象角色（动态代理只能代理接口）  
  2. public interface Subject {  
  3.       
  4.     public void request();  
  5. }  

Java代码  
收藏代码

  1. //真实角色：实现了Subject的request()方法  
  2. public class RealSubject implements Subject{  
  3.       
  4.     public void request(){  
  5.         System.out.println(“From real subject.”);  
  6.     }  
  7. }  

Java代码  
收藏代码

  1. //实现了InvocationHandler  
  2. public class DynamicSubject implements InvocationHandler  
  3. {  
  4.     private Object obj;//这是动态代理的好处，被封装的对象是Object类型，接受任意类型的对象  
  5.   
  6.     public DynamicSubject()  
  7.     {  
  8.     }  
  9.   
  10.     public DynamicSubject(Object obj)  
  11.     {  
  12.         this.obj = obj;  
  13.     }  
  14.   
  15.     //这个方法不是我们显示的去调用  
  16.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable  
  17.     {  
  18.         System.out.println(“before calling “ + method);  
  19.   
  20.         method.invoke(obj, args);  
  21.   
  22.         System.out.println(“after calling “ + method);  
  23.   
  24.         return null;  
  25.     }  
  26.   
  27. }  

Java代码  
收藏代码

  1. //客户端：生成代理实例，并调用了request()方法  
  2. public class Client {  
  3.   
  4.     public static void main(String[] args) throws Throwable{  
  5.         // TODO Auto-generated method stub  
  6.   
  7.         Subject rs=new RealSubject();//这里指定被代理类  
  8.         InvocationHandler ds=new DynamicSubject(rs);  
  9.         Class<?> cls=rs.getClass();  
  10.           
  11.         //以下是一次性生成代理  
  12.           
  13.         Subject subject=(Subject) Proxy.newProxyInstance(  
  14.                 cls.getClassLoader(),cls.getInterfaces(), ds);  
  15.           
  16.         //这里可以通过运行结果证明subject是Proxy的一个实例，这个实例实现了Subject接口  
  17.         System.out.println(subject instanceof Proxy);  
  18.           
  19.         //这里可以看出subject的Class类是$Proxy0,这个$Proxy0类继承了Proxy，实现了Subject接口  
  20.         System.out.println(“subject的Class类是：”+subject.getClass().toString());  
  21.           
  22.         System.out.print(“subject中的属性有：”);  
  23.           
  24.         Field[] field=subject.getClass().getDeclaredFields();  
  25.         for(Field f:field){  
  26.             System.out.print(f.getName()+“, “);  
  27.         }  
  28.           
  29.         System.out.print(“\n”+“subject中的方法有：”);  
  30.           
  31.         Method[] method=subject.getClass().getDeclaredMethods();  
  32.           
  33.         for(Method m:method){  
  34.             System.out.print(m.getName()+“, “);  
  35.         }  
  36.           
  37.         System.out.println(“\n”+“subject的父类是：”+subject.getClass().getSuperclass());  
  38.           
  39.         System.out.print(“\n”+“subject实现的接口是：”);  
  40.           
  41.         Class<?>[] interfaces=subject.getClass().getInterfaces();  
  42.           
  43.         for(Class<?> i:interfaces){  
  44.             System.out.print(i.getName()+“, “);  
  45.         }  
  46.   
  47.         System.out.println(“\n\n”+“运行结果为：”);  
  48.         subject.request();  
  49.     }  
  50. }  

Xml代码  
收藏代码

  1. 运行结果如下：此处省略了包名，***代替  
  2. true  
  3. subject的Class类是：class $Proxy0  
  4. subject中的属性有：m1, m3, m0, m2,   
  5. subject中的方法有：request, hashCode, equals, toString,   
  6. subject的父类是：class java.lang.reflect.Proxy  
  7. subject实现的接口是：cn.edu.ustc.dynamicproxy.Subject,   
  8.   
  9. 运行结果为：  
  10. before calling public abstract void ***.Subject.request()  
  11. From real subject.  
  12. after calling public abstract void ***.Subject.request()  

PS：这个结果的信息非常重要，至少对我来说。因为我在动态代理犯晕的根源就在于将上面的subject.request()理解错了，至少是被表面所迷惑，没有发现这个subject和Proxy之间的联系，一度纠结于最后调用的这个request()是怎么和invoke()联系上的，而invoke又是怎么知道request存在的。其实上面的true和class $Proxy0就能解决很多的疑问，再加上下面将要说的$Proxy0的源码，完全可以解决动态代理的疑惑了。 

        从以上代码和结果可以看出，我们并没有显示的调用invoke()方法，但是这个方法确实执行了。下面就整个的过程进行分析一下： 

        从Client中的代码看，可以从newProxyInstance这个方法作为突破口，我们先来看一下Proxy类中newProxyInstance方法的源代码： 

Java代码  
收藏代码

  1. public static Object newProxyInstance(ClassLoader loader,  
  2.         Class<?>[] interfaces,  
  3.         InvocationHandler h)  
  4. throws IllegalArgumentException  
  5. {  
  6.     if (h == null) {  
  7.         throw new NullPointerException();  
  8.     }  
  9.   
  10.     /* 
  11.      * Look up or generate the designated proxy class. 
  12.      */  
  13.     Class cl = getProxyClass(loader, interfaces);  
  14.   
  15.     /* 
  16.      * Invoke its constructor with the designated invocation handler. 
  17.      */  
  18.     try {  
  19.            /* 
  20.             * Proxy源码开始有这样的定义： 
  21.             * private final static Class[] constructorParams = { InvocationHandler.class }; 
  22.             * cons即是形参为InvocationHandler类型的构造方法 
  23.            */  
  24.         Constructor cons = cl.getConstructor(constructorParams);  
  25.         return (Object) cons.newInstance(new Object[] { h });  
  26.     } catch (NoSuchMethodException e) {  
  27.         throw new InternalError(e.toString());  
  28.     } catch (IllegalAccessException e) {  
  29.         throw new InternalError(e.toString());  
  30.     } catch (InstantiationException e) {  
  31.         throw new InternalError(e.toString());  
  32.     } catch (InvocationTargetException e) {  
  33.         throw new InternalError(e.toString());  
  34.     }  
  35. }  

        Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下几件事. 

        （1）根据参数loader和interfaces调用方法 getProxyClass(loader, interfaces)创建代理类$Proxy0.$Proxy0类 实现了interfaces的接口,并继承了Proxy类. 

        （2）实例化$Proxy0并在构造方法中把DynamicSubject传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下： 

Java代码  
收藏代码

  1. class Proxy{  
  2.     InvocationHandler h=null;  
  3.     protected Proxy(InvocationHandler h) {  
  4.         this.h = h;  
  5.     }  
  6.     …  
  7. }  

        来看一下这个继承了Proxy的$Proxy0的源代码： 

Java代码  
收藏代码

  1. public final class $Proxy0 extends Proxy implements Subject {  
  2.     private static Method m1;  
  3.     private static Method m0;  
  4.     private static Method m3;  
  5.     private static Method m2;  
  6.   
  7.     static {  
  8.         try {  
  9.             m1 = Class.forName(“java.lang.Object”).getMethod(“equals”,  
  10.                     new Class[] { Class.forName(“java.lang.Object”) });  
  11.   
  12.             m0 = Class.forName(“java.lang.Object”).getMethod(“hashCode”,  
  13.                     new Class[0]);  
  14.   
  15.             m3 = Class.forName(“***.RealSubject”).getMethod(“request”,  
  16.                     new Class[0]);  
  17.   
  18.             m2 = Class.forName(“java.lang.Object”).getMethod(“toString”,  
  19.                     new Class[0]);  
  20.   
  21.         } catch (NoSuchMethodException nosuchmethodexception) {  
  22.             throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
  23.         } catch (ClassNotFoundException classnotfoundexception) {  
  24.             throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
  25.         }  
  26.     } //static  
  27.   
  28.     public $Proxy0(InvocationHandler invocationhandler) {  
  29.         super(invocationhandler);  
  30.     }  
  31.   
  32.     @Override  
  33.     public final boolean equals(Object obj) {  
  34.         try {  
  35.             return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();  
  36.         } catch (Throwable throwable) {  
  37.             throw new UndeclaredThrowableException(throwable);  
  38.         }  
  39.     }  
  40.   
  41.     @Override  
  42.     public final int hashCode() {  
  43.         try {  
  44.             return ((Integer) super.h.invoke(this, m0, null)).intValue();  
  45.         } catch (Throwable throwable) {  
  46.             throw new UndeclaredThrowableException(throwable);  
  47.         }  
  48.     }  
  49.   
  50.     public final void request() {  
  51.         try {  
  52.             super.h.invoke(this, m3, null);  
  53.             return;  
  54.         } catch (Error e) {  
  55.         } catch (Throwable throwable) {  
  56.             throw new UndeclaredThrowableException(throwable);  
  57.         }  
  58.     }  
  59.   
  60.     @Override  
  61.     public final String toString() {  
  62.         try {  
  63.             return (String) super.h.invoke(this, m2, null);  
  64.         } catch (Throwable throwable) {  
  65.             throw new UndeclaredThrowableException(throwable);  
  66.         }  
  67.     }  
  68. }  

        接着把得到的$Proxy0实例强制转换成Subject，并将引用赋给subject。当执行subject.request()方法时，就调用了$Proxy0类中的request()方法，进而调用父类Proxy中的h的invoke()方法.即InvocationHandler.invoke()。 

PS：1、需要说明的一点是，Proxy类中getProxyClass方法返回的是Proxy的Class类。之所以说明，是因为我一开始犯了个低级错误，以为返回的是“被代理类的Class类”- -！推荐看一下getProxyClass的源码，很长=。= 

        2、从$Proxy0的源码可以看出，动态代理类不仅代理了显示定义的接口中的方法，而且还代理了java的根类Object中的继承而来的equals()、hashcode()、toString()这三个方法，并且仅此三个方法。 

Q：到现在为止，还有一个疑问，invoke方法中的第一个参数是Proxy的实例（准确说，最终用到的是$Proxy0的实例），但是有什么用呢？或者说，程序内是怎样显示出作用的？ 

A：就本人目前的水平看来，这个proxy参数并没有什么作用，在整个动态代理机制中，并没有用到InvocationHandler中invoke方法的proxy参数。而传入的这个参数实际是代理类的一个实例。我想可能是为了让程序员在invoke方法中使用反射来获取关于代理类的一些信息吧。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/131910.html原文链接：https://javaforall.net

赞 (1)
全栈程序员-站长的头像全栈程序员-站长
0 0

相关推荐

  • 什么是java构造函数_什么是java构造函数

    什么是java构造函数_什么是java构造函数

    什么是java构造函数_什么是java构造函数构造函数是面向对象中的一员，构造函数可以叫做构造器，它的函数名与类名相同，不用定义返回值类型，也没有具体的返回值。构造函数是在构建创造时对象时调用函数，作用是可以给对象进行初始化，创建对象都必须要通过构造函数初始化。一个类中如果没有定义过构造函数，那么该类会有一个默认的空参数构造函数。如果在类中定义了指定的构造函数，那么该类中的默认构造函数就没有了。我们人出生的时候，有些人一出生之后再起名字的，但…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年7月8日
  • IOC 控制反转[通俗易懂]

    IOC 控制反转[通俗易懂]

    IOC 控制反转[通俗易懂]SpringFramework概述https://blog.csdn.net/centrl/article/details/115519480通过前面的学习，我们至少已经知道IOC，下面我们就来说说IOC是个什么东西。1.写在前面首先来想一件事，作为程序员，怎么开发程序才最巴适？我觉得最起码有两点：开发简单、升级简单。开发简单，就是我们只管写业务逻辑（培养只会写if-else的程序员）。 升级简单，这里也包含两点：我们使用的技术（可理解为框架）出了什么问…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年6月16日
  • Python怎么取整(Python程序打包)

    Python怎么取整(Python程序打包)

    Python取整方式：背景在处理数据的时候，碰到了一个问题，就是取整方式！比如给定一个数值型列表，我需要分别获取它位置为长度的0%,25%,50%,75%,100%处的几个数字。但Python自带的int是向下取整，如果数字长度是5，理论上这五个数字分别对应0%,25%,50%,75%,100%的位置，但使用int，结果却并不是入次。比如当5*0.75时,如果加上int(5*0.7

    全栈程序员-站长的头像 全栈程序员-站长
    2022年4月16日
  • 黑盒测试的等价类划分法_黑盒测试等价类输出

    黑盒测试的等价类划分法_黑盒测试等价类输出

    黑盒测试的等价类划分法_黑盒测试等价类输出1、等价类划分2、边界值分析

    全栈程序员-站长的头像 全栈程序员-站长
    2022年10月3日
  • 脚手架专项施工方案范本_脚手架工程施工方案主要内容

    脚手架专项施工方案范本_脚手架工程施工方案主要内容

    脚手架专项施工方案范本_脚手架工程施工方案主要内容前言如何快速搭建一个httprunner项目呢？我们可以使用脚手架，脚手架就是自动地创建一些目录，形成一个项目的架构，不需要我们再手动的去创建查看创建新项目的命令先来查看一下帮助命令httpr

    全栈程序员-站长的头像 全栈程序员-站长
    2022年7月28日
  • 谷歌搜索好用吗_谷歌搜索引擎搜索技巧

    谷歌搜索好用吗_谷歌搜索引擎搜索技巧

    谷歌搜索好用吗_谷歌搜索引擎搜索技巧0前言相信大家在使用搜索引擎的时候，大部分情况下都是直接输入要搜索的关键词，然后在搜索结果里一个个点开查找。但除了特定信息外，搜索引擎同时也会返回大量无关的信息。有时候我们可能翻好几页也不一定能找到满意的结果，平白增加不少的工作量。其实，有一些特殊的技巧，可以对搜索结果进行限制和筛选，缩小检索范围，让搜索结果更加准确，大大提高我们的效率。下面，扩展迷就给大家介绍一些在进行谷歌搜索时可以使用的便捷技巧。其中，部分技巧在其他搜索引擎中也同样支持。文章目录0前言1.强制精确匹配2.AND

    全栈程序员-站长的头像 全栈程序员-站长
    2022年8月30日

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号