代理
代理就是通过代理对象去访问实际的目标对象,比如我们在生活中租房,可以直接找房东,也可以通过某些租房平台去租房,通过租房平台的这种方式就是代理。在java中这种租房平台就被叫做代理类,代理类不仅能实现目标对象,还能增加一些额外的功能。
静态代理
什么叫做静态代理?
静态代理就是在代码运行之前,这个代理类就已经存在了。
例子
在这里插入图片描述
首先,需要创建一个租房的通用接口
package com.sxl.staticProxy;
//租房接口
public interface Rent {
public void rent();
}
然后,我们需要一个被代理类,也就是需要出租房子的房东
package com.sxl.staticProxy;
//房东出租房屋
public class Landlord implements Rent{
/**
* 声明一个被代理类,需要重写接口中的rent方法
*/
@Override
public void rent() {
System.out.println("房东已经出租房屋!");
}
}
随即,我们需要写一个代理类,也就是中介
package com.sxl.staticProxy;
//代理,中介帮助房东出租房屋
/**
* 声明一个代理类,要和被代理类继承同一个接口
* 且要重写接口中的rent方法
*/
public class Proxy implements Rent{
private Rent r;
public Proxy(Rent r) {
this.r = r;
}
@Override
public void rent() {
System.out.println("中介正在寻找房源...");
kanfang();
r.rent();
System.out.println("中介已经帮助完成租房!");
shoufei();
}
public void kanfang(){
System.out.println("中介带领前去看房...");
}
public void shoufei(){
System.out.println("中介收取费用!");
}
}
最后,租客前来寻找中介租房
package com.sxl.staticProxy;
//租客前来租房
public class Test {
public static void main(String[] args) {
Landlord l=new Landlord();
Proxy p=new Proxy(l);
p.rent();
}
}
运行结果
在这里插入图片描述
这样,我们就可以通过代理来完成租房子了
静态代理的优点
真实角色的操作可以更加纯粹,而不用过多的关注公共业务
代理角色可以去完成公共业务,实现了业务的分工
公共业务发生拓展的时候,更加便于拓展和管理
静态代理的缺点
由于静态代理在代码运行之前就已经存在代理类,因此对于每一个代理对象都需要建一个代理类去代理,当需要代理的对象很多时就需要创建很多的代理类,严重降低程序的可维护性,开发效率也会大大降低。
动态代理
动态代理是指代理类不是写在代码中,而是在运行过程中产生的,
基于Jdk的动态代理
底层实现
通过实现 InvocationHandler 接口创建自己的调用处理器;
通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类;
通过反射机制获得动态代理类的构造函数,其唯一参数类型是调用处理器接口类型;
通过构造函数创建动态代理类实例,构造时调用处理器对象作为参数被传入。
基于Cglib的动态代理
cglib是一个java字节码的生成工具,它动态生成一个被代理类的子类,子类重写被代理的类的所有不是final的方法。
在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。
基于javassist的动态代理(不做了解)
总结
静态代理比较容易理解, 需要被代理的类和代理类实现自同一个接口, 然后在代理类中调用真正实现类, 并且静态代理的关系在编译期间就已经确定了。而动态代理的关系是在运行期间确定的。静态代理实现简单,适合于代理类较少且确定的情况,而动态代理则给我们提供了更大的灵活性。
JDK 动态代理所用到的代理类在程序调用到代理类对象时才由 JVM 真正创建,JVM 根据传进来的业务实现类对象以及方法名 ,动态地创建了一个代理类的 class 文件并被字节码引擎执行,然后通过该代理类对象进行方法调用。我们需要做的,只需指定代理类的预处理、调用后操作即可。
静态代理和动态代理都是基于接口实现的, 而对于那些没有提供接口只是提供了实现类的而言, 就只能选择 CGLIB 动态代理了。
在这里插入图片描述
JDK 动态代理和 CGLIB 动态代理的区别
JDK 动态代理基于 Java 反射机制实现, 必须要实现了接口的业务类才能用这种方法生成代理对象。
CGLIB 动态代理基于 ASM 框架通过生成业务类的子类来实现。
JDK 动态代理的优势是最小化依赖关系,减少依赖意味着简化开发和维护并且有 JDK 自身支持。还可以平滑进行 JDK 版本升级,代码实现简单。
基于 CGLIB 框架的优势是无须实现接口,达到代理类无侵入,我们只需操作我们关系的类,不必为其它相关类增加工作量,性能比较高。
描述代理的几种实现方式? 分别说出优缺点?
代理可以分为 “静态代理” 和 “动态代理”,动态代理又分为 “JDK 动态代理” 和 “CGLIB 动态代理” 实现。
1.静态代理:
代理对象和实际对象都继承了同一个接口,在代理对象中指向的是实际对象的实例,这样对外暴露的是代理对象而真正调用的是 Real Object.
优点:可以很好的保护实际对象的业务逻辑对外暴露,从而提高安全性。
缺点:不同的接口要有不同的代理类实现,会很冗余
2.JDK 动态代理:
为了解决静态代理中,生成大量的代理类造成的冗余;
JDK 动态代理只需要实现 InvocationHandler 接口,重写 invoke 方法便可以完成代理的实现.
jdk 的代理是利用反射生成代理类 Proxyxx.class 代理类字节码,并生成对象
jdk 动态代理之所以只能代理接口是因为代理类本身已经 extends 了 Proxy,而 java 是不允许多重继承的,但是允许实现多个接口
优点:解决了静态代理中冗余的代理实现类问题。
缺点:JDK 动态代理是基于接口设计实现的,如果没有接口,会抛异常。
3.CGLIB 代理:
由于 JDK 动态代理限制了只能基于接口设计,而对于没有接口的情况,JDK 方式解决不了;
CGLib 采用了非常底层的字节码技术,其原理是通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑,来完成动态代理的实现。实现方式实现 MethodInterceptor 接口,重写 intercept 方法,通过 Enhancer 类的回调方法来实现。
CGLib 在创建代理对象时所花费的时间却比 JDK 多得多,所以对于单例的对象,因为无需频繁创建对象,用 CGLib 合适,反之,使用 JDK 方式要更为合适一些。
由于 CGLib 由于是采用动态创建子类的方法,对于 final 方法,无法进行代理。
优点:没有接口也能实现动态代理,而且采用字节码增强技术,性能也不错。
缺点:技术实现相对难理解些。
330 篇文章 0 订阅
订阅专栏
一、代理模式
代理模式(Proxy Pattern)是程序设计中的一种设计模式,它的特征是代理类和委托类实现有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。
代理类与委托类之间通常会存在关联关系,一个代理类对象与一个委托类对象(目标对象)关联,代理类对象本身并不真正实现服务,而是通过调用委托类对象的相关方法,来提供特定的服务。
即通过代理对象访问目标对象,这样我们可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
以最近很火的贵州茅台为例子,假如我们要买1箱茅台,我们不是直接跟茅台公司买的,而是通过代理商(例如沃尔玛,京东等)进行购买。茅台公司就是一个目标对象,它只负责生产茅台,而其他如何销售,寄快递等琐碎的事交由代理商(代理对象)来处理。
二、静态代理
代理对象与目标对象一起实现相同的接口或者继承相同父类,由程序员创建或特定工具自动生成源代码,即在编译时就已经确定了接口,目标类,代理类等。在程序运行之前,代理类 的 .class 文件就已经生成。
你可以简单认为代理对象写死持有目标对象。
package com.nobody.staticproxy;
/**
* @Description 白酒厂商
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public interface WhileWineCompany {
// 生产酒 (演示才写一个方法,实际多个方法都是能被代理的)
void product();
}
package com.nobody.staticproxy;
/**
* @Description 委托类,贵州茅台
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class Moutai implements WhileWineCompany {
public void product() {
System.out.println("生产贵州茅台...");
}
}
package com.nobody.staticproxy;
/**
* @Description 代理类,京东代理商
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class JDProxy implements WhileWineCompany {
// 被代理的贵州茅台公司
private Moutai moutai;
public JDProxy(Moutai moutai) {
this.moutai = moutai;
}
public void product() {
System.out.println("京东商城下订单购买");
// 实际调用目标对象的方法
moutai.product();
System.out.println("京东商城发快递");
}
}
package com.nobody.staticproxy;
/**
* @Description
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class Main {
public static void main(String[] args) {
// 生成代理对象,并传入被代理对象
WhileWineCompany proxy = new JDProxy(new Moutai());
proxy.product();
}
}
// 输出结果
京东商城下订单购买
生产贵州茅台...
京东商城发快递
静态代理的优缺点:
优点:在不修改目标对象的功能前提下,可以对目标功能扩展。
缺点:假如又有一个目标类,也要做增强,则还需要新增相对应的代理类,导致我们要手动编写很多代理类。同时,一旦接口增加方法,目标对象与代理对象都要维护。
三、动态代理
代理类在程序运行时才创建的代理方式被称为动态代理。
静态代理中,代理类(JDProxy)是我们程序员定义的,在程序运行之前就已经编译完成。而动态代理中的代理类并不是在Java代码中定义的,而是在运行时根据我们在Java代码中的“指示”动态生成的。
在 Java 中,有2种动态代理实现方式,JDK动态代理和CGLIB动态代理。
Spring 中的 AOP 是依靠动态代理来实现切面编程的。
3.1 JDK动态代理
JDK动态代理是基于反射机制,生成一个实现代理接口的匿名类,然后重写方法进行方法增强。在调用具体方法前通过调用 InvokeHandler 的 invoke 方法来处理。
它的特点是生成代理类速度很快,但是运行时调用方法操作会比较慢,因为是基于反射机制的,而且只能针对接口编程,即目标对象要实现接口。
如果目标对象实现了接口,默认情况下会采用JDK的动态代理。
实现JDK动态代理,我们需要借助 java.lang.reflect 包下的 Proxy 类 和 InvocationHandler接口
package com.nobody.jdkproxy;
/**
* @Description 白酒厂商
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public interface WhileWineCompany {
// 生产酒 (演示才写一个方法,实际多个方法都是能被代理的)
void product();
}
package com.nobody.jdkproxy;
/**
* @Description 委托类,贵州茅台
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class Moutai implements WhileWineCompany {
public void product() {
System.out.println("生产贵州茅台...");
}
}
package com.nobody.jdkproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @Description JDK动态代理实现InvocationHandler接口
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class JDKProxy implements InvocationHandler {
// 被代理的目标对象
private Object target;
/**
* 所有执行代理对象的方法都会被替换成执行invoke方法
*
* @param proxy 代理对象
* @param method 将要执行的方法信息
* @param args 执行方法需要的参数
* @return 方法执行后的返回值
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("京东商城下订单");
// 通过反射,调用目标对象的方法并传入参数
Object result = method.invoke(target, args);
System.out.println("京东商城发快递");
return result;
}
/**
* 获取代理对象
*
* @param target 被代理的对象
* @return 代理对象
*/
public Object getJDKProxy(Object target) {
this.target = target;
// loader:ClassLoader对象,定义哪个ClassLoader对象加载生成代理对象
// interfaces:一个Interface对象的数组,即给代理的对象提供一组接口,代理对象就会实现了这些接口(多态),这样我们就能调用这些接口中的方法
// h::InvocationHandler对象,当动态代理对象在调用方法的时候,会调用InvocationHandler对象的invoke方法
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
}
package com.nobody.jdkproxy;
/**
* @Description
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class Main {
public static void main(String[] args) {
JDKProxy jdkProxy = new JDKProxy();
// 获取贵州茅台的代理对象
WhileWineCompany proxy = (WhileWineCompany) jdkProxy.getJDKProxy(new Moutai());
// 执行方法
proxy.product();
}
}
// 输出结果
京东商城下订单
生产贵州茅台...
京东商城发快递
如果此时我们又增加了一个目标对象,也要进行代理,我们只需要定义一个委托类实现接口即可。
package com.nobody.jdkproxy;
/**
* @Description 委托类,酒鬼酒
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class JiuGuiJiu implements WhileWineCompany {
public void product() {
System.out.println("生产酒鬼酒...");
}
}
package com.nobody.jdkproxy;
/**
* @Description
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class Main {
public static void main(String[] args) {
JDKProxy jdkProxy = new JDKProxy();
// 获取贵州茅台的代理对象
WhileWineCompany proxy = (WhileWineCompany) jdkProxy.getJDKProxy(new Moutai());
// 执行方法
proxy.product();
System.out.println("----------------------");
// 获取酒鬼酒的代理对象
proxy = (WhileWineCompany) jdkProxy.getJDKProxy(new JiuGuiJiu());
// 执行方法
proxy.product();
}
}
// 输出结果
京东商城下订单
生产贵州茅台...
京东商城发快递
----------------------
京东商城下订单
生产酒鬼酒...
京东商城发快递
动态代理让我们更方便对代理类的方法进行统一处理,而不用修改每个代理类中的方法。因为所有被代理执行的方法,最终都是调用 InvocationHandler 中的 invoke 方法,所以我们可以在 invoke 方法中统一进行增强处理。
在JDK动态代理的过程中,没有看到实际的代理类,代理对象又是如何通过调用 InvocationHandler 的invoke方法来完成代理过程的?通过JDK源码分析其实是 Proxy 类的 newProxyInstance方法在运行时动态生成字节码生成代理类(缓存在Java虚拟机内存中),从而创建了一个动态代理对象。
我们通过以下方法将生成的代理类打印到本地查看:
byte[] classFile =
ProxyGenerator.generateProxyClass("$Proxy0", Moutai.class.getInterfaces());
String path = "D:/$Proxy0.class";
try (FileOutputStream fos = new FileOutputStream(path)) {
fos.write(classFile);
fos.flush();
} catch (Exception e) {
e.printStackTrace();
}
最终,生成的class文件通过反编译如下,可以看出代理类继承了 Proxy,并且实现了与目标对象同样的 WhileWineCompany 接口,所以不难理解为什么 newProxyInstance 方法生成的代理对象能赋值给 WhileWineCompany 接口。而且从中也看出代理类的 product 方法实际调用了 InvocationHandler 的 invoke 方法,从而最终实现对目标对象的方法代理。
简单可总结为,代理对象($Proxy0)持有 InvocationHandler 对象(我们定义的JDKProxy),InvocationHandler 对象持有目标对象(target),InvocationHandler 中的 invoke 方法对目标对象的方法进行增强处理。从而达到调用代理对象的方法,代理对象调用 InvocationHandler 的 invoke方法,invoke 方法中又调用了目标对象的方法。
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import com.nobody.staticproxy.WhileWineCompany;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements WhileWineCompany {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void product() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.nobody.staticproxy.WhileWineCompany").getMethod("product");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
JDK为我们的生成了一个叫$Proxy0(0 是 编号,有多个代理类会依次递增)的代理类,这个类文件信息存放在内存中,我们在创建代理对象时,是通过反射获得这个类的构造方法,然后创建的代理实例。
代理类继承了 Proxy 类,因为在Java中是单继承的,所以这就是为什么JDK动态代理中,目标对象一定要实现接口。
3.2 Cglib动态代理
JDK动态代理要求目标对象要实现接口,那如果一个类没有实现接口呢?那可以用 Cglib 实现动态代理。
Cglib(Code Generation Library)是一个强大的,高性能,高质量的Code生成类库,它是开源的。动态代理是利用 asm 开源包,将目标对象类的 class 文件加载进来,然后修改其字节码生成新的子类来进行扩展处理。即可以在运行期扩展Java类和实现Java接口。它广泛地被许多AOP的框架使用中,例如 Spring AOP,为他们提供方法的 interception (拦截)。
Cglib包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类。不推荐直接使用ASM,除非你对JVM内部结构包括class文件的格式和指令集都了如指掌。
总结为,cglib继承被代理的类,重写方法,织入通知,动态生成字节码并运行,要求被代理的类不能final修饰符修饰。
<!-- 引入cglib依赖 -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
package com.nobody.cglib;
/**
* @Description 委托类,贵州茅台
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class Moutai {
public void product() {
System.out.println("生产贵州茅台...");
}
}
package com.nobody.cglib;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @Description 动态代理类,实现MethodInterceptor方法拦截器接口
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class CglibProxy implements MethodInterceptor {
// 被代理的目标对象
private Object target;
// 动态生成一个新的类,使用父类的无参构造方法创建一个指定了特定回调的代理实例
/**
* 动态生成一个新的类
*
* @param target
* @return
*/
public Object getProxyObject(Object target) {
this.target = target;
// 增强器,动态代码生成器
Enhancer enhancer = new Enhancer();
// 回调方法
enhancer.setCallback(this);
// 设置生成代理类的父类类型
enhancer.setSuperclass(target.getClass());
// 动态生成字节码并返回代理对象
return enhancer.create();
}
/**
* 拦截方法
*
* @param o CGLib动态生成的代理类实例
* @param method 上文中实体类所调用的被代理的方法引用
* @param objects 方法参数值列表
* @param methodProxy 生成的代理类对方法的代理引用
* @return 代理对象
* @throws Throwable
*/
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)
throws Throwable {
System.out.println("京东商城下订单");
Object result = methodProxy.invoke(target, objects);
System.out.println("京东商城发快递");
return result;
}
}
package com.nobody.cglib;
/**
* @Description
* @Author Mr.nobody
* @Date 2021/2/12
* @Version 1.0
*/
public class Main {
public static void main(String[] args) {
// 目标对象
Moutai moutai = new Moutai();
// 代理对象
Moutai proxy = (Moutai) new CglibProxy().getProxyObject(moutai);
// 执行代理对象的方法
proxy.product();
}
}
//输出结果
京东商城下订单
生产贵州茅台...
京东商城发快递
Cglib动态代理注意的2点:
被代理类不能是 final 修饰的。
需要扩展的方法不能有 final 或 static 关键字修饰,不然不会被拦截,即执行方法只会执行目标对象的方法,不会执行方法扩展的内容。
四、两种动态代理区别
JDK动态代理是基于反射机制,生成一个实现代理接口的匿名类。而Cglib动态代理是基于继承机制,继承被代理类,底层是基于asm第三方框架对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。
JDK动态代理是生成类的速度快,后续执行类的方法操作慢;Cglib动态代理是生成类的速度慢,后续执行类的方法操作快。
JDK只能针对接口编程,Cglib可以针对类和接口。在Springboot项目中,在配置文件中增加
spring.aop.proxy-target-class=true 即可强制使用Cglib动态代理实现AOP。
如果目标对象实现了接口,默认情况下是采用JDK动态实现AOP,如果目标对象没有实现接口,必须采用CGLIB库动态实现AOP。