[转]自定义Gradle插件 + ASM实现字节码插桩

作者: 瑜小贤 | 来源:发表于2021-10-28 15:49 被阅读0次

1. 什么是插桩？

用通俗的话来讲，插桩就是将一段代码通过某种策略插入到另一段代码，或替换另一段代码。这里的代码可以分为源码和字节码，而我们所说的插桩一般指字节码插桩。
下图是Android开发者常见的一张图，我们编写的源码（.java）通过javac编译成字节码（.class），然后通过dx/d8编译成dex文件（.dex）。

我们下面要讲的插桩，就是在.class转为.dex之前，修改.class文件从而达到修改或替换代码的目的。
那有人肯定会有这样的疑问？既然插桩是插入或替换代码，那为何我不自己直接插入或替换呢？为何还要用这么“复杂”的工具？别着急，第二个问题将会给你答案。

2. 插桩的应用场景有哪些？

技术是服务于业务的，一个无法推进业务进步的技术并不值得我们学习。在上面，我们对插桩的理解是：插入，替换代码。那么，结合这个核心主线我们来挖掘插桩能被应用的场景有哪些？

代码插入

我们所熟悉的ButterKnife，Dagger这些常用的框架，也是在编译期间生成了代码，简化了程序员的操作。假设有这么一个需求，要监控某些或者所有方法的执行耗时？你会怎么做呢？如果你监控的方法只有十几个或者几十个，那么也许通过程序员自身的编码就能轻松解决；但是如果监控的方法达到百千甚至万级别，你还通过编码来解决？那么程序员存在的价值在哪里？面对这样的重复劳动问题，最先想到的就应该是自动化，也就是我们今天所讲的插桩。通过插桩，我们扫描每一个class文件，并针对特定规则进行字节码修改从而达到监控每个方法耗时的目的。关于如何实现这样的需求，后面我会详细讲述。

代码替换

如果遇到这么一个需求，需要将项目中所有使用某个方法（如Dialog.show()）的地方替换成自己包装的方法（MyDialog.show()），那么你该如何解决呢？有人会说，直接使用快捷键就能全局替换。那么有两个问题

如果有其他类定义了show()方法，并被调用了，直接使用快捷键是否会被错误替换？
如果其他引用包使用了该方法，你怎么替换呢？

没关系，插桩同样可以解决你的问题。
综合上面所说的两点，其实很多业务场景都使用了插桩技术，比如无痕埋点，性能监控等。

3. 掌握插桩应该具备的基础知识有哪些？

上面讲了插桩的应用场景，是否现在想跃跃欲试呢？别着急，想掌握好插桩技术，练就扎实的插桩功底，我们是需要具备一些基础知识的。

熟练掌握字节码相关技术。可参考一文让你明白Java字节码
Gradle自定义插件，直接参考官网 Writing Custom plugins
如果你想运用在Android项目中，那么还需要掌握Transform API,
这是android在将class转成dex之前给我们预留的一个接口，在该接口中我们可以通过插件形式来修改class文件。
字节码修改工具。如AspectJ，ASM，javasisst。这里我推荐使用ASM，关于ASM相关知识，在下一章我给大家简单介绍。同样大家可以参考 Asm官方文档
groovy语言基础
如果你具备了上面5块知识，那么恭喜你，会很顺利的完成字节码插桩技术了。下面，我通过实战一个很简单的例子，带领大家一起领略插桩的风采。

4. 使用ASM进行字节码插桩

4.1 什么是ASM?

ASM是生成和转换已编译的Java类工具，就是我们插桩需要使用的工具。

4.2 两种API？

ASM提供了两种API来生成和转换已编译类

一个是核心API，以基于事件形式来表示类
一个是树API，以基于对象形式来表示类

4.3 基于事件形式

我们通过上面的基础知识，了解到类的结构，类包含字段，方法，指令等；基于事件的API把类看作是一系列事件来表示，每一个类的事件表示一个类的元素。类似解析XML的SAX

4.4 基于对象形式

基于对象的API将类表示成一棵对象树，每个对象表示类的一部分。类似解析XML的DOM

4.5 优缺点比较

	事件形式	对象形式
内存占用	少	多
实现难度	难	易

通过上面表格，我们清楚的了解到：

事件API内存占用少于对象API，因为事件API不需要在内存中创建和存储对象树
事件API实现难度比对象API大，因为事件API在任意时刻类中只有一个元素可使用，但是对象API能获得整个类。

