InvocationHandler中invoke()方法的调用问题

最新推荐文章于 2022-06-05 22:43:29 发布
最新推荐文章于 2022-06-05 22:43:29 发布
阅读量1.5k 收藏 3
点赞数 1
分类专栏： java
  以下的内容部分参考了网络上的内容，在此对原作者表示感谢！

        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的说明，如下： 
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参数传递的即是代理类的实例。

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

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


//真实角色：实现了Subject的request()方法
public class RealSubject implements Subject{
	
	public void request(){
		System.out.println("From real subject.");
	}
}
//实现了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;
	}

}

//客户端：生成代理实例，并调用了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();
	}
}

运行结果如下：此处省略了包名，***代替
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的源码，完全可以解决动态代理的疑惑了。

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

        从Client中的代码看，可以从newProxyInstance这个方法作为突破口，我们先来看一下Proxy类中newProxyInstance方法的源代码： 
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赋值,如下： 
class Proxy{
	InvocationHandler h=null;
	protected Proxy(InvocationHandler h) {
		this.h = h;
	}
	...
}


class Proxy{
	InvocationHandler h=null;
	protected Proxy(InvocationHandler h) {
		this.h = h;
	}
	...
}


        来看一下这个继承了Proxy的$Proxy0的源代码： 
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);
		}
	}
}


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方法中使用反射来获取关于代理类的一些信息吧。
z2007130205
关注
专栏目录
InvocationHandler中invoke()方法的调用问题分析
08-28
"InvocationHandler中invoke()方法的调用问题分析" InvocationHandler 中的 invoke() 方法是 Java 语言中动态代理的关键所在。通过分析 invoke() 方法的调用问题，可以更好地理解 Java 中的动态代理机制。 首先，...
motan源码分析四：客户端调用服务
a1439226817的博客
03-30 2228
在第一章中，我们分析了服务的发布与注册，本章中将简单的分析一下客户端调用服务的代码及流程，本文将以spring加载的方式进行分析。 1.在DemoRpcClient类的main()方法中加载类： 1 2 3 ApplicationContext ctx = new ClassPathXmlApplicationContext(n
（Java）动态代理 InvocationHandler 和 Invoke
南淮北安的博客
04-27 2358
文章目录一、基本概念二、示例一三、示例二四、method.invoke 一、基本概念 Java 动态代理 有两个重要的类和接口InvocationHandler（接口）和Proxy（类），这一个类Proxy和接口InvocationHandler是我们实现动态代理的核心； InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的...
JDK的动态代理原理
A Dent in the Universe
09-09 2335
首先，invoke方法的完整形式如下：  Java代码   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable       {              method.invoke(obj, args);              return null
Java中InvocationHandler接口中第一个参数proxy详解
热门推荐
OceanSky的专栏
07-14 2万+
这两天在学习Java动态代理，上一篇文章我们详细的讲解了创建代理类的调用处理程序（实现InvocationHandler接口的类），获得代理对象的Proxy类，但是就发现InvocationHandler中的invoke方法中的第一个参数proxy好像从来没有用过，所以就开始在网上查询proxy的用途，最后在国外的网站上找到了不错的讲解stackoverflow.com,下面就根据自己的学习心得，...
远程对象方法调用(动态代理+socket).rar
07-11
当客户端调用代理对象的方法时，实际上触发的是`InvocationHandler`的`invoke`方法，从而将调用转发到远程服务器执行。 Socket通信是网络编程的基础，它提供了一种在不同计算机之间建立连接并交换数据的方式。在RMI...
黑马程序员------代理类中invoke方法注意点
04-04
`invoke`方法是Java动态代理中的核心方法，它位于`java.lang.reflect.InvocationHandler`接口中。本篇文章将深入探讨代理类中`invoke`方法的使用及其注意事项。 代理类主要用于实现AOP（面向切面编程），它可以提供...
InvocationHandler, Proxy机制
03-22
当通过`Proxy`类生成的代理对象上的任何方法被调用时，实际的工作都是由`InvocationHandler`的`invoke`方法完成的。`invoke`方法接受三个参数：被代理的对象、被调用的方法以及方法调用时的参数。开发者可以在这个...
java InvocationHandler
01-09
这种行为通常体现在调用代理对象的方法时，实际上会执行`InvocationHandler`中的`invoke`方法。 `InvocationHandler`接口只有一个方法： ```java Object invoke(Object proxy, Method method, Object[] args) ...
报错：java.lang.NullPointerException 空指针异常
qq_43551276的博客
10-31 1979
项目场景 当用Java做项目管理系统登录页面的时，涉及到一些安全问题需要用到Shiro(Java安全锁框架）、vue， 问题描述： 当用到ajax做验证登录的时候，报空指针异常java.lang.NullPointerException //原代码 function login() { //加载层 var index = layer.load(0, {shade: false}); //0代表加载的风格，支持0-2 $.ajax({ url:"/login",
架构系列——java动态代理中的InvocationHandler和Proxy
前方一片光明
04-13 5326
前言 先赞后看，此生必赚！ Java中动态代理的实现，主要是InvocationHandler和Proxy的使用。 可以通过以下步骤实现一个动态代理： 一、创建正常的接口以及实现类 这个挺简单吧，每个开发者都会的！ 1. 接口： public interface People { public void working(); } 2. 实现类： public class S...
Kotlin 动态代理 method.invoke(obj, args),报错:Cannot read the array length because “args“ is null
weixin_45391986的博客
06-05 3990
报错:Cannot read the array length because "args" is null
java map failed_java.lang.OutOfMemoryError: Map failed此报错如何解决
weixin_36262567的博客
02-16 1470
java.io.IOException: Map failed详细信息如下 ：java.lang.RuntimeException:java.io.IOException:Mapfailedatcom.fr.web.core.MessageRecorder.initWriter(UnknownSource)atcom.fr.web.core.MessageRecorder.write(...
20210507—Java_Proxy—代理模式简介
Terio的博客
05-07 222
Proxy学习记录 一、代理模式 代理是基于反射机制，使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑 1、什么是代理 举例： 代购， 中介，换ip，商家等等 比如有一家美国的大学， 可以对全世界招生。 留学中介（代理） 留学中介（代理）： 帮助这家美国的学校招生， 中介是学校的代理， 中介是代替学校完成招生功能。 代理特点： 1. 中介和代理他们要做的事情是一致的： 招生。 2. 中介是学校代理， 学校是目标。 3. 家长-
java开发文件上传出现错误NullPointerException空指针
杰少027
11-14 2053
java开发文件上传出现错误NullPointerException空指针 今天实现一个文件上传的功能，出现错误： java.lang.NullPointerException at com.whxh.upload.UploadController.upload(UploadController.java:16) at sun.reflect.NativeMethodAccessorImpl.in...
[问题记录]使用Dubbo时空指针java.lang.NullPointerException
墨落青衫
03-09 4754
错误信息 java.lang.NullPointerException: null at com.qsssyh.controller.UserController.getUser(UserController.java:25) ~[classes/:na] at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)...
java_基础_invoke方法第一个参数的意义
写bug的蚊子的博客
11-10 912
转载自：https://blog.csdn.net/weixin_36637758/article/details/95482724 Java 反射方法调用方法 method.invoke(Object obj, Object… args) 第一个参数的意义 近期看到 invoke 方法第一个参数的另外一种传法，如下： public class Event { public static final String TAG= "Event"; public static void test.
自动注入报空指针异常
11
04-25 1065
四月 16, 2017 7:08:03 下午 org.apache.catalina.core.StandardWrapperValve invoke严重: Servlet.service() for servlet [lixxxxxxxxxx] in context with path [] threw exception [Request processing failed; nested e...
invocationhandler的invoke
最新发布
03-16
InvocationHandler的invoke方法是Java动态代理中的核心方法，用于处理代理对象的方法调用。当代理对象的方法被调用时，JVM会自动调用InvocationHandler的invoke方法，并将代理对象、被调用的方法和方法参数等信息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值