Javassist即时编译技术，热修复核心与原理

2023-05-16

Java 字节码以二进制的形式存储在 .class 文件中，每一个.class 文件包含一个Java类或接口。Javaassist 框架就是一个用来处理 Java 字节码的类库。它可以在一个已经编译好的类中添加新的方法，或者是修改已有的方法，并且不需要对字节码方面有深入的了解。

Javassist 可以绕过编译，直接操作字节码，从而可以实现代码的注入。所以使用 Javassist 框架的时机就是在构建工具 Gradle 将源文件编译成 .class 文件之后，在将 .class 打包成 .dex 文件之前。

1. 关于Javassist 的相关基础知识

在Javassist框架中，.class文件是用类 Javassist.CtClass 表示的。一个 CtClass 对象可以处理一个 .class 文件。下面列举一个简单的示例。

ClassPool pool = ClassPool.getDefault();  // 获取一个 ClassPool 对象

CtClass aClass = pool.get("zgy.javaassit.AutoTrackHelper")

aClass.setSuperclass("java.lang.Object")

aClass.writeFile()

在上面这个示例中，我们首先获取一个 ClassPool 对象。ClassPool 是 CtClass 对象的容器。

它可以按需读取类文件用来创建 CtClass 对象，并且保存 CtClass 对象以便以后可能会被使用到。

为了修改类的定义，首先需要使用 ClassPool.get() 方法从 ClassPool 中获得一个 CtClass 对象。

使用 getDefault() 方法获取的 ClassPool 对象使用的是默认系统的类搜索路径。

ClassPool 是一个存储 CtClass 的 Hash 表，类的名称作为 Hash 表的 key。ClassPool get()

方法会从 Hash 表查找 key 对应的 CtClass 对象。如果根据对应的 Key 没有找到 CtClass 对get()

方法就会创建并返回一个新的 CtClass 对象，这个对象同时也会保存在 Hash 表中。从 ClassPool

中获取的 CtClass 对象是可以被修改的。比如上面的这个例子：

byte[]b = aClass.toBytecode();

也可以使用 toClass() 函数直接将 CtClass 对象转换成 Class 对象，比如：

Classclazz = aClass.toClass();

toClass() 请求当前线程的 ClassLoader 加载 CtClass 对象所代表的类文件，它返回此类文件

的 java.lang.Class 对象。

冻结类

一个 CtClass 对象通过 writeFile()、toClass()、toBytecode() 等方法被转换成一个类文件，此

CtClass 对象就会被冻结起来，不允许再被修改，这是因为一个类只能被 JVM 加载一次。

其实，一个冻结的 CtClass 对象也可以被解冻，比如：

CtClassaClass = …;

// ……

aClass.writeFile();

aClass.defrost();

// 因为类已经被解冻，所以这里是可以被修改成功的

aClass.setSuperClass(…);

此处调用 defrost() 方法之后，这个 CtClass 对象就又可以被修改了。

类搜索路径

通过 ClassPool.getDefault() 获取的 ClassPool 是使用 JVM 的类搜索路径。如果程序运行在

JBoss 或者 Tomcat 等 Web 服务器上，

ClassPool 可能无法找到用户的类，因为 Web 服务器使用多个类加载器作为系统类加载器。

在这种情况下，ClassPool 必须添加额外的类搜索路径。比如：

ClassPoolpool = ClassPool.getDefault();

pool.insertClassPath(newClassClassPath(this.getClass()));

在上面的代码示例中，将 this 指向的类添加到 ClassPool 的类加载路径中。你可以使用任意 Class

对象来代替 this.getClass()，从而将 Class 对象添加到类加载路径中。

同时，也可以注册一个目录作为搜索路径。比如：

ClassPoolpool = ClassPool.getDefault();

pool.insertClassPath(“/usr/local/Library/”);

上面的例子是将 “/usr/local/Library/”目录添加到类搜索路径中。

ClassPool 是 CtClass 对象的容器。因为编译器在编译引用 CtClass 代表的 Java 类的源代码

时，可能会引用 CtClass 对象，所以一旦一个 CtClass 被创建，它就会被保存在 ClassPool 中。

避免内存溢出

如果 CtClass 对象的数量变得非常多，ClassPool 有可能会导致巨大的内存消耗。为了避免

这个问题，我们可以从 ClassPool 中显式删除不必要的 CtClass对象。如果对 CtClass 对象调

detach() 方法，那么该 CtClass 对象将会被从 ClassPool 中删除。比如：

CtClassaClass = …;

aClass.writeFile();

aClass.detach();

在调用 detach() 方法之后，就不能再调用这个 CtClass 对象的任何有关方法了。如果调用

ClassPool 的 get() 方法，ClassPool 会再次读取这个类文件，并创建一个新的 CtClass 对象。

在方法体中插入代码

CtMethod 和 CtConstructor 均提供了 insertBefore()、insertAfter() 及 addCatch() 等方法。

