Android ASM插桩技术学习

已于 2022-09-19 15:42:14 修改
阅读量916 收藏 1
点赞数
文章标签： android 学习 java
于 2022-07-01 14:39:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47933729/article/details/125558393
版权

简介

ASM插桩在网上其实已经有很多资料了，我之所以再写这篇文章呢，一是因为好久前学习的ASM，现在已经忘的差不多了，需要再回顾一下，二来是记录一下学习过程，以后如果再有细节记不清楚可以很方便的就能查到，三来再学习的过程中也踩了一些坑，收获了一些心得，这些也需要一个地方记录一下。

好了，废话就说到这里，接下来开始正文。

插桩技术指在保证原有程序逻辑完整性的基础上，在程序中插入探针，通过探针采集代码中的信息（方法本身、方法参数值、返回值等）在特定的位置插入代码段，从而收集程序运行时的动态上下文信息。

插桩技术大体可以分为两类：

  • APT（Annotation Process Tools），在编译的时候，动态生成 Java 文件，之后编译器将生成的 Java 文件编译成 class 文件，像 ButterKnife、Dagger 就是通过 APT 的方式生成代码的。

    • 代表工具：ButterKnife

  • AOP（Aspect Oriented Programming），生成 class 文件后，修改 class 文件的字节码，达到修改代码的目的。

    • 代表工具：听云

工具

我们这次选用AOP技术，我们看看有哪些工具可以帮助我们完成插桩工作：

  • AspectJ，成熟稳定，使用者不需要对字节码文件有深入的理解，使用简单。但是其切入点相对固定，对于字节码文件的操作自由度以及开发的掌控度就大打折扣。并且，他会额外生成一些包装代码，对性能以及包大小有一定影响。

  • ASM，可以修改现有的字节码文件，也可以动态生成字节码文件，完全从字节码去操作字节码的框架，更加灵活，功能更加强大，可以根据需求自定义修改、插入、删除，性能也十分出色，但是要对字节码文件有比较深入的了解，上手也更难。

我们使用ASM来完成插桩，在介绍Android字节码插桩之前，需要先了解一下Java字节码的概念和Android程序打包过程。

字节码

我们知道，Java程序是运行在JVM（Java虚拟机）上的，Java源代码首先会由编译器（Java Compiler）编译成包含了Bytecode（字节码）的.class文件，程序执行时，由类加载器(class loader)将该类的字节码加载到JVM中，JVM会解释执行相应的Bytecode。如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rx92m9Dl-1656657474820)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fe8c7df420834af09d07cf5c1bde52b8~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

为什么不直接彻底编译成机器码，而需要字节码这个中间产物呢？Java是一门跨平台的语言，为了实现一份源码，处处运行的效果，每个平台都有对应不同的JVM，它会将源码对应的指令翻译成对应平台能够理解的机器指令。那为什么不从源码直接解释执行呢，我个人认为这是因为直接从源码开始的编译，速度非常慢，出于性能的考虑，先将源码做一些预处理，处理为字节码，来减轻运行前的编译的性能开销。

在做插桩之前，我们先要记住一点：Java 字节码指令是基于堆栈操作的，因为大部分的Java虚拟机对字节码的执行是基于堆栈的（Android的Dalvik虚拟机是基于寄存器的，不过不影响我们的插桩，因为在我们对java字节码插完桩后，才会执行从java字节码转换到dex文件的过程）

Android打包过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RQX8PmcW-1656657474822)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/84d4f89a8452465397c9d0392a1b5b09~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

Android插桩过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uExANGMV-1656657474822)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ef7c887b99f34fe186cba5bace804861~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FT7ir5zM-1656657474822)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fc778a12d5674eb29198bc555cd096fa~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

实战

这次，我们模仿听云，做一个Activity生命周期执行时间检测的插件。

我们先梳理一下功能点：

  1. 针对Activity类
  2. 针对生命周期方法
  3. 支持插件自定义配置

我们用Java代码把我们想要插入的逻辑写一遍：

public class Test {

    //这里取这个名字是为了防止和代码本身的成员变量产生冲突
    private long _$_timeRecorder;

