揭秘Android编译插桩：ASM让你的代码"偷偷"变强

前言

想象一下：老板突然说"所有方法都要加耗时统计"，产品经理补刀"每个按钮点击都得埋点"，测试同学再加一句"异常要自动上报"。如果你手动改，怕是要改到地老天荒。

这时候，编译插桩就像个"幕后英雄"------在代码编译成APK的过程中，神不知鬼不觉地帮你把这些重复工作做完。而ASM，就是这个英雄手中最锋利的剑。

编译插桩：代码界的"流水线工人"

先搞明白什么是编译插桩。我们写的Java/Kotlin代码，要经过一系列加工才能变成手机能跑的APK：

vbnet 复制代码

Java代码 → javac编译 → Class文件 → 打包成Dex → 生成APK

编译插桩就像在"Class文件"和"Dex"之间加了个质检员，它会：

拦下所有Class文件
按你的要求修改（比如加日志、加统计）
再放它们去生成Dex

这好处可太多了：

不用改源码，业务代码干干净净
统一处理，避免漏改、错改
一次开发，全项目生效

ASM：字节码界的"瑞士军刀"

要修改Class文件，就得懂字节码。但字节码这东西，人类看了脑壳疼（不信你看下面这段）：

csharp 复制代码

public void test() {
  0: aload_0
  1: invokespecial #1 // Method java/lang/Object."<init>":()V
  4: return
}

这时候ASM就登场了。它是一个操作字节码的框架，能帮你：

读懂Class文件（不用自己解析字节码）
修改Class文件（不用记那些鬼画符一样的指令）
生成新的Class文件（徒手撸字节码什么的，不存在的）

为啥不用AspectJ？AspectJ确实简单，但就像自动挡汽车；ASM是手动挡，虽然难一点，但性能好、灵活度高，能做更底层的操作。

Android中用ASM搞事情的正确姿势

4.1 准备工作：搭建插桩环境

插桩通常通过Gradle插件实现，步骤如下：

创建一个Android Library模块（比如叫asm-plugin）
在build.gradle里引入必要依赖：

groovy 复制代码

// build.gradle
dependencies {
    implementation gradleApi()
    implementation localGroovy()
    // ASM核心库
    implementation 'org.ow2.asm:asm:9.3'
    implementation 'org.ow2.asm:asm-commons:9.3'
}

4.2 核心武器：自定义Transform

Transform是Android Gradle提供的用于处理Class文件的接口，我们的插桩逻辑就放在这里。

先定义一个Transform：

java 复制代码

public class ASMTransform extends Transform {
    // 给Transform起个名字
    @Override
    public String getName() {
        return "ASMTransform";
    }

    // 告诉Gradle我们要处理哪些类型的文件
    @Override
    public Set<QualifiedContent.ContentType> getInputTypes() {
        return Collections.singleton(QualifiedContent.DefaultContentType.CLASSES);
    }

    // 告诉Gradle我们要处理哪些范围的文件
    @Override
    public Set<QualifiedContent.Scope> getScopes() {
        return Sets.immutableEnumSet(QualifiedContent.Scope.PROJECT, 
                                     QualifiedContent.Scope.EXTERNAL_LIBRARIES);
    }

    // 是否支持增量编译（提升编译速度）
    @Override
    public boolean isIncremental() {
        return true;
    }

    // 核心方法：处理Class文件
    @Override
    public void transform(TransformInvocation invocation) throws TransformException, InterruptedException, IOException {
        // 1. 遍历所有输入的Class文件
        invocation.getInputs().forEach(input -> {
            // 处理项目自身的Class
            input.getDirectoryInputs().forEach(dirInput -> {
                processDir(dirInput.getFile());
                // 把处理后的文件输出到下一个流程
                File dest = invocation.getOutputProvider()
                    .getContentLocation(dirInput.getName(), dirInput.getContentTypes(), 
                                       dirInput.getScopes(), Format.DIRECTORY);
                FileUtils.copyDirectory(dirInput.getFile(), dest);
            });

            // 处理第三方库的Class（Jar包）
            input.getJarInputs().forEach(jarInput -> {
                processJar(jarInput.getFile());
                // 输出处理后的Jar
                File dest = invocation.getOutputProvider()
                    .getContentLocation(jarInput.getName(), jarInput.getContentTypes(),
                                       jarInput.getScopes(), Format.JAR);
                FileUtils.copyFile(jarInput.getFile(), dest);
            });
        });
    }

