首页 / JAVA / java动态代理中的invoke方法是如何被自动调用的

java动态代理中的invoke方法是如何被自动调用的

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java动态代理中的invoke方法是如何被自动调用的，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8953字，纯文字阅读大概需要13分钟。

内容图文

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

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

Java代码
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{

    method.invoke(obj, args);  

    return null;  
}  

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

Java代码
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代码
//抽象角色（动态代理只能代理接口）
public interface Subject {

public void request();

}

Java代码
//真实角色：实现了Subject的request()方法
public class RealSubject implements Subject{

public void request(){  
    System.out.println("From real subject.");  
}

}

Java代码
//实现了InvocationHandler
public class DynamicSubject implements InvocationHandler
{
private Object obj;//这是动态代理的好处，被封装的对象是Object类型，接受任意类型的对象

public DynamicSubject()  
{  
}  

public DynamicSubject(Object obj)  
{  
    this.obj = obj;  
}  

//这个方法不是我们显示的去调用  
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable  
{  
    System.out.println("before calling " + method);  

    method.invoke(obj, args);  

    System.out.println("after calling " + method);  

    return null;  
}

}

Java代码
//客户端：生成代理实例，并调用了request()方法
public class Client {

public static void main(String[] args) throws Throwable{  
    // TODO Auto-generated method stub  

    Subject rs=new RealSubject();//这里指定被代理类  
    InvocationHandler ds=new DynamicSubject(rs);  
    Class<?> cls=rs.getClass();  
      
    //以下是一次性生成代理  
      
    Subject subject=(Subject) Proxy.newProxyInstance(  
            cls.getClassLoader(),cls.getInterfaces(), ds);  
      
    //这里可以通过运行结果证明subject是Proxy的一个实例，这个实例实现了Subject接口  
    System.out.println(subject instanceof Proxy);  
      
    //这里可以看出subject的Class类是$Proxy0,这个$Proxy0类继承了Proxy，实现了Subject接口  
    System.out.println("subject的Class类是："+subject.getClass().toString());  
      
    System.out.print("subject中的属性有：");  
      
    Field[] field=subject.getClass().getDeclaredFields();  
    for(Field f:field){  
        System.out.print(f.getName()+", ");  
    }  
      
    System.out.print("\n"+"subject中的方法有：");  
      
    Method[] method=subject.getClass().getDeclaredMethods();  
      
    for(Method m:method){  
        System.out.print(m.getName()+", ");  
    }  
      
    System.out.println("\n"+"subject的父类是："+subject.getClass().getSuperclass());  
      
    System.out.print("\n"+"subject实现的接口是：");  
      
    Class<?>[] interfaces=subject.getClass().getInterfaces();  
      
    for(Class<?> i:interfaces){  
        System.out.print(i.getName()+", ");  
    }  

    System.out.println("\n\n"+"运行结果为：");  
    subject.request();  
}

}

Xml代码
运行结果如下：此处省略了包名，***代替
true
subject的Class类是：class $Proxy0
subject中的属性有：m1, m3, m0, m2,
subject中的方法有：request, hashCode, equals, toString,
subject的父类是：class java.lang.reflect.Proxy
subject实现的接口是：cn.edu.ustc.dynamicproxy.Subject,

运行结果为：
before calling public abstract void ***.Subject.request()
From real subject.
after calling public abstract void ***.Subject.request()

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

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

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

Java代码
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}

/* 
 * Look up or generate the designated proxy class. 
 */  
Class cl = getProxyClass(loader, interfaces);  

/* 
 * Invoke its constructor with the designated invocation handler. 
 */  
try {  
       /* 
        * Proxy源码开始有这样的定义： 
        * private final static Class[] constructorParams = { InvocationHandler.class }; 
        * cons即是形参为InvocationHandler类型的构造方法 
       */  
    Constructor cons = cl.getConstructor(constructorParams);  
    return (Object) cons.newInstance(new Object[] { h });  
} catch (NoSuchMethodException e) {  
    throw new InternalError(e.toString());  
} catch (IllegalAccessException e) {  
    throw new InternalError(e.toString());  
} catch (InstantiationException e) {  
    throw new InternalError(e.toString());  
} catch (InvocationTargetException e) {  
    throw new InternalError(e.toString());  
}

}

    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代码