    public void onCreate(Bundle savedInstanceState) {
        //向实际代码前插入代码
	_$_timeRecorder = -System.currentTimeMillis();
        
	... //这里是实际代码
        
        //向实际代码后插入代码
	_$_timeRecorder += System.currentTimeMillis();
	System.err.println("Time spent: " + _$_timeRecorder + "ms, when " + className + ".onCreate");
	StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
	for (StackTraceElement element : stackTraceElements) {
		System.err.println(element.getClassName() + "." + element.getMethodName() + ":" + element.getLineNumber());
	}
    }
}

接下来正式开始编写插件

新建插件工程

由于Android Studio没有新建gradle脚本的选项，我们先新建一个Empty Activity Project，在此基础上进行改造。

  1. 新建module
  2. 更改module的build.gradle文件
  3. 新建groovy源代码目录
  4. 新建groovy类实现Plugin<Project>接口
  5. 新建resource/META_INF/xxx.properites文件（xxx为插件的id名）
  6. 在properites文件中声明插件的实现类

为插件提供可配置的功能

  1. 新建一个实体类用来保存配置信息
public class AsmConfigModel {
	/**
	 * 以此参数为开头的类（全限定类名）才插桩
	 * 如果不配此参数则代表所有类都可插桩
	 */
	public List<String> startWithPatterns;
	/**
	 * 排除列表（全限定类名）
	 */
	public List<String> excludes;
	/**
	 * 排除列表（全限定类名）
	 * 以文件形式
	 */
	public File excludesByFile;
}
  1. 在插件apply的时候创建这个配置类，以提供给使用者配置
@Override
void apply(Project project) {
    println 'apply AsmPlugin'
    mConfig = project.extensions.create("asmConfig", AsmConfigModel.class)
}
  1. 在使用该插件的module下的build.gradle文件中配置
asmConfig {
    startWithPatterns = ['com.shanbay']
    excludesByFile = new File(projectDir, "asm-excludes.txt")
}
  1. 新建asm-excludes.txt文件，配置exclude信息
com/xxx/xxx/BaseActivity

这里是举个例子，在工程中很有可能有的Activity继承自一些基类Activity，对这些类插桩就重复了

使用Transform Api

根据官网介绍，Transform Api允许第三方 Plugin 在打包 dex 文件之前的编译过程中操作.class 文件，下图是Transform Api的工作流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8bKeRa1H-1656657474823)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/45696e712b674432908fe4beb67f1d12~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

可以看到，一次App的编译打包可能会经历多次Transform，Transform将输入进行处理，然后写入到指定的目录下作为下一个 Transform 的输入源。

使用插桩工具，我们需要借助于Transform Api实现

  1. 首先，我们需要让我们的插件继承自Transform
  2. 然后，我们要在插件apply时注册Transform
@Override
void apply(Project project) {
    println 'apply AsmPlugin'
    def android = project.extensions.getByType(AppExtension.class)
    android.registerTransform(this)
    mConfig = project.extensions.create("asmConfig", AsmConfigModel.class)
}
  1. 最后，需要实现Transform类中的抽象方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hxa1RBrZ-1656657474824)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/402b2ab5ce5e41e28d17ca9def7f0e3e~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

  • getName 这个方法是指定这个Transform的名称
@Override
String getName() {
    return 'AsmPlugin'
}
  • getInputTypes 这个方法是指定输入类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DRkBx5Zc-1656657474824)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/06d6c997bef74f70ac275cb8f032c319~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oaAGn74d-1656657474824)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9c4dbd4ac1044950a33041104bcc8a92~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

这里，我们选用TransformManager.CONTENT_CLASS就可以了

  • getScopes 这个方法是指定插桩的作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GJrdy88O-1656657474825)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e27f4fd6b7314beeb9d2d005a4bb98a5~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3YbZHIMZ-1656657474825)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fa9c48dfb3234dbcacaa1b376751ff70~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

这里我们选择TransformManager.SCOPE_FULL_PROJECT，代表插桩范围包括此工程和它依赖的所有包

  • isIncremental 这个方法代表是否开启增量编译

如果开启的话可以减少编译时间，但需要增加额外的判断条件，所以这里就先不开启了

  • transform 这个方法是核心方法，我们要对输入内容进行处理然后输出

transform()方法的参数 TransformInvocation 是一个接口，提供了一些关于输入输出的一些基本信息。下图是transform中我们需要走的流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3CnH07b3-1656657474826)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f4584ea9c660464d9888275eed888c94~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

这里以directoryInputs举例，directoryInputs就是本地源码编译后产生的class文件

