浅谈字节码增强技术系列2-Asm与Cglib

OSC开源社区 2022-12-20 579

OSC开源社区

663 文章 69.2w阅读 6粉丝

描述

作者 | 京东云开发者-董子龙

一、SpringAop 与 Cglib

1.1、aop 重要概念

 AOP

 1.2、实现原理解析

Spring AOP 的实现原理是基于动态织入的动态代理技术，而动态代理技术又分为 Java JDK 动态代理和 CGLIB 动态代理。具体使用哪一种需要根据 AopProxyFactory 接口的 createProxy 方法中的 AdvisedSupport 中的参数进行确定，默认情况下如果目标类是接口，则使用 jdk 动态代理技术，如果是非接口类，则使用 cglib 来生成代理。具体的源码就不给大家一一贴出来了，大家可以去网上搜索一些资料进行深入了解。这里只给大家贴一张生成代理对象的图：

AOP

1.2.1、jdk 动态代理

AOP


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 包

  
     cglib 
     cglib 
     3.2.5

 

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();
    }
}

 

执行结果

AOP


从代码看被代理的类无需接口即可实现动态代理，而 CGLibProxy 代理类需要实现一个方法拦截器接口 MethodInterceptor 并重写 intercept 方法，类似 JDK 动态代理的 InvocationHandler 接口，也是理解为回调函数，同理每次调用代理对象的方法时，intercept 方法都会被调用，利用该方法便可以在运行时对方法执行前后进行动态增强。关于代理对象创建则通过 Enhancer 类来设置的，Enhancer 是一个用于产生代理对象的类，作用类似 JDK 的 Proxy 类，因为 CGLib 底层是通过继承实现的动态代理，因此需要传递目标对象的 Class，同时需要设置一个回调函数对调用方法进行拦截并进行相应处理，最后通过 create () 创建目标对象的代理对象。


1.2.2.3、原理解析


AOP 

上图是我们在 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.();
            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" 处理这一切。

AOP 

流程图

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（用于跳过读取字节码时的一些信息选项，有以下四种选择可以选择)

SKIP_CODE 表示跳过代码扫描，如果你只需要只是类的结构，就可以使用这个。
SKIP_DEBUG 跳过调试信息，ClassReader 不会去访问调试信息。如果设置了这个标志，这些属性既不会被解析也不会被访问 (例如 ClassVisitor.visitSource,MethodVisitor.visitLocalVariable, MethodVisitor.visitLineNumber MethodVisitor.visitParameter)。这个会比较常用，当你不需要上面这些方法时候。
SKIP_FRAMES 跳过堆栈映射帧。如果设置了这个标志，这些属性既不会被解析也不会被访问（例如：MethodVisitor.visitFrame）. 这个标志当 ClassWriter.COMPUTE_FRAME 选项被使用时，它会避免访问将被忽略并从头重新计算的帧。
EXPAND_FRAMES 用来展开堆栈映射帧的标志，会降低性能。

2.2.2、ClassWriter

构造方法 作用：用来定义类的属性 示例：public ClassWriter(final int flags) 重要参数解析：

flag == 0 自己计算栈帧和局部变量以及操作数堆栈的大小 ，也就是你要自己调用 visitmax 和 visitFrame 方法。
flag == ClassWriter. COMPUTE_MAXS 局部变量和操作数堆栈部分的大小会为你计算，还需要调用 visitFrame 方法设置栈帧。
flag == ClassWriter.COMPUTE_FRAMES 所有的内容都是自动计算的。你不必调用 visitFrame 和 visitmax

visit 方法 作用：用来定义类的属性 示例：public final void visit(int version, int access, String name, String signature, String superName, String[] interfaces) 重要参数解析：

version Java 版本号，例如 V1_8 代表 Java 8
access Class 访问权限，一般默认都是 ACC_PUBLIC | ACC_SUPER
name Class 文件名，例如：asm/User，包名加类名
signature 类的签名，除非你是泛型类或者实现泛型接口，一般默认 null。
superName 继承的类，很明显所有类默认继承 Object。例如：java/lang/Object ，如果是继承自己写的类 Animal，那就是 asm/Animal
interfaces 实现的接口，例如实现自己写的接口 IPrint，那就是 new String[]{"asm/IPrint"}

visitMethod 方法 作用：用来定义类的方法 示例：public final MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) 重要参数解析：

access 方法的访问权限，也就是 public，private 等
name 方法名：在 Class 中，有两个特殊方法名。 和 < clinit>，其他的方法都是正常对应 Java 方法名。 代表的是类的实例构造方法初始化，也就是 new 一个类时，肯定会调用的方法。 代表的类的初始化方法，不同于 < init>，它不是显示调用的。因为 Java 虚拟机会自动调用 < clinit>，并且保证在子类的 < clinit > 前调用父类的 < clinit>。也就是说，Java 虚拟机中，第一个被执行 < clinit > 方法的肯定是 java.lang.Object。注意： 和 < clinit > 执行的时机不一样， 的时机早于 < init>， 是在类被加载阶段的初始化过程中调用 < clinit > 方法，而 < init > 方法的调用是在 new 一个类的实例的时候。
descriptor 方法的描述符，就是字节码对代码中方法的形参和返回值的一个描述。其实就是一个一一对应的模板
signature 方法签名，除非方法的参数、返回类型和异常使用了泛型，否则一般为 null。
exceptions 方法上的异常

visitField 方法

作用：用来定义一个变量

示例：public final FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value)

重要参数解析：

access 变量的访问权限，，也就是 public，private 等
name 变量名
descriptor 变量的描述符
signature 变量的签名，如果没有使用泛型则为 null
value 变量的初始值。这个字段仅作用于被 final 修饰的字段，或者接口中声明的变量。其他默认为 null，变量的赋值是通过 MethodVisitor 的 visitFieldInsn 方法。

visitEnd 方法 作用：用来通知 Class 已经使用完 示例：public final void visitEnd() toByteArray 方法 作用：返回一个字节数组 示例：public byte[] toByteArray()

2.2.3、ClassVisiter

看名字就能看出来，这是一个对 Class 文件进行观察（扫描）的工具类。因为它是一个抽象类，所以我们只能对其进行继承重写。并且 ClassVisitor 所有的调用都是由 ClassReader 来进行回调，就是我们前面 accept 方法。而这个方法里，执行了对 ClassVisitor 源码扫描的回调。如下图：

AOP 

构造方法 示例：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

 

    
    org.ow2.asm    
    asm    
    9.4

 

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,"","()V",null,null);
        mv.visitVarInsn(ALOAD,0);
        mv.visitMethodInsn(INVOKESPECIAL,"java/lang/Object","","()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();
    }
}
运行结果：

 AOP

 

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();
    }
}
运行结果：

AOP

 

2.3.4、实现方法注入

实现方法注入类似于我们的 aop 功能，本篇就不做过多介绍了，感兴趣的大佬可以参考上一篇文章的 demo。

三、总结

每次写到这里，心里都感觉如释重负了一下，因为正文总算是写完了。写本文时查了很多资料，看了很多文章，再写分享的同时，自身也学到了很多东西。同时，如果文章中有不足或者描述不准确的内容，希望及时批评指正，万分感谢。

审核编辑：汤梓红

打开APP阅读更多精彩内容
声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。 举报投诉

全部0条评论

快来发表一下你的评论吧 !

下载APP
|投诉反馈|电子发烧友网
© 2021 elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分