从零开始探索jdk动态代理

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量124 收藏
点赞数 1
文章标签： java proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdnyqfyqf/article/details/105262822
版权

文章目录

前言

最近正在学习Spring，和以往一样，学习资料的来源依然是万能的3W。作为一个非专业IT人，以往的我并没有整理笔记的习惯，但最近的记忆力给我带来了些许困扰。于是本人的博客之旅就这样开始了…
作为第一篇博文，为了不打击自己的积极性，内容上主要参考了知乎大大bravo1988，若有侵权望告知。
言归正传，Spring的核心是控制反转（IOC）和面向切面（AOP），而AOP的底层实现便是本文的核心–动态代理。

1.代理模式

百度百科中代理模式是这样定义的：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式的UML图如下：
代理模式UML图
代理模式一般分为静态代理和动态代理，为了直观的描述静态代理和动态代理，下面以一个例子来说明。
假设我们现在有个类Student如下：

public class Student {
	
	public String getSex(int stu_id){
		String sex = stu_id==1?"Girl":"ToDo";
			return sex;
	}
	
	public int getAge(int stu_id){
		int age = stu_id==1?15:-1;
		return age;
	}
}

现在要完成如下需求：在对象的每个方法前后加上方法开始及结束说明。

1.1静态代理

静态代理指在程序运行前已经存在代理类的字节码文件，静态代理的原理可以用下图表示。
static_proxy_1
为了完成上述需求，计划定义如下三个类
1.Student接口Interface Student
2.Student接口实现类StudentImpl（真实对象类）
3.Student接口代理类StudentProxy（代理对象类）

public interface Student {
	public String getSex(int stu_id);
	
	public int getAge(int stu_id);
}

public class StudentImpl implements Student{
	
	public String getSex(int stu_id){
		String sex = stu_id==1?"Girl":"ToDo";
			return sex;
	}
	
	public int getAge(int stu_id){
		int age = stu_id==1?15:-1;
		return age;
	}
}


public class StudentProxy implements Student{
	public Student realSubject;
	
	public StudentProxy(Student realSubject){
		this.realSubject = realSubject;
	}
	
	public String getSex(int stu_id){
		System.out.println("getSex方法开始");
		String sex = realSubject.getSex(stu_id);
		System.out.println("getSex方法结束");
			return sex;
	}
	
	public int getAge(int stu_id){
		System.out.println("getAge方法开始");
		int age = realSubject.getAge(stu_id);
		System.out.println("getAge方法开始");
		return age;
	}
}

下面开始测试

public class StudentStaticProxyTest {
	public static void main(String args[]){
		Student student = new StudentProxy(new StudentImpl());
		int stu_id=1;
		String sex = student.getSex(stu_id);
		System.out.println(stu_id+"号学生性别"+sex);
		int age = student.getAge(stu_id);
		System.out.println(stu_id+"号学生年龄为"+age);
	}
}

测试结果如下
test_result
通过静态代理完成了需求，但从实现的方法看静态代理存在着如下缺陷：
1.每个方法都需要添加说明，若方法有很多个，代理类编码效率低
2.当需求改变时，代理类每个方法都要改变，不易修改维护
3.一个代理类只能实现一种接口的代理，如果有许多接口需要代理，工作量较大

通过上述分析，代理类只是用于生成代理对象，代理对象才是最终需求，那么能不能直接通过对象接口动态生成代理对象呢？
其实这些问题前辈们早已做了探索，JDK中便存在着这样的方法，接下来将详细介绍JDK动态代理。

1.2 JDK动态代理

