作者：董子龙
前言
记得那是 2022 年秋天的第一场雨，比 2021 年来的稍晚一些，在那个秋雨朦胧的下午，正在工位上奋笔疾书的我突然听到了前面波哥对着手机听筒说出来的"温柔"的话语：说说你了解的 spring-aop。话音刚落，aop 这三个字便犹如一把利剑一样狠狠的扎到了我的心上，让我的脑海中顿时浮现了当年刚刚毕业被面试官"蹂躏"的凄惨画面。历经多年，直至现在，虽然日常工作中经常使用 aop 做一些业务功能的开发，但是如果让我解释"面向切面"这四个字的意思，我还是会"十脸懵逼"，哈哈。那么今天的文章，作为字节码增强技术系列承上启下的第二篇，就让我们以 aop 为马，去追逐字节码的星光。
一、SpringAop 与 Cglib
1.1、aop 重要概念
1.2、实现原理解析
Spring AOP 的实现原理是基于动态织入的动态代理技术，而动态代理技术又分为 Java JDK 动态代理和 CGLIB 动态代理。具体使用哪一种需要根据 AopProxyFactory 接口的 createProxy 方法中的 AdvisedSupport 中的参数进行确定，默认情况下如果目标类是接口，则使用 jdk 动态代理技术，如果是非接口类，则使用 cglib 来生成代理。具体的源码就不给大家一一贴出来了，大家可以去网上搜索一些资料进行深入了解。这里只给大家贴一张生成代理对象的图：
1.2.1、jdk 动态代理
spring-aop 中 jdk 代理的实现和我们平时自己实现动态代理开发是一致的，所以此处不做详细的介绍，只是简要给大家说明一下。使用做 jdk 动态代理时，代理类要实现 InvocationHandler 接口，目标类要实现接口，因为 JDK 提供的 Proxy 类将通过目标对象的类加载器 ClassLoader 和 Interface，以及句柄(Callback)创建与目标类拥有相同接口的代理对象 proxy，该代理对象将拥有目标类接口中的所有方法，同时代理类必须实现一个类似回调函数的 InvocationHandler 接口并重写该接口中的 invoke 方法，当调用 proxy 的每个方法(如案例中的 proxy#execute())时，invoke 方法将被调用，利用该特性，可以在 invoke 方法中对目标对象方法执行的前后动态添加其他外围业务操作，此时无需触及目标对象的任何代码，也就实现了外围业务的操作与目标对象完全解耦合的目的。当然缺点也很明显需要拥有接口，这也就有了后来的 CGLIB 动态代理了。
1.2.2、cglib 动态代理
spring-aop 中 cglib 代理的实现给大家贴一下源码的路径 org.springframework.aop.framework.CglibAopProxy、org.springframework.aop.framework.CglibAopProxy#getProxy(java.lang.ClassLoader)，感兴趣的话大家可以自己去看一下源码，接下来我会举一个具体的示例，来看一下如何使用 cglib 创建代理对象。（注：cglibgithub 地址：https://github.com/cglib/cglib）
1.2.2.1、引入 jar 包
<dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.2.5</version> </dependency>
复制代码
1.2.2.2、示例代码
/** * 创建目标对象 */public class Target { public void execute(){ System.out.println("执行Target的execute方法..."); }}
/** * 创建cglib代理类 */public class CGLibProxy implements MethodInterceptor {
/** * 被代理的目标类 */ private Target target;
public CGLibProxy(Target target) { super(); this.target = target; }
/** * 创建代理对象 * @return */ public Target createProxy(){ // 使用CGLIB生成代理: // 1.声明增强类实例,用于生产代理类 Enhancer enhancer = new Enhancer(); // 2.设置被代理类字节码，CGLIB根据字节码生成被代理类的子类 enhancer.setSuperclass(target.getClass()); // 3.//设置回调函数，即一个方法拦截 enhancer.setCallback(this); // 4.创建代理: return (Target) enhancer.create(); }
@Override public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { // 指定要执行被代理的方法 if("execute".equals(method.getName())) { //调用前执行方法 System.out.println("调用前执行方法"); //调用目标对象的方法(执行A对象即被代理对象的execute方法) Object result = methodProxy.invokeSuper(proxy, args); //记录日志数据(动态添加其他要执行业务) System.out.println("调用前执行方法"); return result; } //如果不需要增强直接执行原方法 return methodProxy.invokeSuper(proxy, args); }}
/** * 创建测试类 */public class CglibTest {
public static void main(String[] args) { // 将cglib生成的代理类写入到磁盘 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"D:\test\test"); CGLibProxy cgLibProxy = new CGLibProxy(new Target()); Target proxy = cgLibProxy.createProxy(); proxy.execute(); }}
复制代码
执行结果
从代码看被代理的类无需接口即可实现动态代理，而 CGLibProxy 代理类需要实现一个方法拦截器接口 MethodInterceptor 并重写 intercept 方法，类似 JDK 动态代理的 InvocationHandler 接口，也是理解为回调函数，同理每次调用代理对象的方法时，intercept 方法都会被调用，利用该方法便可以在运行时对方法执行前后进行动态增强。关于代理对象创建则通过 Enhancer 类来设置的，Enhancer 是一个用于产生代理对象的类，作用类似 JDK 的 Proxy 类，因为 CGLib 底层是通过继承实现的动态代理，因此需要传递目标对象的 Class，同时需要设置一个回调函数对调用方法进行拦截并进行相应处理，最后通过 create()创建目标对象的代理对象。
1.2.2.3、原理解析
上图是我们在 CglibTest 的 main 方法中设置了将代理类写入到磁盘之后生成的文件，一共有三个。我们这里重点看一下第二个文件，下面是该 class 文件的源码，给大家贴一下，一些重要的地方我会加上注释：
//// Source code recreated from a .class file by IntelliJ IDEA// (powered by FernFlower decompiler)//
package com.test.excel.cglib;
import java.lang.reflect.Method;import net.sf.cglib.core.ReflectUtils;import net.sf.cglib.core.Signature;import net.sf.cglib.proxy.Callback;import net.sf.cglib.proxy.Factory;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;
public class Target$$EnhancerByCGLIB$$e7b1b1b0 extends Target implements Factory { private boolean CGLIB$BOUND; public static Object CGLIB$FACTORY_DATA; private static final ThreadLocal CGLIB$THREAD_CALLBACKS; private static final Callback[] CGLIB$STATIC_CALLBACKS; // 拦截器 private MethodInterceptor CGLIB$CALLBACK_0; private static Object CGLIB$CALLBACK_FILTER; // 被代理方法 private static final Method CGLIB$execute$0$Method; // 代理方法 private static final MethodProxy CGLIB$execute$0$Proxy; private static final Object[] CGLIB$emptyArgs; private static final Method CGLIB$equals$1$Method; private static final MethodProxy CGLIB$equals$1$Proxy; private static final Method CGLIB$toString$2$Method; private static final MethodProxy CGLIB$toString$2$Proxy; private static final Method CGLIB$hashCode$3$Method; private static final MethodProxy CGLIB$hashCode$3$Proxy; private static final Method CGLIB$clone$4$Method; private static final MethodProxy CGLIB$clone$4$Proxy;
static void CGLIB$STATICHOOK1() { CGLIB$THREAD_CALLBACKS = new ThreadLocal(); CGLIB$emptyArgs = new Object[0]; // 代理类 Class var0 = Class.forName("com.test.excel.cglib.Target$$EnhancerByCGLIB$$e7b1b1b0"); // 被代理类 Class var1; CGLIB$execute$0$Method = ReflectUtils.findMethods(new String[]{"execute", "()V"}, (var1 = Class.forName("com.test.excel.cglib.Target")).getDeclaredMethods())[0]; CGLIB$execute$0$Proxy = MethodProxy.create(var1, var0, "()V", "execute", "CGLIB$execute$0"); Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods()); CGLIB$equals$1$Method = var10000[0]; CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1"); CGLIB$toString$2$Method = var10000[1]; CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2"); CGLIB$hashCode$3$Method = var10000[2]; CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3"); CGLIB$clone$4$Method = var10000[3]; CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4"); }
final void CGLIB$execute$0() { super.execute(); } // 被代理的方法
public final void execute() { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; }
if (var10000 != null) { // 调用拦截器 var10000.intercept(this, CGLIB$execute$0$Method, CGLIB$emptyArgs, CGLIB$execute$0$Proxy); } else { super.execute(); } }
final boolean CGLIB$equals$1(Object var1) { return super.equals(var1); }
public final boolean equals(Object var1) { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; }
if (var10000 != null) { Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy); return var2 == null ? false : (Boolean)var2; } else { return super.equals(var1); } }
final String CGLIB$toString$2() { return super.toString(); }
public final String toString() { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; }
return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString(); }
final int CGLIB$hashCode$3() { return super.hashCode(); }
public final int hashCode() { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; }
if (var10000 != null) { Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy); return var1 == null ? 0 : ((Number)var1).intValue(); } else { return super.hashCode(); } }
final Object CGLIB$clone$4() throws CloneNotSupportedException { return super.clone(); }
protected final Object clone() throws CloneNotSupportedException { MethodInterceptor var10000 = this.CGLIB$CALLBACK_0; if (var10000 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0; }
return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone(); }
public static MethodProxy CGLIB$findMethodProxy(Signature var0) { String var10000 = var0.toString(); switch(var10000.hashCode()) { case -508378822: if (var10000.equals("clone()Ljava/lang/Object;")) { return CGLIB$clone$4$Proxy; } break; case 539325408: if (var10000.equals("execute()V")) { return CGLIB$execute$0$Proxy; } break; case 1826985398: if (var10000.equals("equals(Ljava/lang/Object;)Z")) { return CGLIB$equals$1$Proxy; } break; case 1913648695: if (var10000.equals("toString()Ljava/lang/String;")) { return CGLIB$toString$2$Proxy; } break; case 1984935277: if (var10000.equals("hashCode()I")) { return CGLIB$hashCode$3$Proxy; } }
return null; }
public Target$$EnhancerByCGLIB$$e7b1b1b0() { CGLIB$BIND_CALLBACKS(this); }
public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) { CGLIB$THREAD_CALLBACKS.set(var0); }
public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) { CGLIB$STATIC_CALLBACKS = var0; }
private static final void CGLIB$BIND_CALLBACKS(Object var0) { Target$$EnhancerByCGLIB$$e7b1b1b0 var1 = (Target$$EnhancerByCGLIB$$e7b1b1b0)var0; if (!var1.CGLIB$BOUND) { var1.CGLIB$BOUND = true; Object var10000 = CGLIB$THREAD_CALLBACKS.get(); if (var10000 == null) { var10000 = CGLIB$STATIC_CALLBACKS; if (var10000 == null) { return; } }
var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0]; }
}
public Object newInstance(Callback[] var1) { CGLIB$SET_THREAD_CALLBACKS(var1); Target$$EnhancerByCGLIB$$e7b1b1b0 var10000 = new Target$$EnhancerByCGLIB$$e7b1b1b0(); CGLIB$SET_THREAD_CALLBACKS((Callback[])null); return var10000; }
public Object newInstance(Callback var1) { CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1}); Target$$EnhancerByCGLIB$$e7b1b1b0 var10000 = new Target$$EnhancerByCGLIB$$e7b1b1b0(); CGLIB$SET_THREAD_CALLBACKS((Callback[])null); return var10000; }
public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) { CGLIB$SET_THREAD_CALLBACKS(var3); Target$$EnhancerByCGLIB$$e7b1b1b0 var10000 = new Target$$EnhancerByCGLIB$$e7b1b1b0; switch(var1.length) { case 0: var10000.<init>(); CGLIB$SET_THREAD_CALLBACKS((Callback[])null); return var10000; default: throw new IllegalArgumentException("Constructor not found"); } }
public Callback getCallback(int var1) { CGLIB$BIND_CALLBACKS(this); MethodInterceptor var10000; switch(var1) { case 0: var10000 = this.CGLIB$CALLBACK_0; break; default: var10000 = null; }
return var10000; }
public void setCallback(int var1, Callback var2) { switch(var1) { case 0: this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2; default: } }
public Callback[] getCallbacks() { CGLIB$BIND_CALLBACKS(this); return new Callback[]{this.CGLIB$CALLBACK_0}; }
public void setCallbacks(Callback[] var1) { this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0]; }
static { CGLIB$STATICHOOK1(); }}
复制代码
从代理对象反编译源码可以知道，代理对象继承于 Target，拦截器调用 intercept()方法，intercept()方法由自定义 CGLibProxy 实现，所以，最后调用 CGLibProxy 中的 intercept()方法，从而完成了由代理对象访问到目标对象的动态代理实现。
1.2.3、jdk 代理和 cglib 代理的总结
JDK 动态代理：
. 需要目标类实现接口
. 生成的代理类是与目标类平级，实现了共同的接口
. 使用反射的方式进行最终方法的调用，性能较低
CGLIB 动态代理：
. 不要求目标类实现接口
. 生成的代理类是目标类的子类
. final 方法不会出现在代理类中
. 使用空间换时间的思想对最终的方法调用进行了优化，提升了运行时性能。
看到这里，大佬们此时是不是心里会产生个疑问：你的标题不是 asm 与 cglib 吗，前面说了这么多 cglib 代理和 jdk 代理，和 asm 有关系吗？哈哈，其实虽然我们没有再前面的内容中介绍 asm 的相关知识，但是其实字里行间都透漏着 asm，整体总结一句就是 CGLIB 包的底层是通过使用一个小而快的字节码处理框架 ASM，来转换字节码并生成新的类。
二、深入 ASM
2.1、简介
ASM 是一个 Java 字节码操控框架。它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。Java class 被存储在严格格式定义的 .class 文件里，这些类文件拥有足够的元数据来解析类中的所有元素：类名称、方法、属性以及 Java 字节码（指令）。ASM 从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。
与 BCEL 和 SERL 不同，ASM 提供了更为现代的编程模型。对于 ASM 来说，Java class 被描述为一棵树；使用 “Visitor” 模式遍历整个二进制结构；事件驱动的处理方式使得用户只需要关注于对其编程有意义的部分，而不必了解 Java 类文件格式的所有细节：ASM 框架提供了默认的"response taker"处理这一切。（官方文档：https://asm.ow2.io/asm4-guide.pdf *， *中文文档： https://cf.jd.com/pages/viewpage.action?pageId=1139356247 ）
流程图
2.2、核心 api 介绍
ASM 框架中的核心类有以下几个：
① ClassReader:该类用来解析编译过的 class 字节码文件。
② ClassWriter:该类用来重新构建编译后的类，比如说修改类名、属性以及方法，甚至可以生成新的类的字节码文件。
③ ClassAdapter:该类也实现了 ClassVisitor 接口，它将对它的方法调用委托给另一个 ClassVisitor 对象。
下面会列举每个核心类的几个核心 api 供大家参考，后面如果想了解更多的内容，可以直接查看 asm 的官方文档。
2.2.1、ClassReader
构造方法
作用 ： 获取 Class 文件，输入源很多种，包括字节流，IO 流或者直接加载 Class。
示例 ： public ClassReader(final InputStream inputStream)
accept 方法
作用：解析字节码中常量池之后的所有元素
示例：public void accept(final ClassVisitor classVisitor, final int parsingOptions)
重要参数解析：parsingOptions（用于跳过读取字节码时的一些信息选项，有以下四种选择可以选择)
2.2.2、ClassWriter
构造方法
作用：用来定义类的属性
示例：public ClassWriter(final int flags)
重要参数解析：
visit 方法
作用：用来定义类的属性
示例 ： public final void visit(int version, int access, String name, String signature, String superName, String[] interfaces)
重要参数解析：
visitMethod 方法
作用：用来定义类的方法
示例 ： public final MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions)
重要参数解析：
visitField 方法
作用：用来定义一个变量
示例：public final FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value)
重要参数解析：
visitEnd 方法
作用：用来通知 Class 已经使用完
示例：public final void visitEnd()
toByteArray 方法
作用：返回一个字节数组
示例：public byte[] toByteArray()
2.2.3、ClassVisiter
看名字就能看出来，这是一个对 Class 文件进行观察（扫描）的工具类。因为它是一个抽象类，所以我们只能对其进行继承重写。并且 ClassVisitor 所有的调用都是由 ClassReader 来进行回调，就是我们前面 accept 方法。而这个方法里，执行了对 ClassVisitor 源码扫描的回调。如下图：
构造方法
示例：protected ClassVisitor(final int api, final ClassVisitor classVisitor)
参数解释：
api：代表是 ASM API 的版本 ，默认填最新（ASM9）即可。编写代码和代码读取的版本号最好保持一致，不然可能会有一些兼容性的错误。
由于****ClassVisitor 所有的调用都是由 ClassReader 来进行回调，所以其他 api 咱们不做过多介绍。
2.3、ASM 实践
上面给大家介绍了 asm 的 api，还有一些其他的 api 例如 MethodVisitor、FieldVisitor 等就不过多介绍了，还是那句话，想深入了解，就看一下官方文档。但是光说不练假把式，接下来我们就对 asm 做一番实践，由此来体会他的功能之强大。
2.3.1、引入 jar
<dependency> <groupId>org.ow2.asm</groupId> <artifactId>asm</artifactId> <version>9.4</version></dependency>
复制代码
2.3.2、生成类
我们自定义生成一个 People 的类
package com.test.excel.asm;
import org.objectweb.asm.ClassWriter;import org.objectweb.asm.FieldVisitor;import org.objectweb.asm.MethodVisitor;
import java.io.FileOutputStream;
import static jdk.internal.org.objectweb.asm.ClassWriter.COMPUTE_FRAMES;import static jdk.internal.org.objectweb.asm.ClassWriter.COMPUTE_MAXS;import static jdk.internal.org.objectweb.asm.Opcodes.*;
/** * 文件描述 * * @author dzl * @date 2022-11-27 18:49 */public class AsmTest {
public static void main(String[] args) throws Exception { testCreateAClass(); } public static void testCreateAClass()throws Exception{ //新建一个类生成器，COMPUTE_FRAMES，COMPUTE_MAXS这2个参数能够让asm自动更新操作数栈 ClassWriter cw = new ClassWriter(COMPUTE_FRAMES|COMPUTE_MAXS); //生成一个public的类，类路径是com.study.Human cw.visit(V1_8, ACC_PUBLIC,"com/test/excel/asm/People",null,"java/lang/Object",null); //生成默认的构造方法： public People() MethodVisitor mv = cw.visitMethod(ACC_PUBLIC,"<init>","()V",null,null); mv.visitVarInsn(ALOAD,0); mv.visitMethodInsn(INVOKESPECIAL,"java/lang/Object","<init>","()V",false); mv.visitInsn(RETURN); mv.visitMaxs(0,0);//更新操作数栈 mv.visitEnd();//一定要有visitEnd
//生成成员变量 //1.生成String类型的成员变量:private String name; FieldVisitor fv= cw.visitField(ACC_PRIVATE,"name","Ljava/lang/String;",null,null); fv.visitEnd();//不要忘记end //2.生成Long类型成员：private long age fv=cw.visitField(ACC_PRIVATE,"age","J",null,null); fv.visitEnd();
//3.生成Int类型成员:protected int no fv=cw.visitField(ACC_PROTECTED,"no","I",null,null); fv.visitEnd();
//4.生成静态成员变量：public static long score fv=cw.visitField(ACC_PUBLIC + ACC_STATIC,"score","J",null,null);
//5.生成常量：public static final String real_name = "Sand哥" fv=cw.visitField(ACC_PUBLIC+ACC_STATIC+ACC_FINAL,"real_name","Ljava/lang/String;",null,"Sand哥"); fv.visitEnd();
//6.生成成员方法greet mv=cw.visitMethod(ACC_PUBLIC,"greet","(Ljava/lang/String;)I",null,null); mv.visitCode(); mv.visitIntInsn(ALOAD,0); mv.visitIntInsn(ALOAD,1);
//6.1 调用静态方法 System.out.println("Hello"); mv.visitFieldInsn(GETSTATIC,"java/lang/System","out","Ljava/io/PrintStream;");// mv.visitLdcInsn("Hello");//加载字符常量 mv.visitIntInsn(ALOAD,1);//加载形参 mv.visitMethodInsn(INVOKEVIRTUAL,"java/io/PrintStream","println","(Ljava/lang/String;)V",false);//打印形参 //获取类的byte数组 byte[] classByteData=cw.toByteArray(); //把类数据写入到class文件,这样你就可以把这个类文件打包供其他的人使用 FileOutputStream out = new FileOutputStream(AsmTest.class.getResource("/com/test/excel/asm/").getPath() + "People.class"); out.write(classByteData); out.close(); }}
复制代码
运行结果：
2.3.3、修改已存在的类
假如我们现在有如下类，我们用 asm 做如下几个修改：1.增加了一个 phone 字段 2.删除 testA 方法 3.将 testC 方法改成 protected 4.新增一个 getPhone 方法。
/** * 文件描述 * * @author dzl * @date 2022-11-27 19:14 */public class ModifyFunction {
private int a;
public void testA(){ System.out.println("I am A"); }
public void testB(){ System.err.println("===>I am B"); }
public int testC(){ return a; }}
复制代码
利用 asm 修改该类
package com.test.excel.asm;
import org.objectweb.asm.*;
import java.io.FileOutputStream;
import static jdk.internal.org.objectweb.asm.Opcodes.*;import static org.objectweb.asm.Opcodes.ASM9;
/** * 文件描述 * * @author dzl * @date 2022-11-27 18:49 */public class AsmTest {
public static void main(String[] args) throws Exception { testModifyCalss(); } private static void testModifyCalss()throws Exception{ ClassReader cr = new ClassReader("com.test.excel.asm.ModifyFunction"); final ClassWriter cw=new ClassWriter(cr,0);// cr.accept(cw, 0);//可以直接接受一个writer,实现复制 cr.accept(new ClassVisitor(ASM9,cw) {//接受一个带classWriter的visitor，实现定制化方法拷贝或者属性删除字段 @Override public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) { System.out.println("visit method:"+name+"====> "+descriptor);
if("testA".equals(name)){//拷贝的过程中删除一个方法 return null; }
if("testC".equals(name)){//将testC public方法变成protect access=ACC_PROTECTED; } return super.visitMethod(access, name, descriptor, signature, exceptions); }
@Override public void visitEnd() { //特别注意的是：要为类增加属性和方法，放到visitEnd中，避免破坏之前已经排列好的类结构，在结尾添加新结构 //增加一个字段（注意不能重复）,注意最后都要visitEnd FieldVisitor fv = cv.visitField(ACC_PUBLIC, "phone", "Ljava/lang/String;", null, null); fv.visitEnd();//不能缺少visitEnd //增加一个方法 MethodVisitor mv=cv.visitMethod(ACC_PUBLIC,"getPhone","()Ljava/lang/String;",null,null); mv.visitCode(); mv.visitVarInsn(ALOAD, 0); mv.visitFieldInsn(GETFIELD,"com/test/excel/asm/ModifyFunction","phone","Ljava/lang/String;"); mv.visitInsn(IRETURN); mv.visitMaxs(1, 1); mv.visitEnd();//不能缺少visitEnd super.visitEnd();//注意原本的visiEnd不能少 } },0); //指定新生成的class路径的生成位置,这个路径你可以随便指定 FileOutputStream out = new FileOutputStream(AsmTest.class.getResource("/com/test/excel/asm/").getPath() + "ModifyFunction.class"); out.write(cw.toByteArray()); out.close(); }}
复制代码
运行结果：
2.3.4、实现方法注入
实现方法注入类似于我们的 aop 功能，本篇就不做过多介绍了，感兴趣的大佬可以参考上一篇文章的 demo。
三、总结
写到这里，心里都感觉如释重负了一下，因为正文总算是写完了。作为本系列呈上启下的第二篇，查了很多资料，看了很多文章，再写分享的同时，自身也学到了很多东西。同时，如果文章中有不足或者描述不准确的内容，希望及时批评指正，万分感谢。
评论