private void handleDirectory(DirectoryInput input, TransformOutputProvider outputProvider) {
    File file = input.file

    if (file.isDirectory()) {
        //递归遍历该文件夹下面所有的子文件夹以及子文件
        file.eachFileRecurse { subFile ->
            def fileName = subFile.name
            //初步判断这个文件（或文件夹）是否可插桩
            if (fileName.endsWith(".class") && !fileName.startsWith("R$")
                    && "R.class" != fileName && "BuildConfig.class" != fileName) {
                //ClassReader: 字节码的读取与分析引擎
                ClassReader classReader = new ClassReader(subFile.bytes)
                //ClassWriter: 它实现了ClassVisitor接口，用于拼接字节码
                //COMPUTE_MAXS: 自动计算栈的最大值以及本地变量的最大数量
                //COMPUTE_FRAMES: 包含COMPUTE_MAXS，且会自动计算方法的栈桢
                ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS)
                //ClassVisitor: 定义在读取Class字节码时会触发的事件，如类头解析完成、注解解析、字段解析、方法解析等
                ClassVisitor cv = new AsmClassVisitor(api, classWriter, mConfig)
                //使给定的ClassVisitor访问传递给此构造函数的jvm类文件结构
                //EXPAND_FRAMES: 展开栈帧的标志位
                classReader.accept(cv, ClassReader.EXPAND_FRAMES)
                FileOutputStream fos = new FileOutputStream(
                        subFile.parentFile.absolutePath + File.separator + fileName)
                fos.write(classWriter.toByteArray())
                fos.close()
            }
        }
    }

    def dest = outputProvider.getContentLocation(
            input.name,
            input.contentTypes,
            input.scopes,
            Format.DIRECTORY
    )
    FileUtils.copyDirectoryToDirectory(file, dest)
}

可以用以下流程图大概描述一下一个class文件的修改过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EEWrFHeN-1656657474826)(https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/21520bd033574da6909139c80a480406~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image?)]

自定义ClassVisitor

我们开始继承ClassVisitor来实现我们对类的修改

读取配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DmXDlLfH-1656657474827)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5fa81ba499134d27821ed2389cf218af~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

访问类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2xs1CjBo-1656657474827)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ba63646137f94b74865528d136198060~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

通过这个方法我们可以获得这个类的访问控制，全限定类名，父类名，实现的接口名等信息

这里，我们通过全限定类名和读取出的配置做比对，进一步验证是否需要对此类进行插桩

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tAH1pI73-1656657474828)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ce24b21370bd4144a6b7b0047860e4a5~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zbFSHrbx-1656657474828)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4d8e3f0a480a4ecd85dceb5bc1f8d135~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

访问类内方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dobwjoRy-1656657474828)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f4109c47d30b404aa61e14bf34358d64~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

通过这个方法我们可以获得这个类的所有方法的名称和描述符，我们通过它们来判断该方法是否需要插桩

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GQj2WZhm-1656657474828)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1457e9ef5cea4206a59ad71850f0e0b0~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

如果有需要插桩的方法，就将mNeedStubClass标志位置为true，这个标识是为了我们后续判断是否要在该类中插入成员变量，然后使用我们自定义的MethodVisitor替换原始的MethodVisitor。

插入成员变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O1Yfbj4G-1656657474829)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f55e82fbd39a45e98742bdc8aa76c8d8~tplv-k3u1fbpfcp-zoom-in-crop-mark:1956:0:0:0.image)]

在最后，如果有需要插桩的方法，我们需要将private long _$_timeRecorder这个成员变量插入到类中去

自定义MethodVisitor

之前说了，Java 字节码指令是基于栈操作的，基本上任何操作都会改变栈状态

在方法执行之前插入代码

