初探ASM - JavaShuo

最近项目中产品要求接入神策埋点，神策最大的宣传点应该就是所谓无痕全埋点。对于这种"无痕"或者"无感知"，大部分Android老鸟的第一反应确定就是插桩吧。几年前在以前公司作系统开发时，开发过一套相似Android dumpsys的内部dump系统，经过串口命令输入参数，获取当前应用的相关指标，当时提供给应用开发的sdk就用到了AspectJ，经过统一插桩的方式，自动插入相关代码，减小应用开发的接入工做量和出错量。java

经过下载神策的插件并查看源码，的确和咱们预测同样，在编译期经过插桩方式调用sdk的相关方法，进行数据采集上报工做，和咱们以前项目使用的AspectJ的原理基本同样，只不过它使用的是ASM框架。android

什么是ASM，ASM是一个通用的Java字节码操做和分析框架。它能够用于修改现有类或直接以二进制形式动态生成类。 ASM提供了一些常见的字节码转换和分析算法，能够从中构建自定义复杂转换和代码分析工具。 ASM提供与其余Java字节码框架相似的功能，但专一于性能。由于它的设计和实现尽量小并且快，因此它很是适合在动态系统中使用（但固然也能够以静态方式使用，例如在编译器中）git

都是AOP框架，ASM更加注重的是性能，因此成为了各大公司涉及插桩需求项目的首选框架。github

首先咱们来看一张经典的Android编译流程图，ASM的原理是修改字节码，也就是修改编译生成的class文件，因此对应Android编译流程中的切入时机就是.classFiles和dex之间：
算法

本文不会对ASM框架作深刻的分析和高阶的使用，仅仅经过一个简单的例子介绍下整一个插桩流程和关注点:api

首先在Android Studio中建立一个项目，删除app module，新建一个Java library:

创建好以后，删除包名，只保留Java目录，便于执行命令。接着在build.gradle中添加ASM的依赖：

apply plugin: 'java-library'
apply plugin: 'kotlin'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar']) implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version" // asm远程依赖 implementation 'org.ow2.asm:asm:7.1' implementation 'org.ow2.asm:asm-commons:7.1' } sourceCompatibility = "1.8"
targetCompatibility = "1.8"
复制代码

此时，前期准备工做就完成了。首先说明一下本案例的目标：在一个testAsm的方法中插入一行代码System.out.println("Hello Asm");，因为须要经过命令编译，为了方便，咱们的target目标文件使用Java编写，流程代码使用Kotlin编写。markdown
1.建立一个目标文件Target.java和一个标记须要插桩的注解InjectHello.java：app

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.METHOD)
@interface InjectHello {
}

public class Target {
    @InjectHello
    private void testAsm() {

    }
}
复制代码

此时咱们先在Target.java所在目录下打开命令行，执行javac命令，生成对应的Target.class文件：

Target.class
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

public class Target {
    public Target() {
    }

    @InjectHello
    private void testAsm() {
    }
}
复制代码

接下来咱们正式开始编写流程代码 1.建立一个入口类和main方法:框架

1.读取刚刚编译生成的class文件
2.建立一个ClassReader实例，读取文件流
3.建立一个ClassWriter实例，用于写文件
4.调用reader.accept进行文件访问和修改
5.将修改后的字节流写入目标文件
6.完成对class文件的修改写入

class Main {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            val targetFile = "${System.getProperty("user.dir")}/example/src/main/java/Target.class"
            println("目标文件:$targetFile")
            val startTime = System.currentTimeMillis()
            val fis = FileInputStream(targetFile)
            val reader = ClassReader(fis)// 读取文件
            val writer = ClassWriter(ClassWriter.COMPUTE_FRAMES)// 写文件
            println("开始修改文件")
            // HelloClassVisitor为自定义的类访问器
            reader.accept(HelloClassVisitor(writer), ClassReader.EXPAND_FRAMES)// 访问class文件并修改
            val bytes = writer.toByteArray()// 获取修改后的流
            val fos = FileOutputStream(targetFile)
            println("写入文件:$targetFile")
            fos.write(bytes)// 将修改后字节流写入文件
            fos.flush()
            println("关闭文件流")
            fis.close()
            fos.close()
            println("本次插桩耗时:${System.currentTimeMillis() - startTime} ms")
        }
    }
}
复制代码

2.建立一个自定义class访问器HelloClassVisitor:ide

class HelloClassVisitor(visitor: ClassVisitor) : ClassVisitor(Opcodes.ASM7, visitor) {

    override fun visitMethod(access: Int, name: String?, descriptor: String?, signature: String?, exceptions: Array<out String>?): MethodVisitor {
        val visitMethod = super.visitMethod(access, name, descriptor, signature, exceptions)
        println("访问方法:$name, 描述符:$descriptor")
        return HelloMethodVisitor(visitMethod, access, name, descriptor)
    }
}
复制代码

3.咱们先建立一个自定义的Method方法访问器HelloMethodVisitor，这里使用AdviceAdapter:

class HelloMethodVisitor(methodVisitor: MethodVisitor, access: Int, name: String?, descriptor: String?) :
        AdviceAdapter(Opcodes.ASM7, methodVisitor, access, name, descriptor) {
    override fun visitAnnotation(descriptor: String?, visible: Boolean): AnnotationVisitor {
        return super.visitAnnotation(descriptor, visible)
    }

    override fun onMethodEnter() {
        super.onMethodEnter()
    }
}
复制代码