    // 处理目录中的Class文件
    private void processDir(File dir) {
        if (dir.isDirectory()) {
            for (File file : dir.listFiles()) {
                if (file.isDirectory()) {
                    processDir(file);
                } else if (file.getName().endsWith(".class")) {
                    // 用ASM处理单个Class文件
                    modifyClass(file);
                }
            }
        }
    }

    // 处理Jar包中的Class文件（略）
    private void processJar(File jarFile) { ... }
}

4.3 ASM实战：给所有方法加耗时统计

现在到了最关键的部分：用ASM修改Class文件。我们的目标是------给所有方法前后加上耗时统计，就像这样：

java 复制代码

// 原方法
public void login(String username) {
    // 登录逻辑
}

// 插桩后
public void login(String username) {
    long start = System.currentTimeMillis();
    // 登录逻辑
    long end = System.currentTimeMillis();
    Log.d("耗时", "login: " + (end - start) + "ms");
}

实现这个需求的ASM代码：

java 复制代码

private void modifyClass(File classFile) {
    try {
        // 1. 读取原Class文件
        ClassReader cr = new ClassReader(Files.readAllBytes(classFile.toPath()));
        // 2. 准备写入修改后的Class文件
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
        // 3. 自定义ClassVisitor处理类
        ClassVisitor cv = new ClassVisitor(Opcodes.ASM9, cw) {
            // 当访问到方法时回调
            @Override
            public MethodVisitor visitMethod(int access, String name, String descriptor, 
                                           String signature, String[] exceptions) {
                // 获取原始方法的MethodVisitor
                MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
                
                // 过滤掉构造方法和静态代码块
                if (name.equals("<init>") || name.equals("<clinit>")) {
                    return mv;
                }
                
                // 返回自定义的MethodVisitor，用于修改方法
                return new MethodVisitor(Opcodes.ASM9, mv) {
                    // 方法开始时调用（Code指令前）
                    @Override
                    public void visitCode() {
                        // 插入: long start = System.currentTimeMillis();
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", 
                                          "currentTimeMillis", "()J", false);
                        mv.visitVarInsn(Opcodes.LSTORE, 1); // 存储到局部变量1
                        
                        super.visitCode(); // 执行原方法的Code指令
                    }

                    // 方法结束时调用（return指令前）
                    @Override
                    public void visitInsn(int opcode) {
                        // 只在返回指令前插入代码
                        if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN) || 
                            opcode == Opcodes.ATHROW) {
                            
                            // 插入: long end = System.currentTimeMillis();
                            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", 
                                              "currentTimeMillis", "()J", false);
                            mv.visitVarInsn(Opcodes.LSTORE, 3); // 存储到局部变量3
                            
                            // 插入: Log.d("耗时", "方法名: " + (end - start) + "ms");
                            mv.visitLdcInsn("耗时"); // 日志标签
                            
                            // 拼接字符串："方法名: " + (end - start) + "ms"
                            mv.visitLdcInsn(name + ": ");
                            mv.visitVarInsn(Opcodes.LLOAD, 3); // 加载end
                            mv.visitVarInsn(Opcodes.LLOAD, 1); // 加载start
                            mv.visitInsn(Opcodes.LSUB); // end - start
                            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", 
                                              "toString", "(J)Ljava/lang/String;", false);
                            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", 
                                              "concat", "(Ljava/lang/String;)Ljava/lang/String;", false);
                            mv.visitLdcInsn("ms");
                            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", 
                                              "concat", "(Ljava/lang/String;)Ljava/lang/String;", false);
                            
                            // 调用Log.d
                            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "android/util/Log", 
                                              "d", "(Ljava/lang/String;Ljava/lang/String;)I", false);
                            mv.visitInsn(Opcodes.POP); // 消费返回值
                        }
                        
                        super.visitInsn(opcode); // 执行原返回指令
                    }
                };
            }
        };
        
        // 开始处理Class文件
        cr.accept(cv, ClassReader.EXPAND_FRAMES);
        
        // 4. 把修改后的字节码写回文件
        Files.write(classFile.toPath(), cw.toByteArray());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

