一起来玩转Android项目中的字节码

作者 : 开心源码 本文共31102个字,预计阅读时间需要78分钟 发布时间: 2022-05-12 共124人阅读

作为Android开发,日常写Java代码之余,能否想过,玩玩class文件?直接对class文件的字节码下手,我们可以做很多好玩的事情,比方:

  • 对全局所有class插桩,做UI,内存,网络等等方面的性能监控
  • 发现某个第三方依赖,用起来不爽,但是不想拿它的源码修改再重新编译,而想对它的class直接做点手脚
  • 每次写打log时,想让TAG自动生成,让它默认就是当前类的名称,甚至你想让log里自动加受骗前代码所在的行数,更方便定位日志位置
  • Java自带的动态代理商太弱了,只能对接口类做动态代理商,而我们想对任何类做动态代理商

为了实现上面这些想法,可能我们最开始的第一反应,都是是否通过代码生成技术、APT,抑或者反射、抑或者动态代理商来实现,但是想来想去,貌似这些方案都不能很好满足上面的需求,而且,有些问题不能从Java文件入手,而应该从class文件寻觅突破。而从class文件入手,我们就不得不来近距离接触一下字节码!

JVM平台上,修改、生成字节码无处不在,从ORM框架(如Hibernate, MyBatis)到Mock框架(如Mockio),再到Java Web中的常青树Spring框架,再到新兴的JVM语言Kotlin的编译器,还有大名鼎鼎的cglib项目,都有字节码的身影。

字节码相关技术的强大之处自然不用多说,而且在Android开发中,无论是使用Java开发和Kotlin开发,都是JVM平台的语言,所以假如我们在Android开发中,使用字节码技术做一下hack,还可以天然地兼容Java和Kotlin语言。

今天写这篇文章,分享自己摸索相关技术过程中的少量鸡肋。

这个项目主要使用的技术是Android gradle插件,Transform,ASM与字节码基础。这篇文章将主要围绕以下几个技术点开展:

  • Transform的应用、原理、优化
  • ASM的应用,开发流,以及与Android工程的适配
  • 几个具体应用案例

所以阅读这篇文章,读者最好有Android开发以及编写简单Gradle插件的背景知识。

话不多说,让我们开始吧。

一、Transform

引入Transform

Transform是Android gradle plugin 1.5开始引入的概念。

我们先从如何引入Transform依赖说起,首先我们需要编写一个自己设置插件,而后在插件中注册一个自己设置Transform。这其中我们需要先通过gradle引入Transform的依赖,这里有一个坑,Transform的库最开始是独立的,后来从2.0.0版本开始,被纳入了Android编译系统依赖的gradle-api中,让我们看看Transform在jcenter上的历个版本。

所以,很久很久以前我引入transform依赖是这样

compile 'com.android.tools.build:transform-api:1.5.0'

现在是这样

//从2.0.0版本开始就是在gradle-api中了implementation 'com.android.tools.build:gradle-api:3.1.4'

而后,让我们在自己设置插件中注册一个自己设置Transform,gradle插件可以使用java,groovy,kotlin编写,我这里选择使用java。

public class CustomPlugin implements Plugin<Project> {    @SuppressWarnings("NullableProblems")    @Override    public void apply(Project project) {        AppExtension appExtension = (AppExtension)project.getProperties().get("android");        appExtension.registerTransform(new CustomTransform(), Collections.EMPTY_LIST);    }}

那么如何写一个自己设置Transform呢?

Transform的原理与应用

详情如何应用Transform之前,我们先详情Transform的原理,一图胜千言

每个Transform其实都是一个gradle task,Android编译器中的TaskManager将每个Transform串连起来,第一个Transform接收来自javac编译的结果,以及已经拉取到在本地的第三方依赖(jar. aar),还有resource资源,注意,这里的resource并非android项目中的res资源,而是asset目录下的资源。这些编译的中间产物,在Transform组成的链条上流动,每个Transform节点可以对class进行解决再传递给下一个Transform。我们常见的混淆,Desugar等逻辑,它们的实现如今都是封装在一个个Transform中,而我们自己设置的Transform,会插入到这个Transform链条的最前面。

但其实,上面这幅图,只是展现Transform的其中一种情况。而Transform其实可以有两种输入,一种是消费型的,当前Transform需要将消费型型输出给下一个Transform,另一种是引用型的,当前Transform可以读取这些输入,而不需要输出给下一个Transform,比方Instant Run就是通过这种方式,检查两次编译之间的diff的。至于怎样在一个Transform中公告两种输入,以及怎样解决两种输入,后面将有示例代码。

为了印证Transform的工作原理和应用方式,我们也可以从Android gradle plugin源码入手找出证据,在TaskManager中,有一个方法createPostCompilationTasks.为了避免贴篇幅太长的源码,这里附上链接

TaskManager#createPostCompilationTasks

这个方法的脉络很清晰,我们可以看到,Jacoco,Desugar,MergeJavaRes,AdvancedProfiling,Shrinker,Proguard, JarMergeTransform, MultiDex, Dex都是通过Transform的形式一个个串联起来。其中也有将我们自己设置的Transform插进去。

讲完了Transform的数据流动的原理,我们再来详情一下Transform的输入数据的过滤机制,Transform的数据输入,可以通过Scope和ContentType两个维度进行过滤。

ContentType,顾名思义,就是数据类型,在插件开发中,我们一般只能使用CLASSES和RESOURCES两种类型,注意,其中的CLASSES已经包含了class文件和jar文件

从图中可以看到,除了CLASSES和RESOURCES,还有少量我们开发过程无法使用的类型,比方DEX文件,这些隐藏类型在一个独立的枚举类ExtendedContentType中,这些类型只能给Android编译器使用。另外,我们一般使用 TransformManager中提供的几个常用的ContentType集合和Scope集合,假如是要解决所有class和jar的字节码,ContentType我们一般使用TransformManager.CONTENT_CLASS。