/**
* 以下代码会以栈的形式注释出来，以左边为栈顶，右边为栈底
* 示例：[栈顶 <------------------> 栈底]
* [this, StringBuilder, System.out]
* 此时，this为栈顶，System.out为栈底
*/
@Override
public void visitCode() {

    /*
        假设此时栈为空
    */

    //aload_0: 将this压入栈顶
    mv.visitVarInsn(Opcodes.ALOAD, 0);

    /*
        此时栈内容:
        [this]
    */

    //invokestatic: 调用静态方法System.currentTimeMillis()，返回值为基础类型long
    //第二个参数代表类的全限定名，第三个参数代表方法名，第四个参数代表函数签名，()J的意思是不接受参数，返回值为J (J在字节码里代表基础类型long)
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);

    /*
        此时栈内容:
        [System.currentTimeMillis()的结果值, this]
    */

    //lneg: 将栈顶的long类型取负并将结果压入栈顶
    mv.visitInsn(Opcodes.LNEG);

    /*
        此时栈内容:
        [System.currentTimeMillis()的结果值取负, this]
    */

    //putfield: 为该类的此实例变量赋值
    //以(栈顶 - 1)为执行对象，为其赋值为栈顶值 (this._$_timeRecorder = -System.currentTimeMillis())
    mv.visitFieldInsn(Opcodes.PUTFIELD, mClassName, TIMER_NAME, "J");
    super.visitCode();
}

在方法return之前插入代码