4.4 注册插件，让插桩生效

最后一步，把我们的Transform注册到Gradle插件中：

java 复制代码

public class ASMPlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        // 获取Android扩展
        AppExtension android = project.getExtensions().getByType(AppExtension.class);
        // 注册我们的Transform
        android.registerTransform(new ASMTransform());
    }
}

在resources/META-INF/gradle-plugins/asmplugin.properties中声明插件：

ini 复制代码

implementation-class=com.example.ASMPlugin

然后在app模块的build.gradle中应用插件：

groovy 复制代码

plugins {
    id 'com.android.application'
    id 'asmplugin' // 应用我们的插件
}

这样，每次编译时，ASM就会自动给所有方法加上耗时统计了！

ASM进阶：那些你该知道的坑

5.1 字节码的"栈"规矩

JVM是基于栈的虚拟机，所有操作都要通过栈来完成。比如计算a + b：

arduino 复制代码

iload_1  // 把a推到栈顶
iload_2  // 把b推到栈顶
iadd     // 弹出a和b，相加后推回结果
istore_3 // 弹出结果，存到变量3

用ASM时一定要注意栈平衡，不然会报VerifyError。好消息是ClassWriter.COMPUTE_FRAMES能帮我们自动计算栈帧。

5.2 局部变量表的"座位"

每个方法都有局部变量表，就像电影院座位，每个变量占一个或多个座位（long/double占2个）。

在前面的例子中，我们用了LSTORE 1和LSTORE 3，这是因为：

非静态方法的第一个变量是this（索引0）
我们的start变量存在索引1（占2个位置）
所以end变量只能从索引3开始

5.3 别啥都插，会变慢的

全量插桩会显著增加编译时间和App体积。最好通过包名、注解等方式精准匹配需要插桩的类：

java 复制代码

// 在ClassVisitor中过滤
@Override
public void visit(int version, int access, String name, String signature, 
                 String superName, String[] interfaces) {
    // 只处理com/example包下的类
    if (name.startsWith("com/example/")) {
        super.visit(version, access, name, signature, superName, interfaces);
    } else {
        // 不处理，直接返回null
        cv = null;
    }
}

ASM能做的，远比你想象的多

除了加日志统计，ASM还能：

自动埋点：所有按钮点击自动上报
性能监控：检测方法耗时过长、频繁调用
代码修复：线上紧急bug无需发版，通过插桩修复
AOP编程：实现面向切面编程，解耦业务和非业务逻辑
热修复：配合其他技术实现类替换

知名的库如ARouter、ButterKnife、LeakCanary都用到了类似的插桩技术，只是有些用的是AspectJ或Javassist，但核心思想相通。

总结

学ASM的过程可能有点痛苦，毕竟要和字节码打交道。但一旦掌握，你会发现一个全新的世界------原来代码还能这么玩！

记住：工具是为了解决问题，不要为了用ASM而用ASM。当手动编码效率低下、代码侵入性强时，再请出这位"幕后英雄"也不迟。

最后送大家一句名言："不会ASM的Android开发者，不是好的字节码裁缝"（我说的）。现在，不如动手试试给你的项目加个ASM插桩吧！