破解 JVM 上的第三方 API

JVM 生态系统已经成熟，提供了很多库，因此您无需重新发明轮子。基本功能（以及不那么基本的功能）只需依赖即可实现。然而，有时依赖项和您的用例略有不一致。

解决此问题的正确方法是创建一个 Pull 请求。但您的截止日期是明天：您需要立即使其工作！现在是时候破解提供的 API 了。

在本文中，我们将介绍一些替代方法，这些方法允许您让第三方 API 按照其设计者不期望的方式运行。

反射

想象一下，API 的设计遵循开放封闭原则：

在面向对象编程中，开放封闭原则指出“软件实体（类、模块、函数等）应该对扩展开放，但对修改关闭”；也就是说，这样的实体可以允许扩展其行为而无需修改其源代码。

--开放封闭原则

假设依赖项的公共 API 不适合你的用例。你需要扩展它，但这是不可能的，因为设计不允许这样做 - 故意的。

为了解决这个问题，书中关于 JVM 的最古老的技巧可能是反射。

反射是 Java 编程语言中的一项功能。它允许正在执行的 Java 程序检查或“自省”自身，并操纵程序的内部属性。例如，Java 类可以获取其所有成员的名称并显示它们。

--使用 Java 反射

在我们的范围内，反射允许您访问不应访问的状态，或调用不应调用的方法。