它们可以把用 Java 编写的代码片段插入到现有的方法体中。Javassist 包括一个用于处理源代码的

小型编译器，它接收用 Java 编写的源代码，然后将其编译成 Java 字节码，并内联到方法体中。

也可以按行号来插入代码段（如果行号表包含在类文件中）。向 CtMethod 和 CtConstructor 中的

insertAt() 方法提供源代码和原始类定义中的源文件的行号，就可以将编译后的代码插入到指定行

号位置。

insertBefore()、insertAfter()、addCatch() 和 insertAt() 等方法都能接收一个表示语句或语句块

的 String 对象。一个语句是一个单一的控制结构，比如 if 和 while 或者以分号结尾的表达式。语句

块是一组用大括号 {} 包围的语句。

语句和语句块可以引用字段和方法。但不允许访问在方法中声明的局部变量，尽管在块中声

明一个新的局部变量是允许的。传递给方法insertBefore() 、insertAfter() 、addCatch()和 insertAt()

的 String 对象是由Javassist 的编译器编译的。由于编译器支持语言扩展，所以以 $ 开头的几个标

识符都有特殊的含义：

$0, $1, $2, ...

传递给目标方法的参数使用 $1，$2，... 来访问，而不是原始的参数名称。 $1 表示第一个参

数，$2 表示第二个参数，以此类推。这些变量的类型与参数类型相同。$0 等价于 this 指针。如

果方法是静态的，则 $0 不可用。

$args

变量 $args 表示所有参数的数组。该变量的类型是 Object 类型的数组。如果参数类型是原始类

型（如 int、boolean 等），则该参数值将被转换为包装器对象（如java.lang.Integer）以存储在

$args 中。因此，如果第一个参数的类型不是原始类型，那么 $args[0] 等于 $1。注意$args[0] 不

等于 $0，因为 $0 表示 this。

变量 $$ 是所有参数列表的缩写，用逗号分隔。

CtMethod 中的 insertAfter() 是在方法的末尾插入编译的代码。传递给 insertAfter() 的语句中，

不但可以使用特殊符号如 $0，$1。也可以使用 $_ 来表示方法的结果值。

该变量的类型是方法的返回结果类型（返回类型）。如果返回结果类型为 void，那么 $_ 的类

型为Object，$_ 的值为 null。

虽然由 insertAfter() 插入的编译代码通常在方法返回之前执行，但是当方法抛出异常时，它也可

以执行。要在抛出异常时执行它，insertAfter() 的第二个参数 asFinally 必须为 true。

如果抛出异常，由 insertAfter() 插入的编译代码将作为 finally 子句执行。$_ 的值 0 或 null。在

编译代码的执行终止后，最初抛出的异常被重新抛出给调用者。注意，$_ 的值不会被抛给调者，

它将被丢弃。

addCatch

addCatch() 插入方法体抛出异常时执行的代码，控制权会返回给调用者。在插入的源代码中，

异常用 $e 表示。

CtMethod m = ...;

CtClass etype =ClassPool.getDefault().get("java.io.IOException");

m.addCatch("{ System.out.println($e);throw $e; }", etype);

转换成对应的 java 代码如下：

try {

// the original method body

} catch (java.io.IOException e) {

System.out.println(e);

}

请注意，插入的代码片段必须以 throw 或 return 语句结束。

注解（Annotations）

CtClass、CtMethod、CtField 和 CtConstructor 均提供了 getAnnotations() 方法，用于读取对

应类型上添加的注解。它返回一个注解类型的对象数组。

原理介绍

在自定义的 plugin 里，我们可以注册一个自定义的 Transform，从而可以分别对当前应用程序

的所有源码目录和 jar 包进行遍历。在遍历的过程中，利用Javassist 框架的 API 可以对满足特定

条件的方法进行修改，比如插入相关埋点代码。整个原理与使用 ASM 框架类似，此时只是把操作

.class 文件的框架由 ASM 换成 Javassist 了。

1、App构建是将代码编译为.class文件，然后打包成dex文件之后输出apk

2、Gradle构建App由一个个Task组成，每个Task作用实际上是接收一个输入(编译App所需的资

源)然后进行处理然后有一个输出，如下图：

3、Gradle1.5以后提供了transform-api可以在代码转化为.class文件之后再打包成dex文件之前对

它进行处理,见如下代码：

package com.dwiot.javaassit

import com.android.build.api.transform.Format;
import com.android.build.api.transform.QualifiedContent;
import com.android.build.api.transform.Transform;
import com.android.build.api.transform.TransformException;
import com.android.build.api.transform.TransformInvocation
import javassist.ClassPool
import javassist.CtClass
import javassist.CtMethod;
import org.apache.commons.io.FileUtils
import com.android.build.gradle.internal.pipeline.TransformManager;
import org.gradle.api.Project;

