什么是Java/SpringBoot中的猴子补丁?

banq

在软件开发中，我们经常需要调整和增强系统现有的功能。有时，修改现有代码库可能是不可能的，或者可能不是最实用的解决方案。因此，解决这个问题的方法就是猴子补丁。这种技术允许我们修改类或模块运行时而不改变其原始源代码。

在本文中，我们将探讨如何在 Java 中使用猴子修补、何时使用它以及它的缺点。

什么是猴子补丁 术语“猴子补丁（ Monkey Patching）”源自较早的术语“游击补丁”，指的是在运行时不加任何规则地偷偷地更改代码。由于 Java、Python 或 Ruby 等动态编程语言的灵活性，它得到了普及。

猴子补丁使我们能够在运行时修改或扩展类或模块。这使我们能够调整或增强现有代码，而无需直接更改源代码。当必须进行调整但由于各种限制而直接修改不可行或不受欢迎时，它特别有用。

在Java中，猴子补丁可以通过多种技术来实现。这些方法包括代理、字节码检测、面向方面的编程、反射或装饰器模式。每种方法都有其独特的方法，适合特定的场景。

接下来，我们将创建一个简单的货币转换器，其中包含从欧元到美元的硬编码汇率，以使用不同的方法应用猴子修补。

public interface MoneyConverter {
    double convertEURtoUSD(double amount);
}
public class MoneyConverterImpl implements MoneyConverter {
    private final double conversionRate;
    public MoneyConverterImpl() {
        this.conversionRate = 1.10;
    }
    @Override
    public double convertEURtoUSD(double amount) {
        return amount * conversionRate;
    }
}

动态代理 在 Java 中，使用代理是实现猴子修补的强大技术。代理是一个包装器，它通过自己的设施传递方法调用。这为我们提供了修改或增强原始类行为的机会。

值得注意的是，动态代理是 Java 中的基本代理机制。此外，它们还被 Spring Framework 等框架广泛使用。

@Transactional注释就是一个很好的例子。当应用于方法时，关联的类在运行时经历动态代理包装。调用该方法后，Spring 将调用重定向到代理。之后，代理启动一项新事务或加入现有事务。随后，调用实际方法。请注意，为了能够从这种事务行为中受益，我们需要依赖 Spring 的依赖注入机制，因为它基于动态代理。

让我们使用动态代理来包装我们的转换方法和货币转换器的一些日志。首先，我们必须创建java.lang.reflect.InitationHandler的子类型：

public class LoggingInvocationHandler implements InvocationHandler {
    private final Object target;
    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}
接下来，让我们创建一个测试来验证日志是否包含转换方法：

@Test
public void whenMethodCalled_thenSurroundedByLogs() {
    ByteArrayOutputStream logOutputStream = new ByteArrayOutputStream();
    System.setOut(new PrintStream(logOutputStream));
    MoneyConverter moneyConverter = new MoneyConverterImpl();
    MoneyConverter proxy = (MoneyConverter) Proxy.newProxyInstance(
      MoneyConverter.class.getClassLoader(),
      new Class[]{MoneyConverter.class},
      new LoggingInvocationHandler(moneyConverter)
    );
    double result = proxy.convertEURtoUSD(10);
    Assertions.assertEquals(11, result);
    String logOutput = logOutputStream.toString();
    assertTrue(logOutput.contains("Before method: convertEURtoUSD"));
    assertTrue(logOutput.contains("After method: convertEURtoUSD"));
}

面向方面的编程 面向方面的编程 (AOP) 是一种解决软件开发中的横切关注点的范例，它提供了一种模块化且内聚的方法来分离关注点，否则这些关注点将分散在整个代码库中。这是通过向现有代码添加附加行为而不修改代码本身来实现的。

在 Java 中，我们可以通过AspectJ或Spring AOP等框架来利用 AOP 。 Spring AOP 提供了一种轻量级且与 Spring 集成的方法，而 AspectJ 则提供了更强大且独立的解决方案。

在猴子修补中，AOP 提供了一个优雅的解决方案，允许我们以集中的方式将更改应用于多个类或方法。使用方面，我们可以解决需要在各个组件之间一致应用的日志记录或安全策略等问题，而无需更改核心逻辑。

让我们尝试用相同的日志包围相同的方法。为此，我们将使用 AspectJ框架，并且需要将spring-boot-starter-aop 依赖项添加到我们的项目中：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>3.2.2</version>
</dependency>
我们可以在 Maven Central 上找到该库的最新版本。

在 Spring AOP 中，方面通常应用于 Spring 管理的 bean。因此，为了简单起见，我们将货币转换器定义为 bean：

@Bean
public MoneyConverter moneyConverter() {
    return new MoneyConverterImpl();
}
现在，我们需要定义方面，用日志包围我们的转换方法：

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.baeldung.monkey.patching.converter.MoneyConverter.convertEURtoUSD(..))")
    public void beforeConvertEURtoUSD(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }
    @After("execution(* com.baeldung.monkey.patching.converter.MoneyConverter.convertEURtoUSD(..))")
    public void afterConvertEURtoUSD(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}
接下来，我们可以创建一个测试来验证我们的方面是否正确应用：

@Test
public void whenMethodCalled_thenSurroundedByLogs() {
    ByteArrayOutputStream logOutputStream = new ByteArrayOutputStream();
    System.setOut(new PrintStream(logOutputStream));
    double result = moneyConverter.convertEURtoUSD(10);
    Assertions.assertEquals(11, result);
    String logOutput = logOutputStream.toString();
    assertTrue(logOutput.contains("Before method: convertEURtoUSD"));
    assertTrue(logOutput.contains("After method: convertEURtoUSD"));
}