同样还是以上文提及的需求为例开始介绍。在介绍静态代理的时候，为了实现Student类的代理，编写了StudentProxy类，这正是静态代理存在着的缺陷，需要为每一个代理对象编写代理类。那么能不能不通过定义代理类直接生成代理对象呢？
这里先回顾一下java对象是如何生成的。
在这里插入图片描述
由此可见对象是由class字节码生成的，这刚好解决了上述问题，可以不通过定义代理类直接由class加载到内存生成的字节码生成对象，找啊找，终于在jdk中找到了直接生成Class的方法。
在这里插入图片描述
但仔细查看，又遇到了新问题，Class的构造方法是Private类型，外部无法调用，看来只能找其他的方法了。
又开始了jdk探索之旅，看看JDK中有没有方法可以通过代理接口类得到class，不负众望，在Proxy类中果然存在着gteProxyClass这样一个静态方法。
在这里插入图片描述
和当初期望的一样，只需传入代理对象接口的类加载器，代理对象的接口无需代理类就可以返回一个代理对象。有了这个方法，下面可以测试了。
首先做一个准备工作，看一下真实对象的接口及实现类的Class

public class ClassTest {
	public static void main(String[] args) { 
	/*Student接口的Class对象 得到Class对象的三种方式：
	 * 1.Class.forName(xxx) 
	 * 2.xxx.class 
	 * 3.xxx.getClass() 
	 * 注意，这并不是我们new了一个Class对象，而是让虚拟机加载并创建Class对象
	 */ 
	 Class<Student> studentClass = Student.class; 
	 //Student接口的构造器信息 
	 Constructor[] studentClassConstructors = studentClass.getConstructors(); 
	 //Student接口的方法信息 
	 Method[] studentClassMethods = studentClass.getMethods(); 
	 //打印 
	 System.out.println("------接口Class的构造器信息------"); 
	 printClassInfo(studentClassConstructors); 
	 System.out.println("------接口Class的方法信息------"); 
	 printClassInfo(studentClassMethods); 
	 //Student实现类的Class对象
	 Class<StudentImpl> studentImplClass = StudentImpl.class; 
	 //Student实现类的构造器信息 
	 Constructor<?>[] studentImplClassConstructors = studentImplClass.getConstructors();
	 //Student实现类的方法信息 
	 Method[] studentImplClassMethods = studentImplClass.getMethods();
	 //打印
	 System.out.println("------实现类Class的构造器信息------");
	 printClassInfo(studentImplClassConstructors); 
	 System.out.println("------实现类Class的方法信息------"); 
	 printClassInfo(studentImplClassMethods); 
	 } 
public static void printClassInfo(Executable[] targets){ 
	for (Executable target : targets) { 
		// 构造器/方法名称 
		String name = target.getName(); 
		StringBuilder sBuilder = new StringBuilder(name); 
		// 拼接左括号 
		sBuilder.append('('); 
		Class[] clazzParams = target.getParameterTypes(); 
		// 拼接参数
		for(Class clazzParam : clazzParams){ 
			sBuilder.append(clazzParam.getName()).append(','); } 
		//删除最后一个参数的逗号
		if(clazzParams!=null && clazzParams.length != 0) 
		{ sBuilder.deleteCharAt(sBuilder.length()-1); } 
		//拼接右括号 
		sBuilder.append(')'); 
		//打印 构造器/方法 
		System.out.println(sBuilder.toString()); 
		} 
}

}

在这里插入图片描述
从上述结果可以看出接口Class没有构造方法，实现类Class除了有接口的方法还有从Object类继承的方法
接着用getProxyClass进行测试