public class Private {private String attribute = "My private attribute";private String getAttribute() {return attribute;}
}public class ReflectionTest {private Private priv;@BeforeEachprotected void setUp() {priv = new Private();}@Testpublic void should_access_private_members() throws Exception {var clazz = priv.getClass();var field = clazz.getDeclaredField("attribute");                             // 1var method = clazz.getDeclaredMethod("getAttribute");                        // 2AccessibleObject.setAccessible(new AccessibleObject[]{field, method}, true); // 3field.set(priv, "A private attribute whose value has been updated");         // 4var value = method.invoke(priv);                                             // 5assertThat(value).isEqualTo("A private attribute whose value has been updated");}
}

获取对类private的字段的引用Private
获取类private方法的引用Private
允许使用private成员
private设置字段的值
调用private方法

然而，反射也有一些局限性：

“魔法”发生在上AccessibleObject.setAccessible。可以通过适当配置的安全管理器在运行时禁止这种情况。我承认，在我的职业生涯中，我从未见过有人使用安全管理器。
模块系统限制了反射 API 的使用。例如，调用者和目标类必须位于同一个模块中，目标成员必须是public，等等。请注意，许多库不使用模块系统。
如果您直接使用具有私有成员的类，反射是很好的。但如果您需要更改依赖类的行为，反射就毫无用处：如果您的类使用了第三方类，A而该第三方类本身又需要一个类B，您需要更改B。

类路径阴影

一篇很长的文章可以专门介绍 Java 的类加载机制。在这篇文章中，我们将重点介绍类路径。类路径是JVM 将查找以加载先前卸载的类的文件夹和 JAR 的有序列表。

让我们从以下架构开始：

启动该应用程序的最简单命令如下：

java -cp=.:thirdparty.jar Main

无论出于什么原因，假设我们需要改变类的行为B。它的设计不允许这样做。

无论这种设计如何，我们仍然可以通过以下方式对其进行破解：

获取类的源代码B
根据我们的要求进行更改
编译
将编译后的类放在类路径上包含原始类的 JAR之前

当启动与上述相同的命令时，类加载将按以下顺序进行：从文件系统加载，然后Main从JAR 加载；将跳过 JAR 中的类加载。BAB

这种方法也有一些局限性：

您需要源代码B- 或者至少需要一种从编译的代码中获取它的方法。
您需要能够B从源代码进行编译。这意味着您需要重新创建所有必要的依赖项B。

这些都是技术要求。至于是否合法则完全是另一个问题，超出了本文的讨论范围。

面向方面编程

与 C++ 相反，Java 语言提供单一继承：一个类可以从单个超类继承。

但在某些情况下，多重继承是必须的。例如，我们希望在类层次结构中为不同的日志级别提供日志记录方法。有些语言遵循单一继承原则，但为日志记录等横切关注点提供了替代方案：Scala 提供特征，而 Java 和 Kotlin 的接口可以具有属性。

“在过去”，AOP非常流行，用于向不属于同一层次结构的类添加横切功能。

在计算领域，面向方面编程 (AOP) 是一种编程范式，旨在通过分离横切关注点来提高模块化程度。它通过在不修改代码本身的情况下向现有代码添加额外行为（建议）来实现这一点，而是通过“切入点”规范单独指定要修改的代码，例如“当函数名称以‘set’开头时记录所有函数调用”。这允许将不属于业务逻辑核心的行为（例如日志记录）添加到程序中，而不会使代码核心与功能混杂在一起。AOP 构成了面向方面软件开发的基础。

--面向方面编程

在 Java 中，AspectJ是首选的 AOP 库。它依赖于以下GitHub：

连接点定义程序执行过程中某个明确定义的点，例如方法的执行
切入点在程序流中挑选出特定的连接点，例如，执行任何用@Loggable
建议将切入点（挑选连接点）和代码主体（在每个连接点上运行）结合在一起

这里有两个类：一个代表公共 API，并将其实现委托给另一个。

public class Public {private final Private priv;public Public() {this.priv = new Private();}public String entryPoint() {return priv.implementation();}
}final class Private {final String implementation() {return "Private internal implementation";}
}

想象一下，我们需要改变私有实现。

public aspect Hack {pointcut privateImplementation(): execution(String Private.implementation()); // 1String around(): privateImplementation() {                                    // 2return "Hacked private implementation!";}
}

截取执行的切入点Private.implementation()
包装上述执行并将原始方法体替换为自己的方法体的建议

AspectJ 提供了不同的实现：

编译时：字节码在构建期间更新
后编译时间：字节码在构建后立即更新。它不仅允许更新项目类，还允许更新依赖的 JAR。
加载时：字节码在运行时加载类时更新

您可以像这样在 Maven 中设置第一个选项：

<build><plugins><plugin><artifactId>maven-surefire-plugin</artifactId><version>2.22.2</version></plugin><plugin><groupId>com.nickwongdev</groupId><artifactId>aspectj-maven-plugin</artifactId><version>1.12.6</version><configuration><complianceLevel>${java.version}</complianceLevel><source>${java.version}</source><target>${java.version}</target><encoding>${project.encoding}</encoding></configuration><executions><execution><goals><goal>compile</goal></goals></execution></executions></plugin></plugins>
</build>
<dependencies><dependency><groupId>org.aspectj</groupId><artifactId>aspectjrt</artifactId><version>1.9.5</version></dependency>
</dependencies>

AOP 总体上和 AspectJ 尤其代表了核心选项。它们实际上没有任何限制，尽管我必须承认我没有检查它如何与 Java 模块一起工作。

但是，Codehaus 的官方 AspectJ Maven 插件仅支持 JDK 8 及以下版本，因为自 2018 年以来没有人更新过。有人在GitHub上 fork 了支持更高版本的代码。该 fork 可以支持 JDK 13 及以下版本，以及 AspectJ 库 1.9.5 及以下版本。

Java 代理

当您想要破解时，AOP 提供了高级抽象。但是如果您想以细粒度的方式更改代码，那么除了更改字节码本身之外别无他法。有趣的是，JVM 为我们提供了一种在加载类时更改字节码的标准机制。

您可能已经在您的职业生涯中遇到过该功能：它们被称为 Java 代理。Java 代理可以在启动 JVM 时在命令行上静态设置，也可以在之后动态附加到已经运行的 JVM。有关 Java 代理的更多信息，请查看此帖子（“Java 代理快速入门”部分）。

这是一个简单 Java 代理的代码：

public class Agent {public static void premain(                      // 1String args,                             // 2Instrumentation instrumentation){        // 3var transformer = new HackTransformer();instrumentation.addTransformer(transformer); // 4}
}

premain是静态设置的 Java 代理的入口点，就像main常规应用程序一样
我们也会有争论，就像main
Instrumentation是“魔法”类
设置一个可以在 JVM 加载字节码之前更改字节码的转换器

Java 代理在字节码级别工作。代理为您提供根据 JVM 规范（更准确地说，根据类文件格式）存储类定义的字节数组。必须更改字节数组中的字节并不是一件有趣的事情。好消息是其他人之前也有过这种需求。因此，生态系统提供了可提供更高级别抽象的现成库。

在以下代码片段中，转换器使用Javassist：

public class HackTransformer implements ClassFileTransformer {@Overridepublic byte[] transform(ClassLoader loader,String name,Class<?> clazz,ProtectionDomain domain,byte[] bytes) {                                            // 1if ("ch/frankel/blog/agent/Private".equals(name)) {var pool = ClassPool.getDefault();                                 // 2try {var cc = pool.get("ch.frankel.blog.agent.Private");              // 3var method = cc.getDeclaredMethod("implementation");             // 4method.setBody("{ return \"Agent-hacked implementation!\"; }");  // 5bytes = cc.toBytecode();                                         // 6} catch (NotFoundException | CannotCompileException | IOException e) {e.printStackTrace();}}return bytes;                                                        // 7}
}