那么接下来，我们就通过比较容易实现的对象API入手，一起完成上面的需求。

我们Android的构建工具是Gradle，因此我们结合transform和Gradle插件方式来完成该需求，接下来我们来看看gradle官方提供的3种插件形式

4.6 Gradle插件的3种形式

插件形式	说明
Build script	直接在build script中写插件代码，不可复用
buildSrc	独立项目结构，只能在本构建体系中复用，无法提供给其他项目
Standalone	独立项目结构，发布到仓库，可以复用

由于我们是demo，并不需要共享给其他项目，因此采用buildSrc方式即可，但是正常项目中都采用Standalone形式。

5. 实践

5.1 目标

实现自定义gradle插件，通过ASM实现在MainActivity的onCreate中插入Log打印语句

5.2 自定义Gradle插件实现

gradle实现自定义插件一般有三种方式，考虑到灵活性，我们选择第三种Standalone方式实现自定义插件

5.2.1 创建module

创建一个新的module，删除不必要的文件，只留下build.gradle, src/main这两个文件和文件夹

5.2.2 创建目录和配置文件

创建代码目录
在src/main下创建 java和groovy目录以及 resources/META-INF/gradle-plugins目录，META-INF和gradle-plugins均为package
创建配置文件
在resources/META-INF/gradle-plugins下创建xxxx.properties文件, xxxx为apply plugin时用到的名字，文件中内容为implementation-class = 插件的完整路径，这里可以先空着，后面创建了插件后再填入

5.2.3 build.gradle编写

build.gradle中引入groovy和maven插件，然后引入gradle插件，asm以及gradle api和库，最后进行编译

注意：此处的定义的group + 此module名(或者archivesBaseName定义) + version 即是插件的依赖地址，下方仓库设置中的pom.groupId, pom.artifactId, pom.version是同样的效果，同时设置会生成两个不同地址

apply plugin: 'groovy'
apply plugin: 'maven'
 
dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
 
    implementation gradleApi()
    implementation localGroovy()
 
    implementation 'com.android.tools.build:gradle:3.5.3'
}
 
group='danny.lifecycle.plugin'
version='1.0.0'
 
uploadArchives {
    repositories {
        mavenDeployer {
//            pom.groupId = 'com.xxx.plugin.gradle'   //groupId
//            pom.artifactId = 'xxx'  //artifactId
//            pom.version = '1.0.2' //版本号
            //本地的Maven地址设置
            repository(url: uri('../asm_lifecycle_repo'))
        }
    }
}

5.2.4 编写插件

编译完成后在groovy中添加package，创建实现Plugin<>接口的类文件，先使用java文件便于包和类的引入，具体实现如下，编写完成后将.java后缀改成.groovy，这就是自定义插件的入口

public class LifeCyclePlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
    
    }
}

同级目录下创建继承Transform的类文件，同样使用java文件导入包和引用类，具体实现如下，编写完成后后缀改为.groovy，Transform的作用是可以在项目构建过程中.class文件转换成.dex文件期间获取到.class文件进行读取修改操作

public class LifeCycleTransform extends Transform {
    @Override
    public String getName() {
        return "LifeCycleTransform";
    }
 
    @Override
    public Set<QualifiedContent.ContentType> getInputTypes() {
        return TransformManager.CONTENT_CLASS;
    }
 
    @Override
    public Set<? super QualifiedContent.Scope> getScopes() {
        return TransformManager.PROJECT_ONLY;
    }
 
    @Override
    public boolean isIncremental() {
        return false;
    }
 
    @Override
    public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
    
    }
}

getName()：这里可以指定此task的名字，不过最终名字需要做一些拼接，transformClassesWith名字ForDebug/Release

getInputTypes()：处理的文件类型，此处为class文件

getScopes()：作用范围，此处为只处理当前项目文件

isIncremental()：是否支持增量编译

transform(TransformInvocation transformInvocation)：主要处理文件和jar包的方法

编写完transform后，在plugin中进行注册，AppExtension就是指的build.gradle中的android{}闭包

public class LifeCyclePlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        def extension = project.extensions.getByType(AppExtension)
 
        LifeCycleTransform transform = new LifeCycleTransform();
        extension.registerTransform(transform)
    }
}

5.2.5 生成仓库