4.这时候咱们先暂停，看下这两个重写方法，从方法名咱们能够看出，一个是访问方法注解时的回调，一个是进入方法时的回调。还记的咱们的目标吗，就是往标记了注解的方法中插入一行打印代码，因此这两个方法就是咱们须要实现自定义逻辑的地方。

5.咱们先暂停继续编写代码，在AS中搜索安装一个插件ASM Bytecode Outline便于查看字节码和ASM代码文件:

6.咱们先编写一个目标文件，也就是咱们但愿插入打印后的文件Target2.java:

// 咱们指望插入打印后的代码：
public class Target2 {
    @InjectHello
    private void testAsm() {
        System.out.println("Hello Asm");
    }
}
复制代码

7.安装好插件后，选择咱们的Target2，右键点击Show Bytecode outline使用插件查看对应的字节码：

Java字节码:

ASM代码:

8.咱们把bytecode中修改后的testAsm方法部分代码拷贝出来以下，这就是咱们最终指望的产物:

// access flags 0x2
  private testAsm()V @LInjectHello;() // invisible
   L0
    LINENUMBER 8 L0
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "Hello Asm"
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
   L1
    LINENUMBER 9 L1
    RETURN
   L2
    LOCALVARIABLE this LTarget2; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1
复制代码

9.如今咱们对照这这个目标class文件，开始实现咱们的HelloMethodVisitor，有以下两种api实现方式:

class HelloMethodVisitor(methodVisitor: MethodVisitor, access: Int, name: String?, descriptor: String?) :
        AdviceAdapter(Opcodes.ASM7, methodVisitor, access, name, descriptor) {
    private var isInjectHello = false

    override fun visitAnnotation(descriptor: String?, visible: Boolean): AnnotationVisitor {
        println("访问方法:$name -注解:$descriptor")
        if (descriptor!! == Type.getDescriptor(InjectHello::class.java)) {
            println("标记了注解:$descriptor, 须要处理")
            isInjectHello = true
        }
        return super.visitAnnotation(descriptor, visible)
    }

    /** * ==========================> * Java方法： * private void testAsm() { * System.out.println("Hello Asm");// 准备插入的代码 * } * ==========================> * 对应字节码： * // access flags 0x2 * private testAsm()V * L0 * LINENUMBER 7 L0 * GETSTATIC java/lang/System.out : Ljava/io/PrintStream; * LDC "Hello Asm" * INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V * L1 * LINENUMBER 8 L1 * RETURN * L2 * LOCALVARIABLE this LTarget2; L0 L2 0 * MAXSTACK = 2 * MAXLOCALS = 1 * 对应ASM代码： * mv = cw.visitMethod(ACC_PRIVATE, "testAsm", "()V", null, null); * { * av0 = mv.visitAnnotation("LInjectHello;", false); * av0.visitEnd(); * } * mv.visitCode(); * Label l0 = new Label(); * mv.visitLabel(l0); * mv.visitLineNumber(8, l0); * mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); * mv.visitLdcInsn("Hello Asm"); * mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false); * Label l1 = new Label(); * mv.visitLabel(l1); * mv.visitLineNumber(9, l1); * mv.visitInsn(RETURN); * Label l2 = new Label(); * mv.visitLabel(l2); * mv.visitLocalVariable("this", "LTarget2;", null, l0, l2, 0); * mv.visitMaxs(2, 1); * mv.visitEnd(); */ 
    override fun onMethodEnter() {
        super.onMethodEnter()
        // 此处为方法开头
        if (isInjectHello) {
            println("开始插入代码: [ System.out.println(\"Hello Asm\"); ]")
            // **********方法1************
            // 对应->GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
            getStatic(Type.getType("Ljava/lang/System;"), "out", Type.getType("Ljava/io/PrintStream;"))
            // 对应->LDC "Hello Asm"
            visitLdcInsn("Hello Asm")
            // 对应->INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
            invokeVirtual(Type.getType("Ljava/io/PrintStream;"), Method("println", "(Ljava/lang/String;)V"))
            // **********方法2************
            // 直接从ASMified中复制代码，和方法1是等价的:
            // mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            // mv.visitLdcInsn("Hello Asm");
            //mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        }
    }

}
复制代码

10.好了，一套基础的ASM插桩流程已经准备好了，如今让咱们执行下Main.Companion#main的入口方法，发现控制台打印出以下:

目标文件:C:\Users\seagazer\Desktop\Asm/example/src/main/java/Target.class
开始修改文件
访问方法:<init>, 描述符:()V
访问方法:testAsm, 描述符:()V
访问方法:testAsm -注解:LInjectHello;
标记了注解:LInjectHello;, 须要处理
开始插入代码: [ System.out.println("Hello Asm"); ]
写入文件:C:\Users\seagazer\Desktop\Asm/example/src/main/java/Target.class
关闭文件流
本次插桩耗时:36 ms

Process finished with exit code 0
复制代码

11.最后，让咱们再看下最新生成的Target.class文件内容，对比上面的Target.class文件，说明咱们成功插入了System.out.println("Hello Asm"); 这行代码:

好了，到此咱们已经达成了咱们的目标，最后附上完整的代码: github.com/seagazer/as…

最后总结一下，目前不管是ASM，AspectJ或者其余AOP框架，在Android上的主要应用都是在插件transform中对代码进行修改，好比统一的插桩对方法进行耗时统计，点击事件的防抖处理等等，能够减小对原有代码的侵入性，提供统一的管理，下降修改工做量和出错几率。在使用第三方框架的时候，要多些思考，若是咱们本身实现，会怎么去设计方案，或者选择使用什么方式或者框架去实现，而不是简单的引入，完成业务需求，这样，才能保证自身能力的持续提高。