class Proxy{
InvocationHandler h=null;
protected Proxy(InvocationHandler h) {
this.h = h;
}
…
}

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

Java代码
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;

static {  
    try {  
        m1 = Class.forName("java.lang.Object").getMethod("equals",  
                new Class[] { Class.forName("java.lang.Object") });  

        m0 = Class.forName("java.lang.Object").getMethod("hashCode",  
                new Class[0]);  

        m3 = Class.forName("***.RealSubject").getMethod("request",  
                new Class[0]);  

        m2 = Class.forName("java.lang.Object").getMethod("toString",  
                new Class[0]);  

    } catch (NoSuchMethodException nosuchmethodexception) {  
        throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
    } catch (ClassNotFoundException classnotfoundexception) {  
        throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
    }  
} //static  

public $Proxy0(InvocationHandler invocationhandler) {  
    super(invocationhandler);  
}  

@Override  
public final boolean equals(Object obj) {  
    try {  
        return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();  
    } catch (Throwable throwable) {  
        throw new UndeclaredThrowableException(throwable);  
    }  
}  

@Override  
public final int hashCode() {  
    try {  
        return ((Integer) super.h.invoke(this, m0, null)).intValue();  
    } catch (Throwable throwable) {  
        throw new UndeclaredThrowableException(throwable);  
    }  
}  

public final void request() {  
    try {  
        super.h.invoke(this, m3, null);  
        return;  
    } catch (Error e) {  
    } catch (Throwable throwable) {  
        throw new UndeclaredThrowableException(throwable);  
    }  
}  

@Override  
public final String toString() {  
    try {  
        return (String) super.h.invoke(this, m2, null);  
    } catch (Throwable throwable) {  
        throw new UndeclaredThrowableException(throwable);  
    }  
}

}

    接着把得到的$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://blog.csdn.net/zcc_0015/article/details/22695647
版权声明：本文为博主原创文章，转载请附上博文链接！

内容总结

以上是互联网集市为您收集整理的java动态代理中的invoke方法是如何被自动调用的全部内容，希望文章能够帮你解决java动态代理中的invoke方法是如何被自动调用的所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

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

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/840310.html

来源：【匿名】

【上一篇】老菜鸟致青春，程序员应该选择java 还是 c#-【下一篇】JAVA/JSP学习系列之五

更多 ►

【java动态代理中的invoke方法是如何被自动调用的】教程文章相关的互联网学习教程文章

java动态代理技术【代码】【图】

主要用来做方法的增强，让你可以在不修改源码的情况下，增强一些方法，在方法执行前后做任何你想做的事情（甚至根本不去执行这个方法），因为在InvocationHandler的invoke方法中，你可以直接获取正在调用方法对应的Method对象，具体应用的话，比如可以添加调用日志，做事务控制等。还有一个有趣的作用是可以用作远程调用，比如现在有Java接口，这个接口的实现部署在其它服务器上，在编写客户端代码的时候，没办法直接调用接口方法...

java 动态代理的学习详解【图】