装饰器模式 装饰器是一种设计模式，允许我们通过将对象放置在包装对象内来将行为附加到对象上。因此，我们可以假设装饰器为原始对象提供了增强的接口。

在猴子修补的上下文中，它提供了一种灵活的解决方案，可以增强或修改类的行为，而无需直接修改其代码。我们可以创建实现与原始类相同的接口的装饰器类，并通过包装基类的实例来引入附加功能。

当处理一组共享公共接口的相关类时，此模式特别有用。通过使用装饰模式，可以有选择地应用修改，从而允许以模块化和非侵入的方式来适应或扩展单个对象的功能。

装饰器模式与其他猴子修补技术形成对比，提供了一种更加结构化和明确的方法来增强对象行为。它的多功能性使其非常适合需要明确的关注点分离和模块化的代码修改方法的场景。

为了实现此模式，我们将创建一个新类来实现MoneyConverter接口。它将有一个MoneyConverter类型的属性，它将处理请求。而且，我们装饰器的目的只是添加一些日志并转发货币转换请求。

public class MoneyConverterDecorator implements MoneyConverter {
    private final MoneyConverter moneyConverter;
    public MoneyConverterDecorator(MoneyConverter moneyConverter) {
        this.moneyConverter = moneyConverter;
    }
    @Override
    public double convertEURtoUSD(double amount) {
        System.out.println("Before method: convertEURtoUSD");
        double result = moneyConverter.convertEURtoUSD(amount);
        System.out.println("After method: convertEURtoUSD");
        return result;
    }
}
现在，让我们创建一个测试来检查日志是否已添加：

@Test
public void whenMethodCalled_thenSurroundedByLogs() {
    ByteArrayOutputStream logOutputStream = new ByteArrayOutputStream();
    System.setOut(new PrintStream(logOutputStream));
    MoneyConverter moneyConverter = new MoneyConverterDecorator(new MoneyConverterImpl());
    double result = moneyConverter.convertEURtoUSD(10);
    Assertions.assertEquals(11, result);
    String logOutput = logOutputStream.toString();
    assertTrue(logOutput.contains("Before method: convertEURtoUSD"));
    assertTrue(logOutput.contains("After method: convertEURtoUSD"));
}

反射 反射是程序在运行时检查和修改其行为的能力。在Java中，我们可以借助java.lang.reflect 包 或 Reflections库来使用它。虽然它提供了显着的灵活性，但由于它对代码可维护性和性能的潜在影响，应谨慎使用。

猴子修补反射的一种常见应用涉及访问类元数据、检查字段和方法，甚至在运行时调用方法。因此，此功能为在不直接更改源代码的情况下进行运行时修改打开了大门。

假设转化率已更新为新值。我们无法更改它，因为我们没有为转换器类创建设置器，并且它是硬编码的。因此，我们可以使用反射来打破封装，将转化率更新为新值：

@Test
public void givenPrivateField_whenUsingReflection_thenBehaviorCanBeChanged() throws IllegalAccessException, NoSuchFieldException {
    MoneyConverter moneyConvertor = new MoneyConverterImpl();
    Field conversionRate = MoneyConverterImpl.class.getDeclaredField("conversionRate");
    conversionRate.setAccessible(true);
    conversionRate.set(moneyConvertor, 1.2);
    double result = moneyConvertor.convertEURtoUSD(10);
    assertEquals(12, result);
}

字节码检测 通过字节码检测，我们可以动态修改已编译类的字节码。一种流行的字节码检测框架是Java Instrumentation API。引入此 API 的目的是收集数据以供各种工具使用。由于这些修改完全是附加的，因此此类工具不会改变应用程序的状态或行为。例如，此类工具包括监控代理、分析器、覆盖分析器和事件记录器。

然而，这种方法引入了更高级的复杂性，并且由于它对我们应用程序的运行时行为的潜在影响，因此谨慎处理它至关重要。

Monkey 补丁的用例 猴子修补在各种场景中都很有用，其中对代码进行运行时修改成为一种实用的解决方案。一种常见的用例是修复第三方库或框架中的紧急错误，而无需等待官方更新。它使我们能够通过临时修补代码来快速解决一些问题。

另一种情况是在直接代码更改具有挑战性或不切实际的情况下扩展或修改现有类或方法的行为。此外，在测试环境中，猴子修补对于引入模拟行为或临时改变功能以模拟不同的场景很有帮助。

此外，当需要快速原型设计或实验时，可以使用猴子补丁。这使我们能够快速迭代并探索各种实现，而无需进行永久性更改。

Monkey 补丁的风险 尽管猴子补丁很实用，但它也会带来一些应仔细考虑的风险。潜在的副作用和冲突是一种重大风险，因为在运行时进行的修改可能会发生不可预测的相互作用。此外，缺乏可预测性可能会导致具有挑战性的调试场景并增加维护开销。

此外，猴子修补可能会损害代码的可读性和可维护性。动态注入更改可能会掩盖代码的实际行为，使我们难以理解和维护，尤其是在大型项目中。

猴子补丁也可能会引起安全问题，因为它可能会引入漏洞或恶意行为。此外，对猴子补丁的依赖可能会阻碍标准编码实践和问题的系统解决方案的采用，从而导致代码库的健壮性和凝聚力较差。

结论 在本文中，我们了解到猴子补丁在某些情况下可能会很有用且功能强大。它还可以通过各种技术来实现，每种技术都有其优点和缺点。但是，应谨慎使用此方法，因为它可能会导致性能、可读性、可维护性和安全性问题。