此时在gradle任务中生成了uploadArchives任务，双击后即可生成插件仓库

5.2.6 自定义gradle插件引入和使用

在项目的根目录build.gradle中添加仓库路径，然后在dependencies中添加classpath，引入插件

buildscript {
    repositories {
        google()
        jcenter()
        maven {
            url uri('./asm_lifecycle_repo')
        }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.5.3'
        classpath 'danny.lifecycle.plugin:asm_lifecycle_plugin3:1.0.0'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

接着在要使用的module的build.gradle中通过apply plugin引入插件使用

apply plugin: 'com.android.application'
apply plugin: 'danny.asm.lifecycle'

这样，就完成了自定义gradle插件的编写和使用

5.3. ASM实现字节码插桩

5.3.1 引入ASM

完成自定义gradle插件后，在插件的build.gradle中添加ASM依赖

apply plugin: 'groovy'
apply plugin: 'maven'
 
dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
 
    implementation gradleApi()
    implementation localGroovy()
 
    implementation 'com.android.tools.build:gradle:3.5.3'
 
    //ASM相关依赖
    implementation 'org.ow2.asm:asm:7.1'
    implementation 'org.ow2.asm:asm-commons:7.1'
}
 
group='danny.lifecycle.plugin'
version='1.0.0'
 
uploadArchives {
    repositories {
        mavenDeployer {
//            pom.groupId = 'com.xxx.plugin.gradle'   //groupId
//            pom.artifactId = 'xxx'  //artifactId
//            pom.version = '1.0.2' //版本号
            //本地的Maven地址设置
            repository(url: uri('../asm_lifecycle_repo'))
        }
    }
}

5.3.2 创建Visitor

在自定义插件module中的src/main/java下添加package，然后创建继承ClassVisitor的类文件，实现visit，visitMethod方法

public class LifecycleClassVisitor extends ClassVisitor {
    private String className;
    private String superName;
 
    public LifecycleClassVisitor(ClassVisitor classVisitor) {
        super(Opcodes.ASM5, classVisitor);
    }
 
    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        super.visit(version, access, name, signature, superName, interfaces);
        this.className = name;
        this.superName = superName;
    }
 
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor methodVisitor = cv.visitMethod(access, name, descriptor, signature, exceptions);
        if (className.equals("com/example/lifecycledemo/MainActivity") && superName.equals("androidx/appcompat/app/AppCompatActivity")) {
            if (name.startsWith("onCreate")) {
                return new LifeCycleMethodVisitor(Opcodes.ASM5, methodVisitor, access, name, descriptor, className, superName);
            }
        }
        return methodVisitor;
    }
 
    @Override
    public void visitEnd() {
        super.visitEnd();
        System.out.println("ClassVisitor visitEnd()");
    }
}

在visit方法中获取类名，超类名，在visitMethod方法中筛选类名MainActivity，超类AppCompatActivity的文件，接着筛选onCreate方法，最后返回一个继承自 AdviceAdater的类

public class LifeCycleMethodVisitor extends AdviceAdapter {
    private String className;
    private String methodName;
 
    protected LifeCycleMethodVisitor(int api, MethodVisitor methodVisitor, int access, String name, String descriptor, String className, String superName) {
        super(api, methodVisitor, access, name, descriptor);
        this.className = className;
        this.superName = superName;
        System.out.println("MethodVisitor Constructor");
    }
 
    @Override
    protected void onMethodEnter() {
        super.onMethodEnter();
        System.out.println("MethodVisitor visitCode========");
 
        mv.visitLdcInsn("TAG");
        mv.visitLdcInsn(className + "---->" + methodName);
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "android/util/Log", "i", "(Ljava/lang/String;Ljava/lang/String;)I", false);
        mv.visitInsn(Opcodes.POP);
    }
 
    @Override
    protected void onMethodExit(int opcode) {
        mv.visitLdcInsn("TAG");
        mv.visitLdcInsn("this is end");
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "android/util/Log", "i", "(Ljava/lang/String;Ljava/lang/String;)I", false);
        mv.visitInsn(Opcodes.POP);
        super.onMethodExit(opcode);
    }
}

在继承了AdviceAdapter的类中，实现onMethodEnter和onMethodExit方法，对应onCreate方法的开始和结束节点，在这两个节点通过MethodVisitor的一系列api调用插入Log打印语句

visitLdcInsn(final Object value)对应LDC指令