public class StudentDynamicProxyTest {
	public static void main(String[] args) { 

		Class studentProxyClass = Proxy.getProxyClass(
				Student.class.getClassLoader(), Student.class); 
		//以Student实现类的Class对象作对比，看看代理Class是什么类型 
		System.out.println(StudentImpl.class.getName()); 
		System.out.println(studentProxyClass.getName()); 
		//打印代理Class对象的构造器 
		Constructor[] constructors = studentProxyClass.getConstructors(); 
		System.out.println("----构造器----"); 
		printClassInfo(constructors); 
		//打印代理Class对象的方法
		Method[] methods = studentProxyClass.getMethods(); 
		System.out.println("----方法----"); 
		printClassInfo(methods); } 
	public static void printClassInfo(Executable[] targets) { 
		for (Executable target : targets) { 
			// 构造器/方法名称 
			String name = target.getName(); 
			StringBuilder sBuilder = new StringBuilder(name); 
			// 拼接左括号 
			sBuilder.append('('); 
			Class[] clazzParams = target.getParameterTypes();
			// 拼接参数 
			for (Class clazzParam : clazzParams) {
				sBuilder.append(clazzParam.getName()).append(','); } 
			//删除最后一个参数的逗号
			if (clazzParams != null && clazzParams.length != 0) 
			{ sBuilder.deleteCharAt(sBuilder.length() - 1); } 
			//拼接右括号 
			sBuilder.append(')'); 
			//打印 构造器/方法 
			System.out.println(sBuilder.toString()); 
			} 
		} 
}

在这里插入图片描述
从上述结果可以看出通过给Proxy.getProxyClass()传入对象接口加载器和接口类，得到了一个强化版的Class：即包含接口的方法信息getAge()、getSex()，又包含了构造器$Proxy0(InvocationHandler)，还有一些自己特有的方法以及从Object继承的方法。
既然这个Class既有方法信息，又有构造器，下一步通过它生成一个代理对象

public class StudentDynamicProxyTest {
	public static void main(String[] args) throws Throwable{ 
		
		Class studentProxyClass = Proxy.getProxyClass(
				Student.class.getClassLoader(), Student.class);
		Constructor constructor = studentProxyClass.getConstructor(InvocationHandler.class);
		Student studentProxyImpl = (Student)constructor.newInstance(new InvocationHandler(){
			@Override
			public Object invoke(Object proxy ,Method method,Object[] args){
				
				return null;
			}
		});
		System.out.println(studentProxyImpl.getAge(1));
		System.out.println(studentProxyImpl.getSex(1));
		} 
}

在这里插入图片描述
居然报了空指针错误，联想到前面，只有在nvocationHandler的invoke()返回null，难道是因为这个？带着疑问，编写如下测试类

public class StudentDynamicProxyTest {
	public static void main(String[] args) throws Throwable{ 
		
		Class studentProxyClass = Proxy.getProxyClass(
				Student.class.getClassLoader(), Student.class);
		Constructor constructor = studentProxyClass.getConstructor(InvocationHandler.class);
		Student studentProxyImpl = (Student)constructor.newInstance(new InvocationHandler(){
			@Override
			public Object invoke(Object proxy ,Method method,Object[] args){
				
				return 1;
			}
		});
		System.out.println(studentProxyImpl.getAge(1));
		System.out.println(studentProxyImpl.getSex(1));
		} 
}

在这里插入图片描述
将返回值改为1后，getAge方法不报错，getSex方法报错，并报出Integer无法转为String的错误，据此推测每次调用代理对象的方法都会调用invoke,而且invoke的返回值就是代理方法的返回值，正是因为getAge返回值为整型，而invoke返回值被设为1所以此方法不报错，而返回值为String的getSex方法报错。
通过推理动态代理的Class大致如下
在这里插入图片描述
这样设计有一个明显的有点，方法与方法体分离耦合性降低。
但是最终的需求是调用真实对象的方法，那么如何调用呢？注意到invoke函数的后面两个参数，方法及方法参数，由于代理对象和真实对象继承于同一个接口，方法是同名的，可以通过方法的反射调用执行真实对象，具体测试如下。

