欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

带你重新认识Java动态代理

程序员文章站 2022-03-12 21:27:39
目录什么是动态代理?动态代理的常用两种方式:1.基于接口的动态代理2.基于类的动态代理基于子类的动态代理总结:什么是动态代理?动态代理就是,在程序运行期,创建目标对象的代理对象,并对目标对象中的方法进...

什么是动态代理?

动态代理就是,在程序运行期,创建目标对象的代理对象,并对目标对象中的方法进行功能性增强的一种技术。在生成代理对象的过程中,目标对象不变,代理对象中的方法是目标对象方法的增强方法。可以理解为运行期间,对象中方法的动态拦截,在拦截方法的前后执行功能操作(也可以对原方法的参数进行操作)。

代理类在程序运行期间,创建的代理对象称之为动态代理对象。这种情况下,创建的代理对象,并不是事先在java代码中定义好的。而是在运行期间,根据我们在动态代理对象中的“指示”,动态生成的。也就是说,你想获取哪个对象的代理,动态代理就会为你动态的生成这个对象的代理对象。动态代理可以对被代理对象的方法进行功能增强。有了动态代理的技术,那么就可以在不修改方法源码的情况下,增强被代理对象的方法的功能,在方法执行前后做任何你想做的事情。

特点:字节码随用随创建,随用随加载

作用:不修改源码的基础上对方法增强

正常类创建对象的过程:

带你重新认识Java动态代理

动态代理创建代理对象的过程:

带你重新认识Java动态代理

动态代理的常用两种方式:

1.基于接口的动态代理

提供者:jdk

使用jdk官方的proxy类创建代理对象

注意:代理的目标对象必须实现接口(至少一个)

2.基于类的动态代理

提供者:第三方 cglib

使用cglib的enhancer类创建代理对象

注意:被代理类不能用 final 修饰的类(最终类)。如果报 asmxxxx 异常,需要导入 asm.jar包

//jdk动态代理(基于接口的动态代理)
proxy.newproxyinstance(三个参数);
	classloader:类加载器
		它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。(固定写法)
	class[]:字节码数组
		它是用于让代理对象和被代理对象有相同方法。(固定写法)
	invocationhandler:用于提供增强的代码
		它是让我们写如何代理。我们一般都是写一个该接口的实现类,通常情况下都是匿名内部类,但不是必须
		invocationhandler该接口的实现类是谁用谁写,此时我们用就需要我们自己写

此处以一个演员的例子为例:

在很久以前,演员和剧组都是直接见面联系的。没有中间人环节。

而随着时间的推移,产生了一个新兴职业:经纪人(中间人),这个时候剧组再想找演员就需要通过经纪人来找了。下面我们就用代码演示出来。

package com.haust.service;
public interface iactor {
	/**
	* 基本演出
	* @param money
	*/
	public void basicact(float money);
	/**
	* 危险演出
	* @param money
	*/
	public void dangeract(float money);
}
package com.haust.serviceimpl;
import com.haust.service.iactor;
public class actor implements iactor {
	/**
	* 一个演员
	*/
	//实现了接口,就表示具有接口中的方法实现。即:符合经纪公司的要求
	@override
	public void basicact(float money) {
		system.out.println("拿到钱,开始基本的表演:"+money);
	}
	@override
	public void dangeract(float money) {
		system.out.println("拿到钱,开始危险的表演:"+money);
	}
}
package com.haust.test;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
import com.haust.service.iactor;
import com.haust.serviceimpl.actor;
public class client {
	public static void main(string[] args) {
		//一个剧组找演员:
		final actor actor = new actor();//被代理的类
		/**
		* 代理:
		* 间接。
		* 获取代理对象:
		* 要求:
		* 被代理类最少实现一个接口
		* 创建的方式
		* proxy.newproxyinstance(三个参数)
		* 参数含义:
		* classloader:和被代理对象使用相同的类加载器。
		* interfaces:和被代理对象具有相同的行为。实现相同的接口。
		* invocationhandler:如何代理。
		* 
		*/
		//(iactor)proxy.newproxyinstance,这里强制转换必须是接口类型
		iactor proxyactor = (iactor)proxy.newproxyinstance(actor.getclass().getclassloader(),
				 actor.getclass().getinterfaces(),
				 new invocationhandler() {
			 /**
			 * 执行被代理对象的任何方法,都会经过该方法。
			 * 此方法有拦截的功能。
			 * 
			 * 参数:
			 * proxy:代理对象的引用。不一定每次都用得到
			 * method:当前执行的方法对象
			 * args:执行方法所需的参数
			 * 返回值:
			 * 当前执行被代理对象方法的返回值
			 */
					@override
					public object invoke(object proxy, method method, object[] args) throws throwable {
						string name = method.getname();
						float money = (float) args[0];//执行的方法只有一个参数
						object rtvalue = null;
						//每个经纪公司对不同演出收费不一样,此处开始判断
						if("basicact".equals(name)){
						//基本演出,没有 2000 不演
						if(money > 2000){
						//看上去剧组是给了 8000,实际到演员手里只有 4000
						//这就是我们没有修改原来 basicact 方法源码,对方法进行了增强
						rtvalue = method.invoke(actor, money/2);
						} }
						if("dangeract".equals(name)){
						//危险演出,没有 5000 不演
						if(money > 5000){
						//看上去剧组是给了 50000,实际到演员手里只有 25000
						//这就是我们没有修改原来 dangeract 方法源码,对方法进行了增强
						rtvalue = method.invoke(actor, money/2);
						} }
						return rtvalue;
					}
				});
		//没有经纪公司的时候,直接找演员。
		// actor.basicact(1000f);
		// actor.dangeract(5000f);
		//剧组无法直接联系演员,而是由经纪公司找的演员
		proxyactor.basicact(2000f);//价格低于2000不演
		proxyactor.dangeract(50000f);
		
	}
}

