0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看威廉希尔官方网站 视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

浅谈字节码增强威廉希尔官方网站 系列2-Asm与Cglib

OSC开源社区 来源:OSCHINA 社区 作者:京东云开发者-董子 2022-12-20 10:03 次阅读

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

一、SpringAop 与 Cglib

1.1、aop 重要概念

 a7e6fc0a-7f92-11ed-8abf-dac502259ad0.png

1.2、实现原理解析

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

a81ef376-7f92-11ed-8abf-dac502259ad0.png

1.2.1、jdk 动态代理

a84c1090-7f92-11ed-8abf-dac502259ad0.png


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

执行结果

a881e986-7f92-11ed-8abf-dac502259ad0.png


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


1.2.2.3、原理解析


a8a66144-7f92-11ed-8abf-dac502259ad0.png 

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

a906796c-7f92-11ed-8abf-dac502259ad0.png 

流程图

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 源码扫描的回调。如下图:

a9274d18-7f92-11ed-8abf-dac502259ad0.png 

构造方法 示例: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();
    }
}

运行结果:

 a97e9fdc-7f92-11ed-8abf-dac502259ad0.png

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

a9b013c8-7f92-11ed-8abf-dac502259ad0.png

2.3.4、实现方法注入

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

三、总结

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

审核编辑:汤梓红

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • JAVA
    +关注

    关注

    19

    文章

    2966

    浏览量

    104704
  • AOP
    AOP
    +关注

    关注

    0

    文章

    40

    浏览量

    11099
  • 字节码
    +关注

    关注

    0

    文章

    5

    浏览量

    7403

原文标题:浅谈字节码增强威廉希尔官方网站 系列2-Asm与Cglib

文章出处:【微信号:OSC开源社区,微信公众号:OSC开源社区】欢迎添加关注!文章转载请注明出处。

收藏 人收藏

    评论

    相关推荐

    探究python字节

    就是Python的“字节”文件。(但在Python 3上却难觅其踪 -- 原因是它们不再与.py文件出现在同一个目录中,而是放在一个名为__pycache__的子目录中了)。或许你也已听说过这是一种
    发表于 05-22 15:48

    单片机多字节BCD加法减法

    (1) 标号: BCDA 功能:多字节BCD加法入口条件:字节
    发表于 04-17 21:05 4508次阅读

    MCS51三字节无符号除法程序(ASM

    MCS51三字节无符号除法程序(ASM) ;三字节无符号除法程序(R2R3R4/R7)=(R2)R3R4 余数R7;入口 &nb
    发表于 01-16 11:54 1214次阅读

    字节BCD加法

    字节BCD加法 入口条件:字节数在R7中,被加数在[R0]中,加数在[R1]中。出口信息:和在[R0]中,最高位进位在CY中。影响资源:PSW
    发表于 01-19 22:41 2087次阅读

    字节BCD减法汇编语言程序

    字节BCD减法汇编语言程序 入口条件:字节数在R7中,被减数在[R0]中,减数在[R1]中。出口信
    发表于 01-19 22:42 2585次阅读

    字节BCD整数转换成单字节十六进制整数

    字节BCD整数转换成单字节十六进制整数 入口条件:待转换的单字节BCD整数在累加器A中。出口信息:转换后的单
    发表于 01-19 22:49 2798次阅读

    字节BCD整数转换成双字节十六进制整

    字节BCD整数转换成双字节十六进制整 入口条件:待转换的双字节BCD整数在R2、R3中。
    发表于 01-19 22:50 2976次阅读

    字节BCD小数转换成单字节十六进制小数

    字节BCD小数转换成单字节十六进制小数 入口条件:待转换的单字节BCD码数在累加器A中。出口信息:转换后的单字节十六进制小
    发表于 01-19 22:50 1681次阅读

    字节BCD小数转换成双字节十六进制小数

    字节BCD小数转换成双字节十六进制小数 入口条件:待转换的双字节BCD小数在R4、R5中。出口信息:转换后的双
    发表于 01-19 22:51 1668次阅读

    字节十六进制数转换成双字节ASCII

    字节十六进制数转换成双字节ASCII 入口条件:待转换的单字节十六进制数在累加器A中。出口信息:高四位的ASCII在A中,低四位的A
    发表于 01-19 22:52 2729次阅读

    字节十六进制整数转换成双字节BCD整数

    字节十六进制整数转换成双字节BCD整数 入口条件:待转换的双字节十六进制整数在R6、R7中。出口信息:转换后的三字节BCD
    发表于 01-19 22:52 2878次阅读

    字节十六进制整数转换成单字节BCD整数

    字节十六进制整数转换成单字节BCD整数  入口条件:待转换的单字节十六进制整数在累加器A中。出口信息:转换后的BCD整数
    发表于 01-19 22:53 3234次阅读

    字节十六进制小数转换成单字节BCD小数

    字节十六进制小数转换成单字节BCD小数 入口条件:待转换的单字节十六进制小数在累加器A中。出口信息:CY=0时转换后的BCD
    发表于 01-19 22:56 1535次阅读

    字节十六进制小数转换成双字节BCD小数

    字节十六进制小数转换成双字节BCD小数 入口条件:待转换的双字节十六进制小数在R2、R3中。出口信息:转换后的双
    发表于 01-19 22:56 1306次阅读

    tms320f2x_ASM_GUIDE

    tms320f2x ASM GUIDE。
    发表于 01-19 11:27 10次下载