带你重新认识Java动态代理

目录
  • 什么是动态代理?
  • 动态代理的常用两种方式:
    • 1.基于接口的动态代理
    • 2.基于类的动态代理
  • 基于子类的动态代理
  • 总结:

什么是动态代理?

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

代理类在程序运行期间,创建的代理对象称之为动态代理对象。这种情况下,创建的代理对象,并不是事先在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);
	}
}

总结:

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

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

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

(0)

相关推荐

  • Java反射的应用之动态代理深入理解

    目录 一.代理模式的引入 二.动态代理 一.代理模式的引入 静态代理举例 特点:代理类和被代理类在编译期间,就确定下来了. interface ClothFactory{ void produceCloth(); } //代理类 class ProxyClothFactory implements ClothFactory{ private ClothFactory factory;//用被代理类对象进行实例化 public ProxyClothFactory(ClothFactory fact

  • 代理模式:JAVA静态代理和动态代理的实例和实现详解

    目录 前言 静态代理 实现简述 创建human接口 创建接口实现类 创建针对接口实现增强操作的代理 代理实现效果 动态代理 实现简述 要点:向上转型 创建YoungMan接口 创建两个接口实现类 创建动态代理实例对象 代理实现效果 要点:InvocationHandler补充 代理模式和修饰模式的区别 总结 前言 代理模式,我们这里结合JAVA的静态代理和动态代理来说明,类比Spring AOP面向切面编程:增强消息,也是代理模式. 而我们的静态代理和动态代理,与(service)接口和(ser

  • Java实现动态代理的实例代码

    目录 前言 静态代理 动态代理 CGLib实现动态代理 总结 前言 动态代理在Java中有着广泛的应用,比如Spring AOP.Hibernate数据查询.测试框架的后端mock.RPC远程调用.Java注解对象获取.日志.用户鉴权.全局性异常处理.性能监控,甚至事务处理等. 代理,指的是使用代理对象代替对其它对象的访问,简单点说,你求职时找的中介就是代理,那么在Java中,代理如何体现呢? 静态代理 我们首先需要知道,何为静态代理?静态代理指的是在编译期就对目标对象的方法进行增强,例如: p

  • Java静态代理与动态代理案例详解

    代理模式 代理模式(Proxy):为其他对象提供一个代理以控制对这个对象的访问. 主要解决:在直接访问对象时带来的问题,比如说:要访问的对象在远程的机器上.在面向对象系统中,有些对象由于某些原因(比如对象创建开销很大,或者某些操作需要安全控制,或者需要进程外的访问),直接访问会给使用者或者系统结构带来很多麻烦,我们可以在访问此对象时加上一个对此对象的访问层. 代理模式的元素是:共同接口.代理对象.目标对象. 代理模式的行为:由代理对象执行目标对象的方法.由代理对象扩展目标对象的方法. 代理模式的

  • JAVA代理,静态,动态详解

    目录 代理 静态代理 动态代理 JDK动态代理 CGLib动态代理 总结 代理 为其他对象提供一种代理以控制这个对象的访问,在某些情况下一个对象不能直接访问那个对象时,代理就起到了客户端和被代理对象 (委托类) 中介作用. 按照代理的创建时期,代理类可以分为两种: 静态:由程序员创建代理类或特定工具自动生成源代码再对其编译.在程序运行前代理类的.class文件就已经存在了. 动态:在程序运行时运用反射机制动态创建而成. 静态代理 Subject: 代理类和被代理类实现同样的接口 Proxy:代理

  • Java反射(JDK)与动态代理(CGLIB)详解

    目录 一.反射 二.动态代理 1.JDK代理 2.CGLIB代理 3.JDK代理与CGLIB代理对比 总结 一.反射 概念:在运行状态中,对于任意的一个类,都能够知道这个类的所有字段和方法,对任意一个对象都能够通过反射机制调用一个类的任意方法 实现方法:JVM在第一次加载某个类时会生成一个Class对象,里面记录了这个类的信息 链接:类加载机制(留坑) 二.动态代理 动态代理的作用:在不改变原代码的基础上增加新的功能,如日志.权限检验等 反射在动态代理中的应用:由于知道原类的字段.方法等信息,才

  • 带你重新认识Java动态代理

    目录 什么是动态代理? 动态代理的常用两种方式: 1.基于接口的动态代理 2.基于类的动态代理 基于子类的动态代理 总结: 什么是动态代理? 动态代理就是,在程序运行期,创建目标对象的代理对象,并对目标对象中的方法进行功能性增强的一种技术.在生成代理对象的过程中,目标对象不变,代理对象中的方法是目标对象方法的增强方法.可以理解为运行期间,对象中方法的动态拦截,在拦截方法的前后执行功能操作(也可以对原方法的参数进行操作). 代理类在程序运行期间,创建的代理对象称之为动态代理对象.这种情况下,创建的

  • 浅谈Java动态代理的实现

    一.代理设计模式 1.1 什么是代理 考虑真实的编程场景,项目中存在一个访问其他数据源的接口,包含一个query()方法 我们已经针对这个接口,实现了MySQL.Hive.HBase.MongoDB等作为数据源的实现类 但是,在测试过程中,我们发现这些数据源的查询并不是很稳定 最原始的想法: 在所有实现类query()方法中,代码首部获取startTime,代码尾部获取endTime,通过打印日志的方式,知道每次查询的耗时 long startTime = System.currentTimeM

  • Java动态代理四种实现方式详解

    代理模式也是一种非常常见的设计模式.了解Spring框架的都知道,Spring AOP 使用的就是动态代理模式.今天就来系统的重温一遍代理模式. 在现实生活中代理是随处可见的,当事人因某些隐私不方便出面,或者当事人不具备某些相关的专业技能,而需要一个职业人员来完成一些专业的操作, 也可能由于当事人没有时间处理事务,而聘用代理人出面.而在软件设计中,使用代理模式的地方也很多,由于安全原因,屏蔽客户端直接访问真实对象, 或者为了提升系统性能,使用代理模式实现延迟加载,还有就是AOP,对委托类的功能进

  • Java 动态代理原理分析

    Java 动态代理原理分析 概要 AOP的拦截功能是由java中的动态代理来实现的.说白了,就是在目标类的基础上增加切面逻辑,生成增强的目标类(该切面逻辑或者在目标类函数执行之前,或者目标类函数执行之后,或者在目标类函数抛出异常时候执行.Spring中的动态代理是使用Cglib进行实现的.我们这里分析的是JDK中的动态代理实现机制. 下面我们通过例子快速了解JDK中的动态代理实现方式. 示例 需要代理的接口 public interface IHello { public void sayHel

  • 详解java动态代理模式

    本文针对java动态代理进行知识点整理,具体内容如下 一. JAVA的动态代理(比较官方说法) 代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处 理消息.过滤消息.把消息转发给委托类,以及事后处理消息等. 代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的 对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提 供特定的服务. 按照代理的创建时期,代理类可以分为两种. 静态代理:由程序员创建或特定工

  • Java动态代理实现_动力节点Java学院整理

    动态代理作为代理模式的一种扩展形式,广泛应用于框架(尤其是基于AOP的框架)的设计与开发,本文将通过实例来讲解Java动态代理的实现过程. 通常情况下,代理模式中的每一个代理类在编译之后都会生成一个class文件,代理类所实现的接口和所代理的方法都被固定,这种代理被称之为静态代理(Static Proxy).那么有没有一种机制能够让系统在运行时动态创建代理类?答案就是本文将要介绍的动态代理(Dynamic Proxy).动态代理是一种较为高级的代理模式,它在事务管理.AOP(Aspect-Ori

  • JAVA动态代理模式(从现实生活角度理解代码原理)

    所谓动态代理,即通过代理类:Proxy的代理,接口和实现类之间可以不直接发生联系,而可以在运行期(Runtime)实现动态关联. java动态代理主要是使用java.lang.reflect包中的两个类. InvocationHandler类 public Object invoke(Object obj,Method method,Object[] obs) 其中第一个参数 obj 指的是代理类,method是被代理的方法,obs是指被代理的方法的参数组.此方法由代理类来实现. Proxy类

  • java 动态代理的方法总结

    java 动态代理的方法总结 AOP的拦截功能是由java中的动态代理来实现的.说白了,就是在目标类的基础上增加切面逻辑,生成增强的目标类(该切面逻辑或者在目标类函数执行之前,或者目标类函数执行之后,或者在目标类函数抛出异常时候执行.不同的切入时机对应不同的Interceptor的种类,如BeforeAdviseInterceptor,AfterAdviseInterceptor以及ThrowsAdviseInterceptor等). 那么动态代理是如何实现将切面逻辑(advise)织入到目标类

  • Java 动态代理与CGLIB详细介绍

    静态代理模式 因为需要对一些函数进行二次处理,或是某些函数不让外界知道时,可以使用代理模式,通过访问第三方,间接访问原函数的方式,达到以上目的. interface Hosee{ String sayhi(); } class Hoseeimpl implements Hosee{ @Override public String sayhi() { return "Welcome oschina hosee's blog"; } } class HoseeProxy implement

  • Java动态代理分析及理解

    Java动态代理分析及理解 代理设计模式 定义:为其他对象提供一种代理以控制对这个对象的访问. 动态代理使用 java动态代理机制以巧妙的方式实现了代理模式的设计理念. 代理模式示例代码 public interface Subject { public void doSomething(); } public class RealSubject implements Subject { public void doSomething() { System.out.println( "call

随机推荐