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

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

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

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

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

本文不做对ASM框架的深入分析，仅仅通过一个例子介绍下整一个插桩流程:

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

  android_compile

• 建立好之后，删除包名，只保留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编写。

• 1.创建一个目标文件Target.java和一个标记需要插桩的注解InjectHello.java：

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

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

    }
}

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

接下来我们正式开始编写流程代码
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:

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使用插件查看对应的字节码：

bytecode.jpg

asmcode.jpg

8.我们把修改后的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:

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.好了，现在我们执行下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");

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

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