visitMethodInsn(final int opcode, final String owner, final String name, final String descriptor, final boolean isInterface)是访问方法指令，此处用到的五个参数

opcode: 对应字节码指令操作码，此处传入了调用类方法的指令
owner: 方法所在包
name: 方法名
descriptor: 方法描述符，前一个Ljava/lang/String:Ljava/lang/String指明方法有两个String类型参数，最后的 I 表示方法返回int类型
isInterface: 是否是接口类的实现方法

visitInsn()对应空操作数指令，比如POP, DUP

注：此处也可直接继承MethodVisitor，实现visitCode方法插入代码，但要实现在方法结束前插入代码需要另外实现visitInsn(int opcode)方法，根据opcode == RETURN来判断指令执行到方法末尾了，插入代码后再调用super方法即可

5.3.3 读取class文件数据

在自定义继承Transform类的transform方法中进行操作，通过getInputs()获取输入的class文件和jar包的路径，outputProvider管理输出路径，接着遍历inputs，directoryInputs获取到class文件的路径集合，再次遍历，筛选出class文件，通过ClassReader进行读取，ClassWriter进行写入，将classWriter传入自定义的ClassVisitor中，接着调用classReader的accept方法正式对class文件进行读取并调用classVisitor中的方法，比如visit()，visitMethod()等，我们在里面对MainActivity的onCreate方法中加入了一行Log打印语句，然后通过classWriter的toByteArray()方法输出修改后的class文件btye数组，覆盖掉原来的class文件，最后将修改后的class文件目录整个copy新的目录下，这个新目录是根据输入的内容，作用范围等信息生成的，供下一个Task使用

    @Override
    public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        Collection<TransformInput> inputs = transformInvocation.getInputs()
        TransformOutputProvider outputProvider = transformInvocation.outputProvider
 
        inputs.each {TransformInput input ->
            input.directoryInputs.each {DirectoryInput directoryInput ->
                File dir = directoryInput.file
                if (dir) {
                    dir.traverse (type: FileType.FILES, nameFilter: ~/.*\.class/) { File file ->
                        println("find class: " + file.name)
                        //对class文件进行读取
                        ClassReader classReader = new ClassReader(file.bytes)
                        //对class文件的写入
                        ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS)
                        //访问class文件相应的内容，解析到某一个结构就会通知到classVisitor相应的方法
                        println("before visit")
                        ClassVisitor visitor = new LifecycleClassVisitor(classWriter)
                        println("after visit")
                        //依次调用ClassVisitor接口的各个方法
                        classReader.accept(visitor, ClassReader.EXPAND_FRAMES)
                        println("after accept")
                        //toByteArray方法会将最终修改的字节码以byte数组形式返回
                        byte[] bytes = classWriter.toByteArray()
                        //通过文件流写入方式覆盖掉原先的内容，实现class文件的改写
                        FileOutputStream fileOutputStream = new FileOutputStream(file.path)
                        fileOutputStream.write(bytes)
                        fileOutputStream.close()
                    }
                }
 
                def dest = outputProvider.getContentLocation(directoryInput.name, directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)
                FileUtils.copyDirectory(directoryInput.file, dest)
            }
        }
    }

5.3.4 运行

代码都全部编写之后，再次点击uploadArchives任务生成本地仓库，然后就可以运行项目检测插桩是否成功了，这是项目中的MainActivity文件，可以看到只在onCreate中第一行打印了一个log

public class MainActivity extends AppCompatActivity {
   
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.i("TAG", "is this the first log?");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

项目运行后，在LogCat中筛选TAG，可以看到打印语句的输出，onMethodEnter中插入的语句最先输出，接着是在onCreate方法开头的语句，最后是在onMethodExit中插入的语句

5.4. 总结

自定义Gradle插件遵循一定的规则，手动实现几次就能掌握，插件和ASM的衔接在Transform中完成，插件负责输入数据，ASM接收数据后进行字节码修改，最后再重新输出，ASM的使用主要还是流程和api的掌握，比较不好编写的是最终插入和修改字节码的api，如果对字节码指令不太熟悉的话可以安装一个ASM Bytecode Viewer插件，将相关操作在java文件中完成，运用插件编译成字节码和ASM指令格式，照搬过来就行

转自：
https://www.jianshu.com/p/13d18c631549
https://blog.csdn.net/tushiba/article/details/106361871