总结:

首先需要创建一个interface然后一个class实现这个interface,然后对这个class进行代理,这个class必须实现至少一个接口

基于子类的动态代理

设计的类:enhancer
提供者:第三方cglib库
如何创建代理对象:
	使用enhancer类中的create方法
创建代理对象的要求:
	被代理对象不是最终类(最终类没有子类)
create方法的参数:
	class方法的参数:
		class:字节码
			它是用于指定被代理对象的字节码
		callback:用于提供增强的代码
			它是让我们写如何代理。我们一般都是些一个该接口的实现类,通常情况下都是匿名内部类,但不是必须的。此接口的实现类都是谁用谁写。
			我们一般写的都是该接口的子接口实现类:methodinterceptor
//cglib动态代理(基于子类的动态代理)
enhancer.create(两个参数);

代码如下:

package com.haust.serviceimpl;

public class actor{//没有实现任何接口
	/**
	* 一个演员
	*/
	public void basicact(float money) {
		system.out.println("拿到钱,开始基本的表演:"+money);
	}
	public void dangeract(float money) {
		system.out.println("拿到钱,开始危险的表演:"+money);
	}
}
package com.haust.test;
import java.lang.reflect.method;
import org.springframework.cglib.proxy.enhancer;
import org.springframework.cglib.proxy.methodinterceptor;
import org.springframework.cglib.proxy.methodproxy;
import com.haust.serviceimpl.actor;
public class test {
	public static void main(string[] args) {
		 actor actor = new actor();//需要创建此被代理的对象
		 /**
		 * 基于子类的动态代理
		 * 要求:
		 * 被代理对象不能是最终类
		 * 用到的类:
		 * enhancer
		 * 用到的方法:
		 * create(class, callback)
		 * 方法的参数:
		 * class:被代理对象的字节码
		 * callback:如何代理
		 * @param args
		 */
		 //此时强转的类的类型就是被代理类的类型
		 actor cglibactor = (actor)enhancer.create(actor.getclass(),new methodinterceptor() {
			@override
			public object intercept(object proxy, method method, object[] args, methodproxy  methodproxy) throws throwable {
				/**
				* 执行被代理对象的任何方法,都会经过该方法。在此方法内部就可以对被代理对象的任何
				方法进行增强。
				* 
				* 参数:
				* 前三个和基于接口的动态代理是一样的。
				* methodproxy:当前执行方法的代理对象。
				* 返回值:
				* 当前执行方法的返回值
				*/
				string name = method.getname();
				float money = (float) args[0];
				object rtvalue = null;
				if("basicact".equals(name)){
				//基本演出
				if(money > 2000){
				rtvalue = method.invoke(actor, money/2);
				} }
				if("dangeract".equals(name)){
					//危险演出
					if(money > 5000){
					rtvalue = method.invoke(actor, money/2);
					} 
				}
				return rtvalue;
			}
		});
		 cglibactor.basicact(10000);
		 cglibactor.dangeract(100000);
	}
}

总结:

无论哪种代理方式,都需要创建一个被代理的类(实例)。

不管是基于接口的代理,还是基于子类的代理,均拦截被代理对象的所有方法,然后我们可以对这些方法进行增强或者其他一些操作。

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!