作者 | 京東云開發者-董子龍

一、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 包

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

執行結果

從代碼看被代理的類無需接口即可實現動態代理，而 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.();
            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();
    }
}

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" 處理這一切。

??

流程圖

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

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

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。

三、總結

每次寫到這里，心里都感覺如釋重負了一下，因為正文總算是寫完了。寫本文時查了很多資料，看了很多文章，再寫分享的同時，自身也學到了很多東西。同時，如果文章中有不足或者描述不準確的內容，希望及時批評指正，萬分感謝。

審核編輯：湯梓紅