/**
* 以下代码会以栈的形式注释出来，以左边为栈顶，右边为栈底
* 示例：[栈顶 <------------------> 栈底]
* [this, StringBuilder, System.out]
* this为栈顶，System.out为栈底
*/
@Override
public void visitInsn(int opcode) {
    if (opcode == Opcodes.RETURN) {
        Label labelEnd = new Label();

        /*
            假设此时栈为空
        */

        //aload_0: 将this压入栈顶
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        //dup: 将栈顶的值复制一份压入栈顶
        mv.visitInsn(Opcodes.DUP);

        /*
            此时栈内容:
            [this, this]
        */

        //以当前栈顶的值为主体，获取当前类的成员变量_$_timeRecorder，类型为long
        //相当于this._$_timeRecorder
        mv.visitFieldInsn(Opcodes.GETFIELD, mClassName, TIMER_NAME, "J");

        /*
            此时栈内容:
            [this._$_timeRecorder, this]
        */

        //执行System.currentTimeMillis()，并将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);

        /*
            此时栈内容:
            [System.currentTimeMillis()执行后的结果值, this._$_timeRecorder, this]
        */

        //将栈顶两long值相加，并将结果压入栈顶
        //即this._$_timeRecorder + System.currentTimeMillis
        mv.visitInsn(Opcodes.LADD);

        /*
            此时栈内容:
            [System.currentTimeMillis() + this._$_timeRecorder, this]
        */

        //将栈顶的值存入(栈顶 - 1)._$_timeRecorder中
        //即this._$_timeRecorder = this._$_timeRecorder + System.currentTimeMillis
        mv.visitFieldInsn(Opcodes.PUTFIELD, mClassName, TIMER_NAME, "J");

        /*
            此时栈为空
        */

        //L: 对象类型，以分号结尾，如Ljava/lang/Object;
        mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");

        /*
            此时栈内容:
            [System.out]
        */

        //构建字符串
        //创建一个StringBuilder对象，此时还并没有执行构造方法
        mv.visitTypeInsn(Opcodes.NEW, "java/lang/StringBuilder");
        //因为执行构造函数会将栈顶的StringBuilder对象弹出，为了后续能继续使用这个对象，所以这里需要先复制一份
        mv.visitInsn(Opcodes.DUP);

        /*
            此时栈内容:
            [StringBuilder, StringBuilder, System.out]
        */

        //以栈顶的StringBuilder调用构造方法
        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
        */

        //将常量压入栈顶
        mv.visitLdcInsn("Time spent: ");

        /*
            此时栈内容:
            ["Time spent: ", StringBuilder, System.out]
        */

        //以栈顶的值为参数，(栈顶 - 1)的引用为主体执行StringBuilder.append()方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
        */

        //将this压入栈顶
        mv.visitVarInsn(Opcodes.ALOAD, 0);

        /*
            此时栈内容:
            [this, StringBuilder, System.out]
        */

        //以当前栈顶的值为主体，获取当前类的成员变量_$_timeRecorder，类型为long
        //相当于this._$_timeRecorder
        mv.visitFieldInsn(Opcodes.GETFIELD, mClassName, TIMER_NAME, "J");

        /*
            此时栈内容:
            [this._$_timeRecorder, StringBuilder, System.out]
        */

        //以栈顶的值为参数，(栈顶 - 1)的引用为主体执行StringBuilder.append()方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(J)Ljava/lang/StringBuilder;", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
        */

        //将常量压入栈顶
        mv.visitLdcInsn("ms, when " + mFormatClassName + "." + mMethodName + ":" + mMethodDescriptor);

        /*
            此时栈内容:
            [字符串常量, StringBuilder, System.out]
        */

        //以栈顶的值为参数，(栈顶 - 1)的引用为主体执行StringBuilder.append()方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
        */

        //以栈顶的值为主体，执行StringBuilder.toString()方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);

        /*
            此时栈内容:
            [String, System.out]
        */

        //以栈顶的值为参数，(栈顶 - 1)的引用为主体执行PrintStream.println()方法
        //相当于System.out.println(String)
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);

        /*
            此时栈为空
        */

        //执行Thread.currentThread()，并将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Thread", "currentThread", "()Ljava/lang/Thread;", false);

        /*
            此时栈内容:
            [Thread.currentThread()执行的结果]
        */

        //以栈顶的值为主体，执行getStackTrace()方法，将返回值压入栈顶
        //相当于Thread.currentThread().getStackTrace()
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Thread", "getStackTrace", "()[Ljava/lang/StackTraceElement;", false);

        /*
            此时栈内容:
            [StackTraceElement数组]
        */

        //astore: 将一个引用类型对象保存到局部变量表index为2的位置（index1: this, index2: onCreate方法的参数）
        //使用一个临时变量保存StackTraceElement数组
        mv.visitVarInsn(Opcodes.ASTORE, 2);
        //将局部变量表index2处的引用对象压入栈顶
        mv.visitVarInsn(Opcodes.ALOAD, 2);

        /*
            此时栈内容:
            [StackTraceElement数组]
            此时局部变量表中:
            [ 0        1             2           ]
            [this | Bundle | StackTraceElement数组]
        */

        //StackTraceElement数组备份
        mv.visitVarInsn(Opcodes.ASTORE, 3);
        mv.visitVarInsn(Opcodes.ALOAD, 3);

        /*
            此时栈内容:
            [StackTraceElement数组]
            此时局部变量表中:
            [ 0        1             2                       3           ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组]
        */

        //获得栈顶位置数组的长度
        mv.visitInsn(Opcodes.ARRAYLENGTH);

        /*
            此时栈内容:
            [StackTraceElement数组长度]
            此时局部变量表中:
            [ 0        1             2                       3           ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组]
        */

        //将数组length保存至局部变量表index4的位置
        mv.visitVarInsn(Opcodes.ISTORE, 4);

        /*
            此时栈为空
            此时局部变量表中:
            [ 0        1             2                       3                 4   ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度]
        */

        //将int常量0压入栈顶
        mv.visitInsn(Opcodes.ICONST_0);
        //将栈顶的0取出保存（用作循环下标index）
        mv.visitVarInsn(Opcodes.ISTORE, 5);

        /*
            此时栈为空
            此时局部变量表中:
            [ 0        1             2                       3                 4          5    ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index]
        */

        //循环开始处
        //插入一个label用来做后续循环跳转的标志
        Label labelLoop = new Label();
        mv.visitLabel(labelLoop);
        //将循环标志位的值压入栈顶
        mv.visitVarInsn(Opcodes.ILOAD, 5);
        //将数组长度值压入栈顶
        mv.visitVarInsn(Opcodes.ILOAD, 4);

        /*
            此时栈内容:
            [循环标志位, 数组长度]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5    ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index]
        */

        //if_icmpge: 比较栈顶两int型数值大小, 当结果大于等于0时跳转
        mv.visitJumpInsn(Opcodes.IF_ICMPGE, labelEnd);

        /*
            此时栈为空
            此时局部变量表中:
            [ 0        1             2                       3                 4          5    ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index]
        */

        //将StackTraceElement数组压入栈顶
        mv.visitVarInsn(Opcodes.ALOAD, 3);
        //将循环index的值压入栈顶
        mv.visitVarInsn(Opcodes.ILOAD, 5);

        /*
            此时栈内容:
            [循环index, StackTraceElement数组]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5    ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index]
        */

        //将引用类型数组指定索引的值推送至栈顶（var3[var5]）
        mv.visitInsn(Opcodes.AALOAD);

        /*
            此时栈内容:
            [StackTraceElement数组中的某个值(以循环index作为下标)]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5    ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index]
        */

        //将该索引下的值保存
        mv.visitVarInsn(Opcodes.ASTORE, 6);

        /*
            此时栈为空
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //将System.out入栈
        mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");

        /*
            此时栈内容:
            [System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //new StringBuilder()
        mv.visitTypeInsn(Opcodes.NEW, "java/lang/StringBuilder");
        mv.visitInsn(Opcodes.DUP);
        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //取出StackTraceElement数组中的某个值(以循环index作为下标)
        mv.visitVarInsn(Opcodes.ALOAD, 6);

        /*
            此时栈内容:
            [StackTraceElement数组中的某个值(以循环index作为下标), StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //使用栈顶对象，执行getClassName方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StackTraceElement", "getClassName", "()Ljava/lang/String;", false);

        /*
            此时栈内容:
            [ClassName, StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //以ClassName作为参数，执行(栈顶 - 1)对象的append方法，将返回值压入栈顶
        //即StringBuilder.append(ClassName)
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //将常量入栈
        mv.visitLdcInsn(".");
        //以常量作为参数，执行(栈顶 - 1)对象的append方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //将StackTraceElement数组中的某个值(以循环index作为下标)入栈
        mv.visitVarInsn(Opcodes.ALOAD, 6);
        //调用它的getMethodName方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StackTraceElement", "getMethodName", "()Ljava/lang/String;", false);

        /*
            此时栈内容:
            [MethodName, StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //以MethodName作为参数，执行(栈顶 - 1)对象的append方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //将常量入栈
        mv.visitLdcInsn(":");
        //以常量作为参数，执行(栈顶 - 1)对象的append方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //将StackTraceElement数组中的某个值(以循环index作为下标)入栈
        mv.visitVarInsn(Opcodes.ALOAD, 6);
        //调用它的getLineNumber方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StackTraceElement", "getLineNumber", "()I", false);

        /*
            此时栈内容:
            [LineNumber, StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //以LineNumber作为参数，执行(栈顶 - 1)对象的append方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;", false);

        /*
            此时栈内容:
            [StringBuilder, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //调用栈顶对象的toString方法，将返回值压入栈顶
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);

        /*
            此时栈内容:
            [String, System.out]
            此时局部变量表中:
            [ 0        1             2                       3                 4          5                             6                         ]
            [this | Bundle | StackTraceElement数组 | StackTraceElement数组 | 数组长度 | 循环index | StackTraceElement数组中的某个值(以循环index作为下标)]
        */

        //以String作为参数，执行(栈顶 - 1)对象System.out的println方法
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);

        //iinc: 将指定int型变量增加指定值(index++)
        mv.visitIincInsn(5, 1);
        //跳转到labelLoop插入的位置
        mv.visitJumpInsn(Opcodes.GOTO, labelLoop);

        //插入结束Label，作为循环终止的跳转标志
        mv.visitLabel(labelEnd);
    }

    super.visitInsn(opcode);
}