public class ModifyTransform extends Transform {
    def project
    def pool = ClassPool.default

    ModifyTransform(Project project) {
        this.project = project;
    }

    @Override
    public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        super.transform(transformInvocation);

        project.android.bootClasspath.each {
            pool.appendClassPath(it.absolutePath)
        }
//   第1步 : 拿到输入
        transformInvocation.inputs.each {

            it.directoryInputs.each {
                def preFileName = it.file.absolutePath
                pool.insertClassPath(preFileName)

                println "========directoryInputs======== " + preFileName
                findTarget(it.file, preFileName)
                //  2 查询输出的文件夹    目的地
                def dest = transformInvocation.outputProvider.getContentLocation(
                        it.name,
                        it.contentTypes,
                        it.scopes,
                        Format.DIRECTORY
                )

                //  3  文件copy  ---> 下一个环节
                FileUtils.copyDirectory(it.file, dest)
            }
            it.jarInputs.each {
                def dest = transformInvocation.outputProvider.getContentLocation(it.name, it.contentTypes, it.scopes, Format.JAR)
                FileUtils.copyFile(it.file, dest)
            }
//            修改class   不是修改 jar
        }
//       第2步 : 查询输出的文件夹    目的地
//       第3步 :  文件copy  ---> 下一个环节
    }

//    fileName C:\Users\maniu\Downloads\ManiuJavaSsit\app\build\intermediates\javac\debug\classes
    private void findTarget(File dir, String fileName) {
        if (dir.isDirectory()) {
            dir.listFiles().each {
                findTarget(it, fileName)
            }
        } else {
            def filePath = dir.absolutePath
            if (filePath.endsWith(".class")) {
                //   修改文件
                modify(filePath, fileName)
            }
        }
    }

    private void modify(def filePath, String fileName) {
        if (filePath.contains('R$') || filePath.contains('R.class') || filePath.contains("BuildConfig.class")) {
            return
        }

// 基于javassit  ----》
        def className = filePath.replace(fileName, "").replace("\\", ".").replace("/", ".")

        def name = className.replace(".class", "").substring(1)
        println "========name======== " + name
//        json 文件   ----》 javabean-- 修改---》 fastjson ----》回写到  json文件
        CtClass ctClass = pool.get(name)
        addCode(ctClass, fileName)
    }

    private void addCode(CtClass ctClass, String fileName) {
//        捡出来
        ctClass.defrost()
        CtMethod[] methods = ctClass.getDeclaredMethods()
        for (method in methods) {

            println "method " + method.getName() + "参数个数  " + method.getParameterTypes().length
            method.insertAfter("if(true){}")
            if (method.getParameterTypes().length == 1) {
                method.insertBefore("{ System.out.println(\$1);}")
            }
            if (method.getParameterTypes().length == 2) {
                method.insertBefore("{ System.out.println(\$1); System.out.println(\$2);}")
            }
            if (method.getParameterTypes().length == 3) {
                method.insertBefore("{ System.out.println(\$1);System.out.println(\$2);System.out.println(\\\$3);}")
            }
        }
        ctClass.writeFile(fileName)
        ctClass.detach()
    }


    @Override
    public String getName() {
        return "zgy";
    }

    @Override
    public Set<QualifiedContent.ContentType> getInputTypes() {
        return TransformManager.CONTENT_CLASS;
    }

    @Override
    public Set<? super QualifiedContent.Scope> getScopes() {
        return TransformManager.SCOPE_FULL_PROJECT;
    }

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

// 代码说明：

getName：用于指明本Transform的名字，这个 name 并不是最终的名字，在TransformManager

中会对名字再处理；

getInputTypes：用于指明Transform的输入类型，可以作为输入过滤的手段

–CLASSES表示要处理编译后的字节码，可能是 jar 包也可能是目录

–RESOURCES表示处理标准的 java 资源

getScopes：用于指明Transform的作用域

–PROJECT 只处理当前项目

–SUB_PROJECTS 只处理子项目

–PROJECT_LOCAL_DEPS 只处理当前项目的本地依赖,例如jar, aar

–EXTERNAL_LIBRARIES 只处理外部的依赖库

–PROVIDED_ONLY 只处理本地或远程以provided形式引入的依赖库

–TESTED_CODE 只处理测试代码

isIncremental：用于指明是否是增量构建。

transform：核心方法，用于自定义处理,在这个方法中我们可以拿到要处理的.class文件路径、jar

包路径、输出文件路径等，拿到文件之后就可以对他们进行操作利用Transform-api处理.class文件

有个标准流程，拿到输入路径 ---> 取出要处理的文件 ---> 处理文件 ----> 移动文件到输出路径

引用插件

a、修改工程根目录下的build.gradle

b、在module的目录下的build.gradle中添加

apply plugin:'com.app.plugin.myplugin' //这里就填写.properties 文件的名称

// Demo https://download.csdn.net/download/u011694328/34001891

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)