再讲java动态代理前，先来看看代理模式。 Proxy类通过组合，对Hello类进行了增强，并对其进行了委托。代理模式代码：public class ProxyPattern { interface IHello{ void say() ; } static class Hello implements IHello{ public void say(){ System.out.println("hello world"); } } static class Proxy implements IHello{ IHello iHello ; public Proxy(IHell...

【Java】代处理？代理模式 - 静态代理，动态代理【代码】

>不用代理有时候，我希望在一些方法前后都打印一些日志，于是有了如下代码。这是一个处理float类型加法的方法，我想在调用它前打印一下参数，调用后打印下计算结果。（至于为什么不直接用+号运算，见【Java】Float计算不准确）package com.nicchagil.study.java.demo.No09代理.No01不用代理;import java.math.BigDecimal;publicclass FloatCalculator {publicfloat add(float a, float b) {BigDecimal b1 = new BigDecimal(a + ""...

Java动态代理模式 -- 保护代理【代码】

意义将接口的调用统一到一个函数里处理，然后再去具体实例调用相应的方法,充当一个分发器的作用user -> handler -> method字典动态：指的是在程序运行时才创建代理类代理：与被代理类具有相同的属性，也就是被代理类有run方法，它也有run方法保护代理：限制接口类的某些方法给特定的对象使用Proxy类：Java反射包自带，其中newProxyInstance可以返回接口实现类的实例组成1.接口Person类：其中有name与score相关的方法自己本人可以修...

java的静态代理和2种动态代理（未完，待续）【代码】【图】

package com.liubingfei.test.proxy.staticproxy;/*** @author LiuBingFei* @desc 接口，定义抽象方法：卖房子，出租房子。* @date 2020/3/5 22:09* @return*/publicinterface house {//卖房子publicabstractvoid sell_house();//出租房子publicabstractvoid rental_house(); } package com.liubingfei.test.proxy.staticproxy;/*** @author LiuBingFei* @desc* @date 2020/3/5 22:12* @return*/publicclass house_owner implement...

java动态代理Proxy【代码】【图】

package com.gz_06;publicinterface StudentDao {publicvoid login();publicvoid regist(); } package com.gz_06;publicclass StudentDaoImpl implements StudentDao{@Overridepublicvoid login() {System.out.println("登陆");}@Overridepublicvoid regist() {System.out.println("注册");}} package com.gz_06;publicclass StudentDaoImpl2 implements StudentDao{@Overridepublicvoid login() {System.out.println("权限验证");...

java提供类与cglib包实现动态代理【代码】

终于有点空余时间，决定把之前学习的知识点整理一下，备以后复习。动态代理有三角色：抽象角色，代理角色，真是角色。第一个记录下java提供的动态代理。即使用Proxy类和InvocationHandel接口。直接上贴上代码：class MyInvocationHandel implements InvocationHandler{private Object obj; //这是原对象//传入源对象，返回代理对象public Object bind(Object obj){this.obj=obj;return Proxy.newProxyInstance(obj.getClass()....

Java代理模式（静态代理&动态代理）【代码】

一、概述　　定义：为其他对象提供一种代理，以控制这个对象的访问。　　代理模式的种类：静态代理和动态代理二、静态代理　　ps：我们创建一个Book用于基础操作，再创建一个JavaBook用来代理Book类的功能。　　1.Book.javapackage com.yw.reflectjavalib.proxy.staticproxy;/*** 定义一个book实体* create by yangwei* on 2020-02-16 17:48*/ public class Book {public void doWork() {System.out.println("读书");} }2.JavaBook...

Java 动态代理实现解析

Java动态代理只能针对接口进行动态代理。如果需要对类进行实现代理可以使用:CGLIB,ASM等相关的操作字节码实现（在这里先只介绍下SUN 基于接口动态代理的实现）。代码如下：import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;public class ProxyTest {public static void main(String[] args) {/* 设置此系统属性,让JVM生成的Proxy类写入文件.保存路径为：com/sun/pro...

java动态代理实现与原理详细分析【代码】【图】

关于Java中的动态代理，我们首先需要了解的是一种常用的设计模式--代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。一、代理模式代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身...

java动态代理复习【代码】

package com.free.testProxy;import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;/** * 动态代理的三个条件 * 1.有接口 * 2.被代理类实现了该接口 * 3.创建代理类 * */publicclass ProxyConnection {private Connection connection;public Connection Getproxy() {Connection connection = (Connection)Proxy.newProxyInstance(jdbcConnection.class.getClassLoader()...

java 获取动态代理生成的 Class 文件【代码】

一获取 JDK 动态代理生成的 Class 文件　　1.1 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");此方式只能在爱main函数中使用　　1.2　　　　　　　FileOutputStream out = null;try {byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", DaoImpl.class.getInterfaces());out = new FileOutputStream(filePath[0] + "$Proxy0.class");out.write(classFile);} catch (Excepti...

java反射机制与动态代理

在学习HadoopRPC时，用到了函数调用，函数调用都是采用的java的反射机制和动态代理来实现的，所以现在回顾下java的反射和动态代理的相关知识。一、反射JAVA反射机制定义： JAVA反射机制是java程序在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。反射就是把Java类中的各种成分映射成相...