public class Test3 {
	public static void main(String[] args) throws Throwable {

		StudentImpl target = new StudentImpl(); 
		//传入目标对象 
		//目的：1.根据它实现的接口生成代理对象 2.代理对象调用目标对象方法
		Student studentProxy = (Student) getProxy(target);
		studentProxy.getAge(1); 
		studentProxy.getSex(1); 
		} 
	private static Object getProxy(final Object target) throws Exception { 
		//参数1：随便找个类加载器给它， 参数2：目标对象实现的接口，让代理对象实现相同接口 
		Class proxyClass = Proxy.getProxyClass(
				target.getClass().getClassLoader(), target.getClass().getInterfaces()); 
		Constructor constructor = proxyClass.getConstructor(InvocationHandler.class); 
		Object proxy = constructor.newInstance(new InvocationHandler() { 
			@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
				System.out.println(method.getName() + "方法开始"); 
				Object result = method.invoke(target, args); 
				System.out.println(result); System.out.println(method.getName() + "方法结束"); 
				return result; } });
		return proxy; } 
}

在这里插入图片描述
到这jdk动态代理的原理基本了解了，当然前辈们早已准备了更简单的方法
在这里插入图片描述
此时是不是顿时感觉神清气爽，但是方法的提示依旧在invoke函数体中，耦合性大，不利于后期扩展，那么有没有好的办法能将其抽离呢？答案是肯定的
定义一个Log接口及实现类

public interface Log {
	
	public void beforeMethod(Method method);
	
	public void afterMethod(Method method);
	
}

public class LogImpl implements Log{
	public void beforeMethod(Method method){
		System.out.println(method.getName() + "方法开始"); 
	};
	
	public void afterMethod(Method method){
		System.out.println(method.getName() + "方法结束"); 
	};
}

测试类如下

public class Test4 {
	public static void main(String[] args) throws Throwable {

		StudentImpl target = new StudentImpl(); 
		//传入目标对象 
		//目的：1.根据它实现的接口生成代理对象 2.代理对象调用目标对象方法
		Student studentProxy = (Student) getProxy(target,new LogImpl());
		studentProxy.getAge(1); 
		studentProxy.getSex(1); 
		} 
	private static Object getProxy(final Object target ,Log log) throws Exception { 
		/*代理对象的方法最终都会被JVM导向它的invoke方法*/
		Object proxy = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),/*类加载器*/
				target.getClass().getInterfaces(),/*让代理对象和目标对象实现相同接口*/
				(proxy1, method, args) -> {
					log.beforeMethod(method); 
					Object result = method.invoke(target, args); 
					System.out.println(result); 
					log.afterMethod(method); 
					return result; 
				}
				);
		return proxy; 
	}
}

在这里插入图片描述
其实Spring的AOP实现原理大概也就是这样了，只是细节更复杂一点。

