带你重新认识Java动态代理

目录

什么是动态代理？

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

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

特点：字节码随用随创建，随用随加载

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

正常类创建对象的过程：

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

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

1.基于接口的动态代理

提供者：jdk

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

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

2.基于类的动态代理

提供者：第三方 cglib

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

注意：被代理类不能用 final 修饰的类（最终类）。如果报 asmxxxx 异常，需要导入 asm.jar包

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

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

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

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

package com.haust.rvice;public interface iactor {/*** 基本演出* @param money*/public void basicact(float money);/*** 危险演出* @param money*/public void dangeract(float money);}

package com.haust.rviceimpl;import com.haust.rvice.iactor;public class actor implements iactor {/*** 一个演员*///实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求@overridepublic void basicact(float money) {system.out.println("拿到钱，开始基本的表演："+money);}@overridepublic 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.rvice.iactor;import com.haust.rviceimpl.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：执行方法所需的参数 * 返回值： * 当前执行被代理对象方法的返回值 */@overridepublic object invoke(o我国海拔最高的湖bject 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.rviceimpl;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.springf美国化妆品品牌大全ramework.cglib.proxy.methodinterceptor;import org.springframework.cglib.proxy.methodproxy;import com.haust.rviceimpl.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() {@overridepublic 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);}}

总结：

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

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

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注www.887551.com的更多内容！