你必须会的 JDK 动态代理和 CGLIB 动态代理
来自:ytao
我们在阅读一些 Java 框架的源码时,基本上常会看到使用动态代理机制,它可以无感的对既有代码进行方法的增强,使得代码拥有更好的拓展性。通过从静态代理、JDK 动态代理、CGLIB 动态代理来进行本文的分析。
静态代理
静态代理就是在程序运行之前,代理类字节码 .class
就已编译好,通常一个静态代理类也只代理一个目标类,代理类和目标类都实现相同的接口。接下来就先通过 demo 进行分析什么是静态代理,当前创建一个 Animal 接口,里面包含 call
函数。
package top.ytao.demo.proxy;
/*** Created by YangTao*/
public interface Animal {void call();
}
创建目标类 Cat,同时实现 Animal 接口,下面是 Cat 发出叫声的实现。
package top.ytao.demo.proxy;
/*** Created by YangTao*/
public class Cat implements Animal {@Overridepublic void call() {System.out.println("喵喵喵 ~");}
}
由于 Cat 叫之前是因为肚子饿了,所以我们需要在目标对象方法 Cat#call
之前说明是饥饿,这是使用静态代理实现猫饥饿然后发出叫声。
package top.ytao.demo.proxy.jdk;
import top.ytao.demo.proxy.Animal;
/*** Created by YangTao*/
public class StaticProxyAnimal implements Animal {private Animal impl;public StaticProxyAnimal(Animal impl) {this.impl = impl;}@Overridepublic void call() {System.out.println("猫饥饿");impl.call();}
}
通过调用静态代理实现猫饥饿和叫行为。
public class Main {@Testpublic void staticProxy(){Animal staticProxy = new StaticProxyAnimal(new Cat());staticProxy.call();}
}
执行结果
代理类、目标类、接口之间关系如图:
以上内容可以看到代理类中通过持有目标类对象,然后通过调用目标类的方法,实现静态代理。静态代理虽然实现了代理,但在一些情况下存在比较明显不足之处:
当我们在 Animal 接口中增加方法,这时不仅实现类 Cat 需要新增该方法的实现,同时,由于代理类实现了 Animal 接口,所以代理类也必须实现 Animal 新增的方法,这对项目规模较大时,在维护上就不太友好了。
代理类实现
Animal#call
是针对 Cat 目标类的对象进行设置的,如果再需要添加 Dog 目标类的代理,那就必须再针对 Dog 类实现一个对应的代理类,这样就使得代理类的重用型不友好,并且过多的代理类对维护上也是比较繁琐。
上面问题,在 JDk 动态代理中就得到了较友好的解决。
JDK 动态代理
动态代理类与静态代理类最主要不同的是,代理类的字节码不是在程序运行前生成的,而是在程序运行时再虚拟机中程序自动创建的。继续用上面 Cat 类和 Animal 接口实现 JDK 动态代理。
实现 InvocationHandler 接口
JDK 动态代理类必须实现反射包中的 java.lang.reflect.InvocationHandler 接口,在此接口中只有一个 invoker 方法:
在 InvocationHandler#invoker
中必须调用目标类被代理的方法,否则无法做到代理的实现。下面为实现 InvocationHandler 的代码。
/*** Created by YangTao*/
public class TargetInvoker implements InvocationHandler {// 代理中持有的目标类private Object target;public TargetInvoker(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("jdk 代理执行前");Object result = method.invoke(target, args);System.out.println("jdk 代理执行后");return result;}
}
在实现 InvocationHandler#invoker
时,该方法里有三个参数:
proxy 代理目标对象的代理对象,它是真实的代理对象。
method 执行目标类的方法
args 执行目标类的方法的参数
创建 JDK 动态代理类
创建 JDK 动态代理类实例同样也是使用反射包中的 java.lang.reflect.Proxy 类进行创建。通过调用 Proxy#newProxyInstance
静态方法进行创建。
/**** Created by YangTao*/
public class DynamicProxyAnimal {public static Object getProxy(Object target) throws Exception {Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), // 指定目标类的类加载target.getClass().getInterfaces(), // 代理需要实现的接口,可指定多个,这是一个数组new TargetInvoker(target) // 代理对象处理器);return proxy;}
}
Proxy#newProxyInstance
中的三个参数(ClassLoader loader、Class[] interfaces、InvocationHandler h):
loader 加载代理对象的类加载器
interfaces 代理对象实现的接口,与目标对象实现同样的接口
h 处理代理对象逻辑的处理器,即上面的 InvocationHandler 实现类。
最后实现执行 DynamicProxyAnimal 动态代理:
public class Main {@Testpublic void dynamicProxy() throws Exception {Cat cat = new Cat();Animal proxy = (Animal) DynamicProxyAnimal.getProxy(cat);proxy.call();}
}
执行结果:
通过上面的代码,有两个问题:代理类是怎么创建的和代理类怎么调用方法的?
分析
从 Proxy#newProxyInstance
入口进行源码分析:
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException
{Objects.requireNonNull(h);final Class<?>[] intfs = interfaces.clone();final SecurityManager sm = System.getSecurityManager();if (sm != null) {checkProxyAccess(Reflection.getCallerClass(), loader, intfs);}// 查找或生成指定的代理类Class<?> cl = getProxyClass0(loader, intfs);try {if (sm != null) {checkNewProxyPermission(Reflection.getCallerClass(), cl);}// 获取代理的构造器final Constructor<?> cons = cl.getConstructor(constructorParams);final InvocationHandler ih = h;// 处理代理类修饰符,使得能被访问if (!Modifier.isPublic(cl.getModifiers())) {AccessController.doPrivileged(new PrivilegedAction<Void>() {public Void run() {cons.setAccessible(true);return null;}});}// 创建代理类实例化return cons.newInstance(new Object[]{h});} catch (IllegalAccessException|InstantiationException e) {throw new InternalError(e.toString(), e);} catch (InvocationTargetException e) {Throwable t = e.getCause();if (t instanceof RuntimeException) {throw (RuntimeException) t;} else {throw new InternalError(t.toString(), t);}} catch (NoSuchMethodException e) {throw new InternalError(e.toString(), e);}
}
newProxyInstance 方法里面获取到代理类,如果类的作用不能访问,使其能被访问到,最后实例化代理类。这段代码中最为核心的是获取代理类的 getProxyClass0
方法。
private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {// 实现类的接口不能超过 65535 个if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}// 获取代理类return proxyClassCache.get(loader, interfaces);
}
如果 proxyClassCache 缓存中存在指定的代理类,则从缓存直接获取;如果不存在,则通过 ProxyClassFactory 创建代理类。至于为什么接口最大为 65535,这个是由字节码文件结构和 Java 虚拟机规定的,具体可以通过研究字节码文件了解。
进入到 proxyClassCache#get
,获取代理类:
继续进入 Factory#get
查看,
最后到 ProxyClassFactory#apply
,这里实现了代理类的创建。
private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>>{// 所有代理类名称都已此前缀命名private static final String proxyClassNamePrefix = "$Proxy";// 代理类名的编号private static final AtomicLong nextUniqueNumber = new AtomicLong();@Overridepublic Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);for (Class<?> intf : interfaces) {// 校验代理和目标对象是否实现同一接口Class<?> interfaceClass = null;try {interfaceClass = Class.forName(intf.getName(), false, loader);} catch (ClassNotFoundException e) {}if (interfaceClass != intf) {throw new IllegalArgumentException(intf + " is not visible from class loader");}// 校验 interfaceClass 是否为接口if (!interfaceClass.isInterface()) {throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");}// 判断当前 interfaceClass 是否被重复if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());}}// 代理类的包名String proxyPkg = null; int accessFlags = Modifier.PUBLIC | Modifier.FINAL;// 记录非 public 修饰符代理接口的包,使生成的代理类与它在同一个包下for (Class<?> intf : interfaces) {int flags = intf.getModifiers();if (!Modifier.isPublic(flags)) {accessFlags = Modifier.FINAL;// 获取接口类名String name = intf.getName();// 去掉接口的名称,获取所在包的包名int n = name.lastIndexOf('.');String pkg = ((n == -1) ? "" : name.substring(0, n + 1));if (proxyPkg == null) {proxyPkg = pkg;} else if (!pkg.equals(proxyPkg)) {throw new IllegalArgumentException("non-public interfaces from different packages");}}}if (proxyPkg == null) {// 如果接口类是 public 修饰,则用 com.sun.proxy 包名proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";}// 创建代理类名称long num = nextUniqueNumber.getAndIncrement();String proxyName = proxyPkg + proxyClassNamePrefix + num;// 生成代理类字节码文件byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);try {// 加载字节码,生成指定代理对象return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);} catch (ClassFormatError e) {throw new IllegalArgumentException(e.toString());}}
}
以上就是创建字节码流程,通过检查接口的属性,决定代理类字节码文件生成的包名及名称规则,然后加载字节码获取代理实例。操作生成字节码文件在 ProxyGenerator#generateProxyClass
中生成具体的字节码文件,字节码操作这里不做详细讲解。
生成的字节码文件,我们可以通过保存本地进行反编译查看类信息,保存生成的字节码文件可以通过两种方式:设置jvm参数或将生成 byte[] 写入文件。
上图的 ProxyGenerator#generateProxyClass
方法可知,是通过 saveGeneratedFiles 属性值控制,该属性的值来源:
private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();
所以通过设置将生成的代理类字节码保存到本地。
-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true
反编译查看生成的代理类:
生成的代理类继承了 Proxy 和实现了 Animal 接口,调用 call
方法,是通过调用 Proxy 持有的 InvocationHandler 实现 TargetInvoker#invoker
的执行。
CGLIB 动态代理
CGLIB 动态代理的实现机制是生成目标类的子类,通过调用父类(目标类)的方法实现,在调用父类方法时再代理中进行增强。
实现 MethodInterceptor 接口
相比于 JDK 动态代理的实现,CGLIB 动态代理不需要实现与目标类一样的接口,而是通过方法拦截的方式实现代理,代码实现如下,首先方法拦截接口 net.sf.cglib.proxy.MethodInterceptor。
/*** Created by YangTao*/
public class TargetInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("CGLIB 调用前");Object result = proxy.invokeSuper(obj, args);System.out.println("CGLIB 调用后");return result;}
}
通过方法拦截接口调用目标类的方法,然后在该被拦截的方法进行增强处理,实现方法拦截器接口的 intercept 方法里面有四个参数:
obj 代理类对象
method 当前被代理拦截的方法
args 拦截方法的参数
proxy 代理类对应目标类的代理方法
创建 CGLIB 动态代理类
创建 CGLIB 动态代理类使用 net.sf.cglib.proxy.Enhancer 类进行创建,它是 CGLIB 动态代理中的核心类,首先创建个简单的代理类:
/*** Created by YangTao*/
public class CglibProxy {public static Object getProxy(Class<?> clazz){Enhancer enhancer = new Enhancer();// 设置类加载enhancer.setClassLoader(clazz.getClassLoader());// 设置被代理类enhancer.setSuperclass(clazz);// 设置方法拦截器enhancer.setCallback(new TargetInterceptor());// 创建代理类return enhancer.create();}
}
设置被代理类的信息和代理类拦截的方法的回调执行逻辑,就可以实现一个代理类。实现 CGLIB 动态代理调用:
public class Main {@Testpublic void dynamicProxy() throws Exception {Animal cat = (Animal) CglibProxy.getProxy(Cat.class);cat.call();}
}
执行结果:
CGLIB 动态代理简单应用就这样实现,但是 Enhancer 在使用过程中,常用且有特色功能还有回调过滤器 CallbackFilter 的使用,它在拦截目标对象的方法时,可以有选择性的执行方法拦截,也就是选择被代理方法的增强处理。使用该功能需要实现 net.sf.cglib.proxy.CallbackFilter 接口。现在增加一个方法拦截的实现:
/*** Created by YangTao*/
public class TargetInterceptor2 implements MethodInterceptor {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("CGLIB 调用前 TargetInterceptor2");Object result = proxy.invokeSuper(obj, args);System.out.println("CGLIB 调用后 TargetInterceptor2");return result;}
}
然后在 Cat 中增加 hobby 方法,因为 CGLIB 代理无需实现接口,可以直接代理普通类,所以不需再 Animal 接口中增加方法:
package top.ytao.demo.proxy;
/*** Created by YangTao*/
public class Cat implements Animal {@Overridepublic void call() {System.out.println("喵喵喵 ~");}public void hobby(){System.out.println("fish ~");}
}
实现回调过滤器 CallbackFilter
/*** Created by YangTao*/
public class TargetCallbackFilter implements CallbackFilter {@Overridepublic int accept(Method method) {if ("hobby".equals(method.getName()))return 1;elsereturn 0;}
}
为演示调用不同的方法拦截器,在 Enhancer 设置中,使用 Enhancer#setCallbacks
设置多个方法拦截器,参数是一个数组, TargetCallbackFilter#accept
返回的数字即为该数组的索引,决定调用的回调选择器。
/*** Created by YangTao*/
public class CglibProxy {public static Object getProxy(Class<?> clazz){Enhancer enhancer = new Enhancer();enhancer.setClassLoader(clazz.getClassLoader());enhancer.setSuperclass(clazz);enhancer.setCallbacks(new Callback[]{new TargetInterceptor(), new TargetInterceptor2()});enhancer.setCallbackFilter(new TargetCallbackFilter());return enhancer.create();}
}
按代码实现逻辑,call 方法会调用 TargetInterceptor 类,hobby 类会调用 TargetInterceptor2 类,执行结果:
CGLIB 的实现原理是通过设置被代理的类信息到 Enhancer 中,然后利用配置信息在 Enhancer#create
生成代理类对象。生成类是使用 ASM 进行生成,本文不做重点分析。如果不关注 ASM 的操作原理,只看 CGLIB 的处理原理还是比较容易读懂。这里主要看生成后的代理类字节码文件,通过设置
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "F:\\xxx");
可保存生成的字节到 F:\xxx 文件夹中
通过反编译可看到
代理类继承了目标类 Cat,同时将两个方法拦截器加载到了代理类中,通过 Callbacks 下标作为变量名后缀进行区分,最后调用指定的方法拦截器中的 intercept 实现代理的最终的执行结果。这里需要注意的是 CGLIB 动态代理不能代理 final 修饰的类和方法。
最后
通过反编译生成的 JDK 代理类和 CGLIB 代理类,我们可以看到它们两种不同机制的实现:
JDK 动态代理是通过实现目标类的接口,然后将目标类在构造动态代理时作为参数传入,使代理对象持有目标对象,再通过代理对象的 InvocationHandler 实现动态代理的操作。
CGLIB 动态代理是通过配置目标类信息,然后利用 ASM 字节码框架进行生成目标类的子类。当调用代理方法时,通过拦截方法的方式实现代理的操作。总的来说,JDK 动态代理利用接口实现代理,CGLIB 动态代理利用继承的方式实现代理。
动态代理在 Java 开发中是非常常见的,在日志,监控,事务中都有着广泛的应用,同时在大多主流框架中的核心组件中也是少不了使用的,掌握其要点,不管是开发还是阅读其他框架源码时,都是必须的。
特别推荐一个分享架构+算法的优质内容,还没关注的小伙伴,可以长按关注一下:长按订阅更多精彩▼如有收获,点个在看,诚挚感谢
你必须会的 JDK 动态代理和 CGLIB 动态代理相关推荐
- 什么是代理模式?代理模式有什么用?通过一个小程序分析静态代理和动态代理。自己简单实现动态代理。JDK动态代理和CGLIB动态代理的区别。
1. 代理模式有什么用 ①功能增强,在实现目标功能的基础上,又增加了额外功能.就像生活中的中介一样,他跟两边客户会有私下的交流. ②控制访问,代理不让用户直接和目标接触.就像中间商一样,他们不会让我们 ...
- Java动态代理的两种实现方法:JDK动态代理和CGLIB动态代理
Java动态代理的两种实现方法:JDK动态代理和CGLIB动态代理 代理模式 JDK动态代理 CGLIB动态代理 代理模式 代理模式是23种设计模式的一种,指一个对象A通过持有另一个对象B,可以具有B ...
- 利用代码分别实现jdk动态代理和cglib动态代理_面试之动态代理
大家好!我是CSRobot,从今天开始,我将会发布一些技术文章,内容就是结合春招以来的面试所遇到的问题进行分享,首先会对知识点进行一个探讨和整理,在最后会给出一些面试题并作出解答,希望可以帮助到大家! ...
- JDK动态代理和CGLib动态代理简单演示
JDK1.3之后,Java提供了动态代理的技术,允许开发者在运行期间创建接口的代理实例. 一.首先我们进行JDK动态代理的演示. 现在我们有一个简单的业务接口Saying,如下: package te ...
- JAVA 进阶篇 动态代理 JDK动态代理和CGlib动态代理
JDK动态代理和CGlib动态代理 JDK动态代理: 利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理. CGlib动态代理: 利用ASM(开源的Java ...
- jdk动态代理和cglib动态代理实现及区别
代理模式是一种设计模式,提供了对目标对象额外的访问方式,即通过代理对象访问目标对象,这样可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能. 代理模式又分为:静态代理.jdk动态代 ...
- Java两种动态代理JDK动态代理和CGLIB动态代理
目录 代理模式 JDK动态代理 cglib动态代理 测试 代理模式 代理模式是23种设计模式的一种,他是指一个对象A通过持有另一个对象B,可以具有B同样的行为的模式.为了对外开放协议,B往往实现了一个 ...
- Spring AOP之---基于JDK动态代理和CGLib动态代理的AOP实现
AOP(面向切面编程)是OOP的有益补充,它只适合那些具有横切逻辑的应用场合,如性能监测,访问控制,事物管理,日志记录等.至于怎么理解横切逻辑,敲完实例代码也就明白了. 为什么要使用AOP,举个栗子: ...
- Java中动态代理的两种方式JDK动态代理和cglib动态代理以及区别
视频功能审核通过了,可以看视频啦!记得点关注啊~ 注意:因为网络原因,视频前一两分钟可能会比较模糊,过一会儿就好了 记得点关注啊,视频里的wx二维码失效了,wx搜索:"聊5毛钱的java&q ...
- 【Spring6】| GoF之代理模式(JDK动态代理和CGLIB动态代理)
目录 一:GoF之代理模式 1. 对代理模式的理解 2. 静态代理 3. 动态代理 3.1 JDK动态代理 3.2 CGLIB动态代理 一:GoF之代理模式 1. 对代理模式的理解 生活场景1:牛村的 ...
最新文章
- 如何轻松应对DNS劫持
- 定制.vimrc配置文件
- Spring Boot 系列(八)@ControllerAdvice 拦截异常并统一处理
- 派森编程软件python-派森Python
- gdb调试之堆栈跟踪
- synchronousqueue场景_java并发队列之SynchronousQueue
- 相机参数设置程序_自定义拍摄模式怎么设置?教你学会相机设置。
- 应用squid全面加速web(全)
- golang(2):beego 环境搭建
- 解决zookeeper启动失败Could not find or load main class org.apache.zookeeper.server.quorum.QuorumPeerMain报错
- 都市异乡年轻人的艰难“房”事
- QT每日一练day24:绘画事件
- PLSQL常用方法汇总
- 计算机考研机构排行,2022计算机考研辅导班十大排名
- 2018CSTC web2 writeup
- 动态网页怎样才能被搜索引擎收录
- 复变函数和积分变换(Complex Function II)
- 三月c++面经(英特尔、旷世、云从、地平线,具体回答后续补)
- notepad数据对比插件_如何使用NotePad++的compare插件进行文本对比,来研究下吧
- 1-十六烷基-3-三乙氧基丙基硅烷咪唑溴盐离子液体([HDTIm]Br)修饰磁性纳米颗粒(MNPs)|[HDTIm]Br-MNPs
热门文章
- matlab入门学习2
- python traceback模块_Python中的traceback模块
- 0x51.动态规划 - 线性DP(习题详解 × 10)
- c++把数组所有元素剔除_C语言基础之数组,第一节,C语言必学知识点剖析
- matlab 插值滤波,插值滤波
- java mvc数据库 封装_Springmvc对就jdbc封装的操作
- 不能成为专业软件测试人员的10大理由
- vue中的minix
- Alibaba Cluster Data 开放下载:270GB 数据揭秘你不知道的阿里巴巴数据中心
- 手机屏幕的物理分辨率和逻辑分辨率