Scope相比ContentType则是另一个维度的过滤规则,

我们可以发现,左边几个类型可供我们使用,而我们一般都是组合使用这几个类型,TransformManager有几个常用的Scope集合方便开发者使用。
假如是要解决所有class字节码,Scope我们一般使用TransformManager.SCOPE_FULL_PROJECT。

好,目前为止,我们详情了Transform的数据流动的原理,输入的类型和过滤机制,我们再写一个简单的自己设置Transform,让我们对Transform可以有一个更具体的认识

public class CustomTransform extends Transform {    public static final String TAG = "CustomTransform";    public CustomTransform() {        super();    }    @Override    public String getName() {        return "CustomTransform";    }    @Override    public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {        super.transform(transformInvocation);        //当前能否是增量编译        boolean isIncremental = transformInvocation.isIncremental();        //消费型输入,可以从中获取jar包和class文件夹路径。需要输出给下一个任务        Collection<TransformInput> inputs = transformInvocation.getInputs();        //引用型输入,无需输出。        Collection<TransformInput> referencedInputs = transformInvocation.getReferencedInputs();        //OutputProvider管理输出路径,假如消费型输入为空,你会发现OutputProvider == null        TransformOutputProvider outputProvider = transformInvocation.getOutputProvider();        for(TransformInput input : inputs) {            for(JarInput jarInput : input.getJarInputs()) {                File dest = outputProvider.getContentLocation(                        jarInput.getFile().getAbsolutePath(),                        jarInput.getContentTypes(),                        jarInput.getScopes(),                        Format.JAR);                //将修改过的字节码copy到dest,即可以实现编译期间干预字节码的目的了                        FileUtils.copyFile(jarInput.getFile(), dest);            }            for(DirectoryInput directoryInput : input.getDirectoryInputs()) {                File dest = outputProvider.getContentLocation(directoryInput.getName(),                        directoryInput.getContentTypes(), directoryInput.getScopes(),                        Format.DIRECTORY);                //将修改过的字节码copy到dest,即可以实现编译期间干预字节码的目的了                        FileUtils.copyDirectory(directoryInput.getFile(), dest);            }        }    }    @Override    public Set<QualifiedContent.ContentType> getInputTypes() {        return TransformManager.CONTENT_CLASS;    }    @Override    public Set<? super QualifiedContent.Scope> getScopes() {        return TransformManager.SCOPE_FULL_PROJECT;    }    @Override    public Set<QualifiedContent.ContentType> getOutputTypes() {        return super.getOutputTypes();    }    @Override    public Set<? super QualifiedContent.Scope> getReferencedScopes() {        return TransformManager.EMPTY_SCOPES;    }    @Override    public Map<String, Object> getParameterInputs() {        return super.getParameterInputs();    }    @Override    public boolean isCacheable() {        return true;    }    @Override     public boolean isIncremental() {        return true; //能否开启增量编译    }}

可以看到,在transform方法中,我们将每个jar包和class文件复制到dest路径,这个dest路径就是下一个Transform的输入数据,而在复制时,我们即可以做少量狸猫换太子,偷天换日的事情了,先将jar包和class文件的字节码做少量修改,再进行复制就可,至于怎样修改字节码,就要借助我们后面详情的ASM了。而假如开发过程要看你当前transform解决之后的class/jar包,可以到
/build/intermediates/transforms/CustomTransform/下查看,你会发现所有jar包命名都是123456递增,这是正常的,这里的命名规则可以在OutputProvider.getContentLocation的具体实现中找到

public synchronized File getContentLocation(        @NonNull String name,        @NonNull Set<ContentType> types,        @NonNull Set<? super Scope> scopes,        @NonNull Format format) {    // runtime check these since it's (indirectly) called by 3rd party transforms.    checkNotNull(name);    checkNotNull(types);    checkNotNull(scopes);    checkNotNull(format);    checkState(!name.isEmpty());    checkState(!types.isEmpty());    checkState(!scopes.isEmpty());    // search for an existing matching substream.    for (SubStream subStream : subStreams) {        // look for an existing match. This means same name, types, scopes, and format.        if (name.equals(subStream.getName())                && types.equals(subStream.getTypes())                && scopes.equals(subStream.getScopes())                && format == subStream.getFormat()) {            return new File(rootFolder, subStream.getFilename());        }    }    //按位置递增!!       // didn't find a matching output. create the new output    SubStream newSubStream = new SubStream(name, nextIndex++, scopes, types, format, true);    subStreams.add(newSubStream);    return new File(rootFolder, newSubStream.getFilename());}

Transform的优化:增量与并发

到此为止,看起来Transform用起来也不难,但是,假如直接这样使用,会大大拖慢编译时间,为理解决这个问题,摸索了一段时间后,也借鉴了Android编译器中Desugar等几个Transform的实现,发现我们可以使用增量编译,并且上面transform方法遍历解决每个jar/class的流程,其实可以并发解决,加上一般编译流程都是在PC上,所以我们可以尽量敲诈机器的资源。

想要开启增量编译,我们需要重写Transform的这个接口,返回true。

@Override public boolean isIncremental() {    return true;}

尽管开启了增量编译,但也并非每次编译过程都是支持增量的,毕竟一次clean build完全没有增量的基础,所以,我们需要检查当前编译能否是增量编译。

假如不是增量编译,则清空output目录,而后按照前面的方式,一一class/jar解决
假如是增量编译,则要检查每个文件的Status,Status分四种,并且对这四种文件的操作也不尽相同

  • NOTCHANGED: 当前文件不需解决,甚至复制操作都不用;
  • ADDED、CHANGED: 正常解决,输出给下一个任务;
  • REMOVED: 移除outputProvider获取路径对应的文件。

大概实现可以一起看看下面的代码

@Overridepublic void transform(TransformInvocation transformInvocation){    Collection<TransformInput> inputs = transformInvocation.getInputs();    TransformOutputProvider outputProvider = transformInvocation.getOutputProvider();    boolean isIncremental = transformInvocation.isIncremental();    //假如非增量,则清空旧的输出内容    if(!isIncremental) {        outputProvider.deleteAll();    }       for(TransformInput input : inputs) {        for(JarInput jarInput : input.getJarInputs()) {            Status status = jarInput.getStatus();            File dest = outputProvider.getContentLocation(                    jarInput.getName(),                    jarInput.getContentTypes(),                    jarInput.getScopes(),                    Format.JAR);            if(isIncremental && !emptyRun) {                switch(status) {                    case NOTCHANGED:                        continue;                    case ADDED:                    case CHANGED:                        transformJar(jarInput.getFile(), dest, status);                        break;                    case REMOVED:                        if (dest.exists()) {                            FileUtils.forceDelete(dest);                        }                        break;                }            } else {                transformJar(jarInput.getFile(), dest, status);            }        }        for(DirectoryInput directoryInput : input.getDirectoryInputs()) {            File dest = outputProvider.getContentLocation(directoryInput.getName(),                    directoryInput.getContentTypes(), directoryInput.getScopes(),                    Format.DIRECTORY);            FileUtils.forceMkdir(dest);            if(isIncremental && !emptyRun) {                String srcDirPath = directoryInput.getFile().getAbsolutePath();                String destDirPath = dest.getAbsolutePath();                Map<File, Status> fileStatusMap = directoryInput.getChangedFiles();                for (Map.Entry<File, Status> changedFile : fileStatusMap.entrySet()) {                    Status status = changedFile.getValue();                    File inputFile = changedFile.getKey();                    String destFilePath = inputFile.getAbsolutePath().replace(srcDirPath, destDirPath);                    File destFile = new File(destFilePath);                    switch (status) {                        case NOTCHANGED:                            break;                        case REMOVED:                            if(destFile.exists()) {                                FileUtils.forceDelete(destFile);                            }                            break;                        case ADDED:                        case CHANGED:                            FileUtils.touch(destFile);                            transformSingleFile(inputFile, destFile, srcDirPath);                            break;                    }                }            } else {                transformDir(directoryInput.getFile(), dest);            }        }    }}

这就能为我们的编译插件提供增量的特性。

实现了增量编译后,我们最好也支持并发编译,并发编译的实现并不复杂,只要要将上面解决单个jar/class的逻辑,并发解决,最后阻塞等待所有任务结束就可。

private WaitableExecutor waitableExecutor = WaitableExecutor.useGlobalSharedThreadPool();//异步并发解决jar/classwaitableExecutor.execute(() -> {    bytecodeWeaver.weaveJar(srcJar, destJar);    return null;});waitableExecutor.execute(() -> {    bytecodeWeaver.weaveSingleClassToFile(file, outputFile, inputDirPath);    return null;});  //等待所有任务结束waitableExecutor.waitForTasksWithQuickFail(true);

接下来我们对编译速度做一个比照,每个试验都是5次同种条件下编译10次,去除最大大小值,取平均时间

首先,在QQ邮箱Android用户端工程中,我们先做一次cleanbuild

./gradlew clean assembleDebug --profile

给项目中增加UI耗时统计,全局每个方法(包括普通class文件和第三方jar包中的所有class)的第一行和最后一行都进行插桩,实现方式就是Transform+ASM,比照一下并发Transform和非并发Transform下,Tranform这一步的耗时

可以发现,并发编译,基本比非并发编译速度提高了80%。效果很明显。

而后,让我们再做另一个实验,我们在项目中模拟日常修改某个class文件的一行代码,这时是符合增量编译的环境的。而后在刚才基础上还是做同样的插桩逻辑,比照增量Transform和全量Transform的差异。

./gradlew assembleDebug --profile

可以发现,增量的速度比全量的速度提升了3倍多,而且这个速度优化会随着工程的变大而更加明显。

数据表明,增量和并发对编译速度的影响是很大的。而我在查看Android gradle plugin自身的十几个Transform时,发现它们实现方式也有少量区别,有些用kotlin写,有些用java写,有些支持增量,有些不支持,而且是代码注释写了一个大大的FIXME, To support incremental build。所以,讲道理,现阶段的Android编译速度,还是有提升空间的。

上面我们详情了Transform,以及如何高效地在编译期间解决所有字节码,那么具体怎样解决字节码呢?接下来让我们一起看看JVM平台上的解决字节码神兵利器,ASM!

二、ASM

ASM的官网在这里asm.ow2.io/,贴一下它的主页详情,一起感受下它的强大

[图片上传失败…(image-c59976-1544358625290)]

JVM平台上,解决字节码的框架最常见的就三个,ASM,Javasist,AspectJ。我尝试过Javasist,而AspectJ也稍有理解,最终选择ASM,由于使用它可以更底层地解决字节码的每条命令,解决速度、内存占用,也优于其余两个框架。

我们可以来做一个比照,上面我们所做的计算编译时间试验的基础上,做如下实验,分别用ASM和Javasist全量解决工程所有class,并且都不开启并发解决的情况下,一次clean build中,transform的耗时比照如下

ASM相比Javasist的优势非常明显,ASM相比其余字节码操作库的效率和性能优势应该无须置疑的,毕竟是诸多JVM语言钦定的字节码生成库。

我们这部分将来详情ASM,但是因为篇幅问题,不会从字节码的基础开展详情,会通过几个实例的实现详情少量字节码的相关知识,另外还会详情ASM的使用,以及ASM解析class文件结构的原理,还有应用于Android插件开发时,遇到的问题,及其处理方案。

ASM的引入

下面是一份完整的gradle自己设置plugin + transform + asm所需依赖,注意一下,此处两个gradleApi的区别

dependencies {    //使用项目中指定的gradle wrapper版本,插件中使用的Project对象等等就来自这里    implementation gradleApi()         //使用本地的groovy    implementation localGroovy()       //Android编译的大部分gradle源码,比方上面讲到的TaskManager    implementation 'com.android.tools.build:gradle:3.1.4'        //这个依赖里其实主要存了transform的依赖,注意,这个依赖不同于上面的gradleApi()    implementation 'com.android.tools.build:gradle-api:3.1.4'       //ASM相关    implementation 'org.ow2.asm:asm:5.1'                            implementation 'org.ow2.asm:asm-util:5.1'                        implementation 'org.ow2.asm:asm-commons:5.1'   }

ASM的应用

ASM设计了两种API类型,一种是Tree API, 一种是基于Visitor API(visitor pattern),

Tree API将class的结构读取到内存,构建一个树形结构,而后需要解决Method、Field等元素时,到树形结构中定位到某个元素,进行操作,而后把操作再写入新的class文件。

Visitor API则将通过接口的方式,分离读class和写class的逻辑,一般通过一个ClassReader负责读取class字节码,而后ClassReader通过一个ClassVisitor接口,将字节码的每个细节按顺序通过接口的方式,传递给ClassVisitor(你会发现ClassVisitor中有多个visitXXXX接口),这个过程就像ClassReader带着ClassVisitor游览了class字节码的每一个指令。

上面这两种解析文件结构的方式在很多解决结构化数据时都常见,一般得看需求背景选择合适的方案,而我们的需求是这样的,出于某个目的,寻觅class文件中的一个hook点,进行字节码修改,这种背景下,我们选择Visitor API的方式比较合适。

让我们来写一个简单的demo,这段代码很简单,通过Visitor API读取一个class的内容,保存到另一个文件

private void copy(String inputPath, String outputPath) {    try {        FileInputStream is = new FileInputStream(inputPath);        ClassReader cr = new ClassReader(is);        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);        cr.accept(cw, 0);        FileOutputStream fos = new FileOutputStream(outputPath);        fos.write(cw.toByteArray());        fos.close();    } catch (IOException e) {        e.printStackTrace();    }}

首先,我们通过ClassReader读取某个class文件,而后定义一个ClassWriter,这个ClassWriter我们可以看它源码,其实就是一个ClassVisitor的实现,负责将ClassReader传递过来的数据写到一个字节流中,而真正触发这个逻辑就是通过ClassWriter的accept方式。

public void accept(ClassVisitor classVisitor, Attribute[] attributePrototypes, int parsingOptions) {    // 读取当前class的字节码信息    int accessFlags = this.readUnsignedShort(currentOffset);    String thisClass = this.readClass(currentOffset + 2, charBuffer);    String superClass = this.readClass(currentOffset + 4, charBuffer);    String[] interfaces = new String[this.readUnsignedShort(currentOffset + 6)];    //classVisitor就是刚才accept方法传进来的ClassWriter,每次visitXXX都负责将字节码的信息存储起来    classVisitor.visit(this.readInt(this.cpInfoOffsets[1] - 7), accessFlags, thisClass, signature, superClass, interfaces);    /**        略去很多visit逻辑    */    //visit Attribute    while(attributes != null) {        Attribute nextAttribute = attributes.nextAttribute;        attributes.nextAttribute = null;        classVisitor.visitAttribute(attributes);        attributes = nextAttribute;    }    /**        略去很多visit逻辑    */    classVisitor.visitEnd();}

最后,我们通过ClassWriter的toByteArray(),将从ClassReader传递到ClassWriter的字节码导出,写入新的文件就可。这就完成了class文件的复制,这个demo尽管很简单,但是涵盖了ASM使用Visitor API修改字节码最底层的原理,大致流程如图

我们来分析一下,不难发现,假如我们要修改字节码,就是要从ClassWriter入手,上面我们提到ClassWriter中每个visitXXX(这些接口实现自ClassVisitor)都会保存字节码信息并最终可以导出,那么假如我们可以代理商ClassWriter的接口,即可以干预最终字节码的生成了。

那么上面的图就应该是这样

我们只需略微看一下ClassVisitor的代码,发现它的构造函数,是可以接收另一个ClassVisitor的,从而通过这个ClassVisitor代理商所有的方法。让我们来看一个例子,为class中的每个方法调用语句的开头和结尾插入一行代码

修改前的方法是这样

private static void printTwo() {    printOne();    printOne();}

被修改后的方法是这样

private static void printTwo() {    System.out.println("CALL printOne");    printOne();    System.out.println("RETURN printOne");    System.out.println("CALL printOne");    printOne();    System.out.println("RETURN printOne");}

让我们来看一下如何用ASM实现

private static void weave(String inputPath, String outputPath) {    try {        FileInputStream is = new FileInputStream(inputPath);        ClassReader cr = new ClassReader(is);        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);        CallClassAdapter adapter = new CallClassAdapter(cw);        cr.accept(adapter, 0);        FileOutputStream fos = new FileOutputStream(outputPath);        fos.write(cw.toByteArray());        fos.close();    } catch (IOException e) {        e.printStackTrace();    }}

这段代码和上面的实现复制class的代码唯一区别就是,使用了CallClassAdapter,它是一个自己设置的ClassVisitor,我们将ClassWriter传递给CallClassAdapter的构造函数。来看看它的实现

//CallClassAdapter.javapublic class CallClassAdapter extends ClassVisitor implements Opcodes {    public CallClassAdapter(final ClassVisitor cv) {        super(ASM5, cv);    }    @Override    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {        super.visit(version, access, name, signature, superName, interfaces);    }    @Override    public MethodVisitor visitMethod(final int access, final String name,                                     final String desc, final String signature, final String[] exceptions) {        MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);        return mv == null ? null : new CallMethodAdapter(name, mv);    }}//CallMethodAdapter.javaclass CallMethodAdapter extends MethodVisitor implements Opcodes {    public CallMethodAdapter(final MethodVisitor mv) {        super(ASM5, mv);    }    @Override    public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {        mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");        mv.visitLdcInsn("CALL " + name);        mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);        mv.visitMethodInsn(opcode, owner, name, desc, itf);        mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");        mv.visitLdcInsn("RETURN " + name);        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);    }}

CallClassAdapter中的visitMethod使用了一个自己设置的MethodVisitor—–CallMethodAdapter,它也是代理商了原来的MethodVisitor,原理和ClassVisitor的代理商一样。

看到这里,貌似使用ASM修改字节码的大概套路都走完了,那么如何写出上面visitMethodInsn方法中插入打印方法名的逻辑,这就需要少量字节码的基础知识了,我们说过这里不会开展详情字节码,但是我们可以详情少量快速学习字节码的方式,同时也是开发字节码相关工程少量实用的工具。

在这之前,我们先讲讲行号的问题

如何验证行号

上面我们给每一句方法调用的前后都插入了一行日志打印,那么有没有想过,这样岂不是打乱了代码的行数,这样,万一crash了,定位堆栈岂不是乱套了。其实并不然,在上面visitMethodInsn中做的东西,其实都是在同一行中插入的代码,上面我们贴出来的代码是这样

private static void printTwo() {    System.out.println("CALL printOne");    printOne();    System.out.println("RETURN printOne");    System.out.println("CALL printOne");    printOne();    System.out.println("RETURN printOne");}

无论你用idea还是eclipse打开上面的class文件,都是一行行展现的,但是其实class内部真实的行数应该是这样

private static void printTwo() {    System.out.println("CALL printOne"); printOne(); System.out.println("RETURN printOne");    System.out.println("CALL printOne"); printOne(); System.out.println("RETURN printOne");}

idea下可以开启一个选项,让查看class内容时,保留真正的行数

开启后,你看到的是这样

我们可以发现,17行和18行,分别包含了三句代码。

而开启选项之前是这样

那么如何开启这个选项呢?Mac下cmd + shift + A输入Registry,勾选这两个选项

其实无论字节码和ASM的代码上看,class中的所有代码,都是先公告行号X,而后开始几条字节码指令,这几条字节码对应的代码都在行号X中,直到公告下一个新的行号。

ASM code

解析来详情,如何写出上面生成代码的逻辑。首先,我们设想一下,假如要对某个class进行修改,那需要对字节码具体做什么修改呢?最直观的方法就是,先编译生成目标class,而后看它的字节码和原来class的字节码有什么区别(查看字节码可以使用javap工具),但是这样还不够,其实我们最终并不是读写字节码,而是使用ASM来修改,我们这里先做一个区别,bytecode vs ASM code,前者就是JVM意义的字节码,然后者是用ASM形容的bytecode,其实二者非常的接近,只是ASM code用Java代码来形容。所以,我们应该是比照ASM code,而不是比照bytecode。比照ASM code的diff,基本就是我们要做的修改。

而ASM也提供了一个这样的类:ASMifier,它可以生成ASM code,但是,其实还有更快捷的工具,Intellij IDEA有一个插件
Asm Bytecode Outline,可以查看一个class文件的bytecode和ASM code。

到此为止,貌似使用比照ASM code的方式,来实现字节码修改也不难,但是,这种方式只是可以实现少量修改字节码的基础场景,还有很多场景是需要对字节码有少量基础知识才能做到,而且,要阅读懂ASM code,也是需要肯定字节码的的知识。所以,假如要开发字节码工程,还是需要学习一番字节码。

ClassWriter在Android上的坑

假如我们直接按上面的套路,将ASM应用到Android编译插件中,会踩到一个坑,这个坑来自于ClassWriter,具体是由于ClassWriter其中的一个逻辑,寻觅两个类的共同父类。可以看看ClassWriter中的这个方法getCommonSuperClass,

/** * Returns the common super type of the two given types. The default * implementation of this method <i>loads</i> the two given classes and uses * the java.lang.Class methods to find the common super class. It can be * overridden to compute this common super type in other ways, in particular * without actually loading any class, or to take into account the class * that is currently being generated by this ClassWriter, which can of * course not be loaded since it is under construction. *  * @param type1 *            the internal name of a class. * @param type2 *            the internal name of another class. * @return the internal name of the common super class of the two given *         classes. */protected String getCommonSuperClass(final String type1, final String type2) {    Class<?> c, d;    ClassLoader classLoader = getClass().getClassLoader();    try {        c = Class.forName(type1.replace('/', '.'), false, classLoader);        d = Class.forName(type2.replace('/', '.'), false, classLoader);    } catch (Exception e) {        throw new RuntimeException(e.toString());    }    if (c.isAssignableFrom(d)) {        return type1;    }    if (d.isAssignableFrom(c)) {        return type2;    }    if (c.isInterface() || d.isInterface()) {        return "java/lang/Object";    } else {        do {            c = c.getSuperclass();        } while (!c.isAssignableFrom(d));        return c.getName().replace('.', '/');    }}

这个方法用于寻觅两个类的共同父类,我们可以看到它是获取当前class的classLoader加载两个输入的类型,而编译期间使用的classloader并没有加载Android项目中的代码,所以我们需要一个自己设置的ClassLoader,将前面提到的Transform中接收到的所有jar以及class,还有android.jar都增加到自己设置ClassLoader中。(其实上面这个方法注释中已经暗示了这个方法存在的少量问题)

如下

public static URLClassLoader getClassLoader(Collection<TransformInput> inputs,                                            Collection<TransformInput> referencedInputs,                                            Project project) throws MalformedURLException {    ImmutableList.Builder<URL> urls = new ImmutableList.Builder<>();    String androidJarPath  = getAndroidJarPath(project);    File file = new File(androidJarPath);    URL androidJarURL = file.toURI().toURL();    urls.add(androidJarURL);    for (TransformInput totalInputs : Iterables.concat(inputs, referencedInputs)) {        for (DirectoryInput directoryInput : totalInputs.getDirectoryInputs()) {            if (directoryInput.getFile().isDirectory()) {                urls.add(directoryInput.getFile().toURI().toURL());            }        }        for (JarInput jarInput : totalInputs.getJarInputs()) {            if (jarInput.getFile().isFile()) {                urls.add(jarInput.getFile().toURI().toURL());            }        }    }    ImmutableList<URL> allUrls = urls.build();    URL[] classLoaderUrls = allUrls.toArray(new URL[allUrls.size()]);    return new URLClassLoader(classLoaderUrls);}

但是,假如只是替换了getCommonSuperClass中的Classloader,仍然还有一个更深的坑,我们可以看看前面getCommonSuperClass的实现,它是如何寻觅父类的呢?它是通过Class.forName加载某个类,而后再去寻觅父类,但是,但是,android.jar中的类可不能随随意便加载的呀,android.jar对于Android工程来说只是编译时依赖,运行时是用Android机器上自己的android.jar。而且android.jar所有方法包括构造函数都是空实现,其中都只有一行代码

throw new RuntimeException("Stub!");

这样加载某个类时,它的静态域就会被触发,而假如有一个static的变量恰好在公告时被初始化,而初始化中只有一个RuntimeException,此时就会抛异常。

所以,我们不能通过这种方式来获取父类,是否通过不需要加载class就能获取它的父类的方式呢?谜底就在眼前,父类其实也是一个class的字节码中的一项数据,那么我们就从字节码中查询父类就可。最终实现是这样。

public class ExtendClassWriter extends ClassWriter {    public static final String TAG = "ExtendClassWriter";    private static final String OBJECT = "java/lang/Object";    private ClassLoader urlClassLoader;    public ExtendClassWriter(ClassLoader urlClassLoader, int flags) {        super(flags);        this.urlClassLoader = urlClassLoader;    }    @Override    protected String getCommonSuperClass(final String type1, final String type2) {        if (type1 == null || type1.equals(OBJECT) || type2 == null || type2.equals(OBJECT)) {            return OBJECT;        }        if (type1.equals(type2)) {            return type1;        }        ClassReader type1ClassReader = getClassReader(type1);        ClassReader type2ClassReader = getClassReader(type2);        if (type1ClassReader == null || type2ClassReader == null) {            return OBJECT;        }        if (isInterface(type1ClassReader)) {            String interfaceName = type1;            if (isImplements(interfaceName, type2ClassReader)) {                return interfaceName;            }            if (isInterface(type2ClassReader)) {                interfaceName = type2;                if (isImplements(interfaceName, type1ClassReader)) {                    return interfaceName;                }            }            return OBJECT;        }        if (isInterface(type2ClassReader)) {            String interfaceName = type2;            if (isImplements(interfaceName, type1ClassReader)) {                return interfaceName;            }            return OBJECT;        }        final Set<String> superClassNames = new HashSet<String>();        superClassNames.add(type1);        superClassNames.add(type2);        String type1SuperClassName = type1ClassReader.getSuperName();        if (!superClassNames.add(type1SuperClassName)) {            return type1SuperClassName;        }        String type2SuperClassName = type2ClassReader.getSuperName();        if (!superClassNames.add(type2SuperClassName)) {            return type2SuperClassName;        }        while (type1SuperClassName != null || type2SuperClassName != null) {            if (type1SuperClassName != null) {                type1SuperClassName = getSuperClassName(type1SuperClassName);                if (type1SuperClassName != null) {                    if (!superClassNames.add(type1SuperClassName)) {                        return type1SuperClassName;                    }                }            }            if (type2SuperClassName != null) {                type2SuperClassName = getSuperClassName(type2SuperClassName);                if (type2SuperClassName != null) {                    if (!superClassNames.add(type2SuperClassName)) {                        return type2SuperClassName;                    }                }            }        }        return OBJECT;    }    private boolean isImplements(final String interfaceName, final ClassReader classReader) {        ClassReader classInfo = classReader;        while (classInfo != null) {            final String[] interfaceNames = classInfo.getInterfaces();            for (String name : interfaceNames) {                if (name != null && name.equals(interfaceName)) {                    return true;                }            }            for (String name : interfaceNames) {                if(name != null) {                    final ClassReader interfaceInfo = getClassReader(name);                    if (interfaceInfo != null) {                        if (isImplements(interfaceName, interfaceInfo)) {                            return true;                        }                    }                }            }            final String superClassName = classInfo.getSuperName();            if (superClassName == null || superClassName.equals(OBJECT)) {                break;            }            classInfo = getClassReader(superClassName);        }        return false;    }    private boolean isInterface(final ClassReader classReader) {        return (classReader.getAccess() & Opcodes.ACC_INTERFACE) != 0;    }    private String getSuperClassName(final String className) {        final ClassReader classReader = getClassReader(className);        if (classReader == null) {            return null;        }        return classReader.getSuperName();    }    private ClassReader getClassReader(final String className) {        InputStream inputStream = urlClassLoader.getResourceAsStream(className + ".class");        try {            if (inputStream != null) {                return new ClassReader(inputStream);            }        } catch (IOException ignored) {        } finally {            if (inputStream != null) {                try {                    inputStream.close();                } catch (IOException ignored) {                }            }        }        return null;    }}

到此为止,我们详情了在Android上实现修改字节码的两个基础技术Transform+ASM,详情了其原理和应用,分析了性能优化以及在Android平台上的适配等。在此基础上,我笼统出一个轮子,让开发者写字节码插件时,只要要写一些的ASM code就可,而不需关心Transform和ASM背后的很多细节。详见

github.com/Leaking/Hun…

万事俱备,只欠写一个插件来玩玩了,让我们来看看几个应用案例。

应用案例

先抛结论,修改字节码其实也有套路,一种是hack代码调用,一种是hack代码实现。

比方修改Android Framework(android.jar)的实现,你是没办法在编译期间达到这个目的的,由于最终Android Framework的class在Android设施上。所以这种情况下你需要从hack代码调用入手,比方Log.i(TAG, “hello”),你不可能hack其中的实现,但是你可以把它hack成HackLog.i(TAG, “seeyou”)。

而假如是要修改第三方依赖或者者工程中写的代码,则可以直接hack代码实现,但是,当假如你要插入的字节码比较多时,也可以通过肯定技巧减少写ASM code的量,你可以将大部分可以笼统的逻辑笼统到某个写好的class中,而后ASM code只要写调用这个写好的class的语句。

当然上面只是目前按照我的经验做的一点总结,还是有少量更复杂的情况要具体情况具体分析,比方在实现相似JakeWharton的hugo的功能时,在代码开头获取方法参数名时我就遇到辣手的问题(用了一种二次扫描的方式处理了这个问题,可以移步项目主页参考具体实现)。

我们这里筛选OkHttp-Plugin的实现进行分析、演示如何使用Huntet框架开发一个字节码编译插件。

使用OkHttp的人知道,OkHttp里每一个OkHttp都可以设置自己独立的Intercepter/Dns/EventListener(EventListener是okhttp3.11新添加),但是需要对全局所有OkHttp设置统一的Intercepter/Dns/EventListener就很麻烦,需要一处处设置,而且少量第三方依赖中的OkHttp很大可能无法设置。曾经在官方repo提过这个问题的issue,没有得到很好的回复,作者之一觉得假如是他,他会用依赖注入的方式来实现统一的Okhttp配置,但是这种方式只能说可行但是不理想,后端在reddit发 帖子安利自己Hunter这个轮子时,JakeWharton大佬竟然亲身答复了,尽管面对大佬,不过还是要正面刚!争论一波之后,总结一下他的立场,大概如下

他觉得我说的如同这是okhttp的锅,然而这其实是okhttp的一个feature,他觉得全局状态是一种不好的编码,所以在设计okhttp没有提供全局Intercepter/Dns/EventListener的接口。而第三方依赖库不可设置自己设置Intercepter/Dns/EventListener这是它们的锅。

但是,他的观点我不完全同意,尽管全局状态的确是一种不好的设计,但是,假如要做性能监控之类的功能,这就很难避免或者多或者少的全局侵入。(不过我的确措辞不当,说得这如同是Okhttp的锅一样)

言归正传,来看看我们要怎样来对OkHttp动刀,请看以下代码

public Builder(){    this.dispatcher = new Dispatcher();    this.protocols = OkHttpClient.DEFAULT_PROTOCOLS;    this.connectionSpecs = OkHttpClient.DEFAULT_CONNECTION_SPECS;    this.eventListenerFactory = EventListener.factory(EventListener.NONE);    this.proxySelector = ProxySelector.getDefault();    this.cookieJar = CookieJar.NO_COOKIES;    this.socketFactory = SocketFactory.getDefault();    this.hostnameVerifier = OkHostnameVerifier.INSTANCE;    this.certificatePinner = CertificatePinner.DEFAULT;    this.proxyAuthenticator = Authenticator.NONE;    this.authenticator = Authenticator.NONE;    this.connectionPool = new ConnectionPool();    this.dns = Dns.SYSTEM;    this.followSslRedirects = true;    this.followRedirects = true;    this.retryOnConnectionFailure = true;    this.connectTimeout = 10000;    this.readTimeout = 10000;    this.writeTimeout = 10000;    this.pingInterval = 0;    this.eventListenerFactory = OkHttpHooker.globalEventFactory;    this.dns = OkHttpHooker.globalDns;    this.interceptors.addAll(OkHttpHooker.globalInterceptors);    this.networkInterceptors.addAll(OkHttpHooker.globalNetworkInterceptors);}

这是OkhttpClient中内部类Builder的构造函数,我们的目标是在方法末尾加上四行代码,这样一来,所有的OkHttpClient都会拥有共同的Intercepter/Dns/EventListener。我们再来看看OkHttpHooker的实现

public class OkHttpHooker {    public static EventListener.Factory globalEventFactory = new EventListener.Factory() {        public EventListener create(Call call) {            return EventListener.NONE;        }    };;    public static Dns globalDns = Dns.SYSTEM;    public static List<Interceptor> globalInterceptors = new ArrayList<>();    public static List<Interceptor> globalNetworkInterceptors = new ArrayList<>();    public static void installEventListenerFactory(EventListener.Factory factory) {        globalEventFactory = factory;    }    public static void installDns(Dns dns) {        globalDns = dns;    }    public static void installInterceptor(Interceptor interceptor) {        if(interceptor != null)            globalInterceptors.add(interceptor);    }    public static void installNetworkInterceptors(Interceptor networkInterceptor) {        if(networkInterceptor != null)            globalNetworkInterceptors.add(networkInterceptor);    }}

这样,只要要为OkHttpHooker预先install好几个全局的Intercepter/Dns/EventListener就可。

那么,如何来实现上面OkhttpClient内部Builder中插入四行代码呢?

首先,我们通过Hunter的框架,可以隐藏掉Transform和ASM绝大部分细节,我们只要把注意力放在写ClassVisitor以及MethodVisitor就可。我们一共需要做以下几步

1、新建一个自己设置transform,增加到一个自己设置gradle plugin中
2、继承HunterTransform实现自己设置transform
3、实现自己设置的ClassVisitor,并依情况实现自己设置MethodVisitor

其中第一步文章讲解transform一部分有讲到,基本是一样简短的写法,我们从第二步讲起

继承HunterTransform,即可以让你的transform具有并发、增量的功能。

final class OkHttpHunterTransform extends HunterTransform {    private Project project;    private OkHttpHunterExtension okHttpHunterExtension;    public OkHttpHunterTransform(Project project) {        super(project);        this.project = project;        //依情况而定,看看你需不需要有插件扩展        project.getExtensions().create("okHttpHunterExt", OkHttpHunterExtension.class);        //必需的一步,继承BaseWeaver,帮你隐藏ASM细节        this.bytecodeWeaver = new OkHttpWeaver();    }    @Override    public void transform(Context context, Collection<TransformInput> inputs, Collection<TransformInput> referencedInputs, TransformOutputProvider outputProvider, boolean isIncremental) throws IOException, TransformException, InterruptedException {        okHttpHunterExtension = (OkHttpHunterExtension) project.getExtensions().getByName("okHttpHunterExt");        super.transform(context, inputs, referencedInputs, outputProvider, isIncremental);    }    // 用于控制修改字节码在哪些debug包还是release包下发挥作用,或者者完全打开/关闭    @Override    protected RunVariant getRunVariant() {        return okHttpHunterExtension.runVariant;    }}//BaseWeaver帮你隐藏了ASM的很多复杂逻辑public final class OkHttpWeaver extends BaseWeaver {    @Override    protected ClassVisitor wrapClassWriter(ClassWriter classWriter) {        return new OkHttpClassAdapter(classWriter);    }}//插件扩展public class OkHttpHunterExtension {    public RunVariant runVariant = RunVariant.ALWAYS;    @Override    public String toString() {        return "OkHttpHunterExtension{" +                "runVariant=" + runVariant +                '}';    }}

好了,Transform写起来就变得这么简单,接下来看自己设置ClassVisitor,它在OkHttpWeaver返回。

我们新建一个ClassVisitor(自己设置ClassVisitor是为了代理商ClassWriter,前面讲过)

public final class OkHttpClassAdapter extends ClassVisitor{    private String className;    OkHttpClassAdapter(final ClassVisitor cv) {        super(Opcodes.ASM5, cv);    }    @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;    }    @Override    public MethodVisitor visitMethod(final int access, final String name,                                     final String desc, final String signature, final String[] exceptions) {        MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);        if(className.equals("okhttp3/OkHttpClient$Builder")) {            return mv == null ? null : new OkHttpMethodAdapter(className + File.separator + name, access, desc, mv);        } else {            return mv;        }    }}

我们寻觅出okhttp3/OkHttpClient$Builder这个类,其余类不论它,那么其余类只会被普通的复制,而okhttp3/OkHttpClient$Builder将会有自己设置的MethodVisitor来解决

我们来看看这个MethodVisitor的实现

public final class OkHttpMethodAdapter extends LocalVariablesSorter implements Opcodes {    private boolean defaultOkhttpClientBuilderInitMethod = false;    OkHttpMethodAdapter(String name, int access, String desc, MethodVisitor mv) {        super(Opcodes.ASM5, access, desc, mv);        if ("okhttp3/OkHttpClient$Builder/<init>".equals(name) && "()V".equals(desc)) {            defaultOkhttpClientBuilderInitMethod = true;        }    }    @Override    public void visitInsn(int opcode) {        if(defaultOkhttpClientBuilderInitMethod) {            if ((opcode >= IRETURN && opcode <= RETURN) || opcode == ATHROW) {                //EventListenFactory                mv.visitVarInsn(ALOAD, 0);                mv.visitFieldInsn(GETSTATIC, "com/hunter/library/okhttp/OkHttpHooker", "globalEventFactory", "Lokhttp3/EventListener$Factory;");                mv.visitFieldInsn(PUTFIELD, "okhttp3/OkHttpClient$Builder", "eventListenerFactory", "Lokhttp3/EventListener$Factory;");                //Dns                mv.visitVarInsn(ALOAD, 0);                mv.visitFieldInsn(GETSTATIC, "com/hunter/library/okhttp/OkHttpHooker", "globalDns", "Lokhttp3/Dns;");                mv.visitFieldInsn(PUTFIELD, "okhttp3/OkHttpClient$Builder", "dns", "Lokhttp3/Dns;");                //Interceptor                mv.visitVarInsn(ALOAD, 0);                mv.visitFieldInsn(GETFIELD, "okhttp3/OkHttpClient$Builder", "interceptors", "Ljava/util/List;");                mv.visitFieldInsn(GETSTATIC, "com/hunter/library/okhttp/OkHttpHooker", "globalInterceptors", "Ljava/util/List;");                mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "addAll", "(Ljava/util/Collection;)Z", true);                mv.visitInsn(POP);                //NetworkInterceptor                mv.visitVarInsn(ALOAD, 0);                mv.visitFieldInsn(GETFIELD, "okhttp3/OkHttpClient$Builder", "networkInterceptors", "Ljava/util/List;");                mv.visitFieldInsn(GETSTATIC, "com/hunter/library/okhttp/OkHttpHooker", "globalNetworkInterceptors", "Ljava/util/List;");                mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "addAll", "(Ljava/util/Collection;)Z", true);                mv.visitInsn(POP);            }        }        super.visitInsn(opcode);    }}

首先,我们先找出okhttp3/OkHttpClient$Builder的构造函数,而后在这个构造函数的末尾,执行插入字节码的逻辑,我们可以发现,字节码的指令是符合逆波兰式的,都是操作数在前,操作符在后。

至此,我们只要要发布插件,而后apply到我们的项目中就可。

借助Hunter框架,我们很轻松就成功hack了Okhttp,我们即可以用全局统一的Intercepter/Dns/EventListener来监控我们APP的网络了。

讲到这里,就完整得详情了如何使用Hunter框架开发一个字节码编译插件,对第三方依赖库为所欲为。假如对于代码还有疑惑,可以移步项目主页,参考完整代码,以及其余几个插件的实现。

总结
这篇文章写到这里差不多了,全文主要围绕Hunter开展详情,分析了如何开发一个高效的修改字节码的编译插件,以及ASM字节码技术的少量相关工作流和开发套路。现在加Android开发群;701740775,可免费领取一份最新Android高级架构技术体系大纲和视频资料,以及这些年积累整理的所有面试资源笔记。加群请备注简书领取xx资料

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 一起来玩转Android项目中的字节码

发表回复