一只鱼~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jdk动态代理课程代码.rar
08-02
在这个“jdk动态代理课程代码”中，我们很可能会看到如何利用这些工具来实现动态代理的示例。 首先，我们需要理解静态代理和动态代理的基本概念。静态代理是我们在编译时期就已经知道了代理类的实现，通过创建一个...
Java JDK动态代理实现原理实例解析
08-19
Java JDK动态代理实现原理实例解析 Java JDK动态代理实现原理实例解析是指通过Java JDK提供的代理机制来实现动态代理的原理和实例解析。动态代理是一种非常重要的设计模式，它可以在运行时生成代理类，从而实现了...
一文读懂Java动态代理
潘潘和他的朋友们
11-22 419
作者 ：潘潘 日期 ：2020-11-22 事实上，对于很多Java编程人员来说，可能只需要达到从入门到上手的编程水准，就能很好的完成大部分研发工作。除非自己强主动获取，或者工作倒逼你学习，否则我们好像没必要去真正了解Java编程，或者深入研究JDK运行原理、或者在实际工作中某个模块写一套设计模式、或者纠结一个线程安全问题。 我觉得完全没必要了解，因为很多知识内容，我技术储备上仅仅点到为止，就能胜任工作，何必深入？确实，我也和有些朋友一样，8年编程生涯以来大部分时候都存在这种思想，直到某一天突然有机会来.
探索AI创新的前沿——从零开始学习和运用SpringAI
qq_51447436的博客
06-16 4663
探索AI创新的前沿——从零开始学习和运用SpringAI
一文读懂 Java 动态代理
weixin_70730532的博客
05-13 240
事实上，对于很多 Java 编程人员来说，可能只需要达到从入门到上手的编程水准，就能很好的完成大部分研发工作。除非自己强主动获取，或者工作倒逼你学习，否则我们好像没必要去真正了解 Java 编程，或者深入研究 JDK 运行原理、或者在实际工作中某个模块写一套设计模式、或者纠结一个线程安全问题。 我觉得完全没必要了解，因为很多知识内容，我技术储备上仅仅点到为止，就能胜任工作，何必深入？确实，我也和有些朋友一样，8 年编程生涯以来大部分时候都存在这种思想，直到某一天突然有机会来了，你就要负责某个系统的架构
Java | 静态代理与动态代理真的超简单
petterp的博客
04-06 252
静态代理: 由我们开发者自己手动创建或者在程序运行前就已经存在的代理类，静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。 动态代理: 在程序运行时，运用java反射机制动态创建而成，静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道，通常动态代理实现方式是通过实现 jdk 的 InvocationHandler 接口的 invoke 方法 代码实践 需要代理的接口 interface IBook { fun toBookName(name: Strin
Java 动态代理机制分析及扩展，第 1 部分
GarfieldEr007的专栏
12-18 823
引言 Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。通过阅读本文，读者将会对 Java 动态代理机制有更加深入的理解。本文首先从 Java 动态代理的运行机制
java学习笔记13--反射机制与动态代理
GarfieldEr007的专栏
03-22 1212
本文地址：http://www.cnblogs.com/archimedes/p/java-study-note13.html，转载请注明源地址。 Java的反射机制 在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。 这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Ref
java Rpc之java动态代理
shadowsama的博客
10-02 417
https://www.ibm.com/developerworks/cn/java/j-lo-proxy1/ Java 动态代理机制分析及扩展，第 1 部分 王 忠平 和 何 平 2010 年 1 月 21 日发布 WeiboGoogle+用电子邮件发送本页面   13
Java 动态代理机制分析及扩展
王仁一的博客
04-25 104
Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。通过阅读本文，读者将会对 Java 动态代理机制有更加深入的理解。本文首先从 Java 动态代理的运行机制和特点出发，...
Android面试：JDK动态代理的原理
2401_84132204的博客
04-09 663
doAfter();return res;// 动态代理和静态代理的唯一区别，就是在获取代理对象的时候，静态代理获取的是一个不可变功能的对象，一旦获取到，那么它的功能也就确定了// 而，动态代理，// 先看看这个对象在debug的时候，是怎么样的一个对象引用// 现在，出现了一个 购买女性用品的接口，和它的实现类，也要用代理来访问// 这样做。
Jdk动态代理 底层
01-20
java动态代理主要有2种，Jdk动态代理、Cglib动态代理，本文主要讲解Jdk动态代理的使用、运行机制、以及源码分析。当spring没有手动开启Cglib动态代理，即：或@EnableAspectJAutoProxy(proxyTargetClass = true)，...
JDK动态代理源码
11-30
在Java编程领域，JDK动态代理是一个非常重要的概念，它允许我们在运行时动态地创建一个实现了特定接口的代理对象，以此来拦截并扩展原有对象的行为。动态代理在很多场景下都有应用，比如AOP（面向切面编程）、事件...
Spring JDK动态代理实现过程详解
08-25
Spring JDK 动态代理实现过程详解 在本文中，我们将详细介绍 Spring JDK 动态代理的实现过程。dynamic proxy 是一种非常重要的技术，在 Spring 框架中应用非常广泛。通过本文的学习，你将了解到 JDK 动态代理的实现...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 568
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 671
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 697
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1203
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
jdk动态代理和cglib动态代理
09-20
jdk动态代理和cglib动态代理是Java中常用的两种动态代理方式。jdk动态代理是基于接口实现的代理方式，而cglib动态代理则是基于继承实现的代理方式。 在jdk动态代理中，代理类通过实现InvocationHandler接口，并重写...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值