这样我们的方法插桩工作就完成了，接下来我们运行一下看看

运行

先clean build，再build，查看控制台信息，build完成后查看class文件

运行App，查看Logcat信息，可以看到打印出来了我们想要的信息。

结语

这样我们就通过插桩的方式，实现了一个简单的无任何代码侵入的性能检测工具

通过这一次实践，我对java的编译运行字节码，Android的打包流程有了更深的理解

完整项目地址：github.com/dreamgyf/As…

以上这篇文章的全部内容了，感谢各位的阅读，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎扫描关注博主一起学习！！

还有一些学习福利送给大家，有需要可扫描下方二维码免费领取

由于篇幅有限，这里以图片的形式给大家展示一小部分。

详细整理扫描下方二维码直接领取；

扫码免费即可领取文中资料，还有更多Android架构进阶学习资料和阿里年薪60W架构进阶学习路线图，729个知识点，3382页，66万字，都可以免费获取！！！

Android架构视频+BAT面试专题PDF+学习笔记

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

大模型学习路线
关注
Android 插桩入门，android进程和线程
m0_64603743的博客
12-12 577
通过gradle的插件完成android的插桩入门 首先学习编写一个简单的gradle插件 通过composing builds 方法引入这个插件方便调试 自己实现Transform方法来实现自己的插桩功能 通过Asm outline插件完成学习插桩代码 参考 本文中的代码通过参考以下的文章和仓库来学习 AndroidAutoTrack Hunter gradle脚本调试 ASM插入方法 完成一个简单的插件 本文设计到的代码都在这个项目中的AsmPlugin目录下代码 首先创建一个工程，这里是As
最通俗易懂的字节码插桩实战（Gradle + ASM）
2401_84149619的博客
04-21 962
总而言之，Android开发行业变化太快，作为技术人员就要保持终生学习的态度，让学习力成为核心竞争力，所谓“活到老学到老”只有不断的学习，不断的提升自己，才能跟紧行业的步伐，才能不被时代所淘汰。在这里我分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司20年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。
Android函数插桩
03-08 4404
一、什么是插桩 插桩：目标程序代码中某些位置插入或修改一些代码，从而在目标程序运行过程中获取某些程序状态并加以分析。简单来说就是在代码中插入代码。 函数插桩：便是在函数中插入或修改代码，在Android编译过程中，往字节码里插入自定义的字节码，所以也可以称为字节码插桩。 二、如何进行操作 完成插桩需要考虑以下两步： 1、寻找插入时机 了解Android打包流程 2、插入字节码 2.1、插桩入口 Transform API：Android Gradle提供，可操作获取字节码 2...
Android 插桩入门
最新发布
2401_87029424的博客
09-07 695
通过gradle的插件完成android的插桩入门。
Android插桩探索
qq_38490134的博客
04-19 860
字节码插桩可以通过修改“.class”的 Java 字节码实现，也可以通过修改“.dex”的 Dalvik 字节码实现，这取决于我们使用的插桩方法。相对于 Java 文件方式，字节码操作方式功能更加强大，应用场景也更广，但是它的使用复杂度更高
吹爆系列：Android 插桩之美，全面掌握
m0_64365896的博客
04-22 891
一、插桩 插桩是什么？你在开发中有用过插桩的技术吗？ 所谓的插桩就是在代码编译期间修改已有的代码或者生成新代码。 插桩具体在编译的哪个流程介入呢？ 二、插桩的作用与场景 代码生成 代码监控 代码修改 代码分析 Java 源文件方式 类似 AndroidAnnotation/APT(Annotation Processing Tool)，可以在代码编译期解析注解，并且生成新的 Java 文件，减少手动的代码输入。这些代码生成的场景，它们生成的都是 Java 文件，是在编译的最开始介入。典型的有 Green
Android ASM插桩探索及实战
Chenhui98的博客
09-05 1941
我们都知道，在Android编译过程中，Java代码会被编译成Class文件，Class文件再被打进Dex文件，虚拟机最终会加载Dex文件去执行。插桩，就是干涉代码的编译过程，在编译期间生成新的代码或者修改已有的代码。常用的EventBus、ARouter，内部就是使用了APT（Annotation Process Tool），在编译的最开始解析Java文件中的注解，并生成新的Java文件。给Activity的attach()方法加日志。
ASM插桩在Android项目中的应用
07-16
总的来说，ASM插桩技术为Android开发者提供了强大的代码增强能力，通过巧妙地利用ASM，我们可以实现许多传统方式难以达成的功能。然而，这也需要开发者对Java字节码有一定的了解，以及熟练掌握ASM框架的使用。通过...
Android-Android无痕埋点框架使用ASM插桩实现
08-13
本文将深入探讨如何使用ASM插桩技术来实现Android无痕埋点框架。 首先，我们需要了解ASM的基本概念。ASM是一个低级别的库，可以直接操作Java字节码，提供了一种动态生成和修改类的方法。它通过ClassWriter、...
Android Asm 插桩 教学项目
05-21
总的来说，"Android Asm 插桩 教学项目"是一个全面的实战教程，涵盖了Android开发中的多个高级主题，包括插桩技术、ASM字节码操作、Gradle插件开发和增量更新。通过这个项目，你将深化对Android底层机制的理解，并...
深入探索编译插桩技术（四、ASM 探秘）
Android技术之家
04-09 1390
本文来自jsonchao的投稿，个人微信：bcce5360 AspectJ 有着一系列弊端：由于其基于规则，所以其切入点相对固定，对于字节码文件的操作自由度以及开发...
Android字节码插桩
12-21
详见https://blog.csdn.net/huaxun66/article/details/103497729
tddebug怎么读取asm文件_ASM字节码插桩：QQ空间的热修复解决方案核心技术
weixin_39796652的博客
12-04 136
一、什么是插桩QQ空间曾经发布的《热修复解决方案》中利用 Javaassist库实现向类的构造函数中插入一段代码解决 CLASS_ISPREVERIFIED 问题。包括了 Instant Run 的实现以及参照 Instant Run 实现的热修复美团Robus等都利用到了插桩技术。插桩就是将一段代码插入或者替换原本的代码。字节码插桩顾名思义就是在我们编写的源码编译成字节码(Class)后，在An...
android 插桩工具,Android Asm 插桩 教学项目
weixin_36266554的博客
05-25 277
AndroidAutoTrack本项目主要就是给大家一个参考学习的demo而已，主要是打算简化学习gradle插件的成本，以及对于android transform的一次抽象，将增量更新等等进行一次抽象，以方便大家学习开发。double tap plugin 双击优化原理和无痕埋点相似，通过classvisitor的机制访问所有View.OnClickListener的子类，然后插入双击优化的代码...
Android 字节码插桩技术
Dream It Possible
05-10 289
字节码插桩技术简单来讲就是通过操作class文件的字节码，对class文件进行改造。在很多三方框架都有应用，比如路由框架ARouter，热修复框架Robust等。而字节码插桩一般都会使用ASM工具进行操作，这篇文章会介绍ASM的简单使用，下篇博客会详细介绍，Android项目中如何进行字节码插桩一、ASM的基本使用ASM的官方地址先创建一个原文件ASMTest.java编译之后会得到一个class文件，我们将这个class文件保存在相应的路径中，我们之后将会对这个class文件进行操作。
Android ASM插桩
qq_34231329的博客
06-30 658
ASM插桩在网上其实已经有很多资料了，我之所以再写这篇文章呢，一是因为好久前学习的ASM，现在已经忘的差不多了，需要再回顾一下，二来是记录一下学习过程，以后如果再有细节记不清楚可以很方便的就能查到，三来再学习的过程中也踩了一些坑，收获了一些心得，这些也需要一个地方记录一下。好了，废话就说到这里，接下来开始正文。插桩技术指在保证原有程序逻辑完整性的基础上，在程序中插入探针，通过探针采集代码中的信息（方法本身、方法参数值、返回值等）在特定的位置插入代码段，从而收集程序运行时的动态上下文信息。插桩技术大体可以分为
Android ASM字节码插桩
zenmela2011的专栏
07-03 3221
1.ASM ASM是一个字节码操作框架，可用来动态生成字节码或者对现有的类进行增强。ASM可以直接生成二进制的class字节码，也可以在class被加载进虚拟机前动态改变其行为，比如方法执行前后插入代码、添加成员变量、修改父类、添加接口等等。 插桩就是将一段代码插入或者替换原本的代码。字节码插桩就是在我们编写的源码编译成字节码（Class）后，在Android下生成dex之前修改Class文件，修改或者增强原有代码逻辑的操作。 比如需要查看方法执行耗时，如果每一个方法都需要自己手动去加入这些.
吹爆系列：Android 插桩之美，全面掌握~
1
04-21 2458
作者：阿明的小蝴蝶 插桩 插桩是什么？你在开发中有用过插桩的技术吗？ 所谓的插桩就是在代码编译期间修改已有的代码或者生成新代码。 插桩具体在编译的哪个流程介入呢？ 插桩的作用与场景 代码生成 代码监控 代码修改 代码分析 Java 源文件方式 类似 AndroidAnnotation/APT(Annotation Processing Tool)，可以在代码编译期解析注解，并且生成新的 Java 文件，减少手动的代码输入。 这些代码生成的场景，它们生成的都是 Java 文件，是在编译的最开始介入.
Android ASM
Vincent的博客
12-15 2006
version：Java 版本号。例如 V1_8 代表 Java 8access：class 访问权限，一般默认都是 ACC_PUBLIC | ACC_SUPER。具体说明如下标志名称标志值含义ACC_PUBLIC0x0001是否为 public 类型ACC_FINAL0x0010是否被声明为 final，只有类可设置ACC_SUPER0x0020。
ASM字节插桩技术核心文件下载
资源摘要信息:"asm字节插桩asm-master.zip" 知识点详细说明: 1. ASM概述： ASM（Abstract Syntax Mapping）是一个Java字节码操作和分析框架，它可以用于动态生成类或者增强既有类的功能。字节插桩（Bytecode ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值