静态分析工具捕获绕过Spring缓存@Cacheable方法的自调用答案

【问题标题】：Static Analysis tool to catch self-invocation bypassing Spring cache @Cacheable method静态分析工具捕获绕过Spring缓存@Cacheable方法的自调用
【发布时间】：2021-06-24 14:07:19
【问题描述】：

我知道这是因为在 Spring 中创建代理以处理缓存、事务相关功能的方式。修复它的方法是使用 AspectJ，但我不想走那条路，因为它有自己的问题。 我可以使用任何静态分析工具检测自我调用吗？

@Cacheable(value = "defaultCache", key = "#id")
public Person findPerson(int id) {
   return getSession().getPerson(id);
} 

public List<Person> findPersons(int[] ids) {
   List<Person> list = new ArrayList<Person>();
       for (int id : ids) {
      list.add(findPerson(id));
    }
   return list;
}

【问题讨论】：

标签： spring-aop static-analysis findbugs pmd spring-cache

【解决方案1】：

我可以使用任何静态分析工具检测自调用吗？

理论上可以，但请注意Rice's theorem。任何此类工具有时都会发出错误警报。

您可以使用abstract interpretation 技术开发这样的工具。您可能需要一年以上的工作。

您可以将此类工具的开发分包给例如Frama-C 团队。然后给我发邮件到basile.starynkevitch@cea.fr

【讨论】：

编写 PMD 自定义规则来检测带注释的方法有多难。还有一个 XPath 来识别对带注释的方法的调用？

【解决方案2】：

如果检测到内部调用就足够了，您可以使用本机 AspectJ 而不是 Spring AOP，然后在每次发生这种情况时抛出运行时异常或记录警告。那不是静态分析，但总比没有好。另一方面，如果您使用本机 AspectJ，那么无论如何您都不会局限于 Spring 代理，而且这些方面也可以用于自调用。

无论如何，这就是一个方面的样子，包括一个 MCVE 显示它是如何工作的。我是在 Spring 之外完成的，这就是为什么我使用代理 @Component 注释来进行演示。

更新：很抱歉针对@Component 类而不是@Cacheable 类/方法，但基本上我在这里展示的一般方法也适用于您的具体情况，如果你只是稍微调整一下切入点。

组件注释：

package de.scrum_master.app;

import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

@Retention(RUNTIME)
@Target(TYPE)
public @interface Component {}

示例类（组件和非组件）：

该组件将被其他组件调用，不应导致异常/警告：

package de.scrum_master.app;

@Component
public class AnotherComponent {
  public void doSomething() {
    System.out.println("Doing something in another component");
  }
}

这个类不是@Component，所以切面应该忽略它里面的自调用：

package de.scrum_master.app;

public class NotAComponent {
  public void doSomething() {
    System.out.println("Doing something in non-component");
    new AnotherComponent().doSomething();
    internallyCalled("foo");
  }

  public int internallyCalled(String text ) {
    return 11;
  }
}

这个类是@Component。方面应该标记internallyCalled("foo")，而不是new AnotherComponent().doSomething()。

package de.scrum_master.app;

@Component
public class AComponent {
  public void doSomething() {
    System.out.println("Doing something in component");
    new AnotherComponent().doSomething();
    internallyCalled("foo");
  }

  public int internallyCalled(String text ) {
    return 11;
  }
}

驱动程序应用：

请注意，我在整个示例代码中使用new 创建组件实例，而不是像在 Spring 中那样从应用程序上下文中请求 bean。但是你可以忽略它，这只是一个例子。

package de.scrum_master.app;

public class Application {
  public static void main(String[] args) {
    new NotAComponent().doSomething();
    new AComponent().doSomething();
  }
}

无方面运行时的控制台日志：

Doing something in non-component
Doing something in another component
Doing something in component
Doing something in another component

现在有了方面，我们期待的不是最后一条消息，而是异常或记录的警告。以下是如何做到这一点：

方面：

抱歉，这里使用了原生 AspectJ 语法。当然，你也可以使用基于注解的语法。

package de.scrum_master.aspect;

import de.scrum_master.app.*;

public aspect SelfInvocationInterceptor {
  Object around(Object caller, Object callee) :
    @within(Component) &&
    call(* (@Component *).*(..)) &&
    this(caller) &&
    target(callee)
  {
    if (caller == callee)
      throw new RuntimeException(
        "Self-invocation in component detected from "  + thisEnclosingJoinPointStaticPart.getSignature() +
        " to "+ thisJoinPointStaticPart.getSignature()
      );
    return proceed(caller, callee);
  }
}

使用方面运行时的控制台日志：

Doing something in non-component
Doing something in another component
Doing something in component
Doing something in another component
Exception in thread "main" java.lang.RuntimeException: Self-invocation in component detected from void de.scrum_master.app.AComponent.doSomething() to int de.scrum_master.app.AComponent.internallyCalled(String)
    at de.scrum_master.app.AComponent.internallyCalled_aroundBody3$advice(AComponent.java:8)
    at de.scrum_master.app.AComponent.doSomething(AComponent.java:8)
    at de.scrum_master.app.Application.main(Application.java:6)

我认为，您可以使用此解决方案，也许宁愿记录警告而不是抛出异常，以便温和地指导您的同事检查和改进他们依赖 AOP 的 Spring 组件。有时他们可能不希望自我调用触发一个方面，这取决于具体情况。您可以在完整的 AspectJ 模式下运行 Spring 应用程序，然后在评估日志后切换回 Spring AOP。但也许只使用原生 AspectJ 开始并完全避免自调用问题会更简单。

更新：在 AspectJ 中，如果满足某些条件，您还可以让编译器抛出警告或错误。在这种情况下，您只能静态确定从组件到其他组件的调用，而无需区分自调用和对其他组件的其他方法的调用。所以这在这里对你没有帮助。

还请注意，此解决方案仅限于由@Component 注释的类。如果您的 Spring bean 以其他方式实例化，例如通过 XML 配置或 @Bean 工厂方法，这个简单的方面不起作用。但它可以通过检查拦截的类是否是代理实例来轻松扩展，然后才决定标记自调用。然后不幸的是，您必须将切面代码编织到所有应用程序类中，因为检查只能在运行时进行。

我可以解释更多的事情，例如使用自我注入和在注入的代理实例上调用内部方法，而不是通过this.internallyCalled(..)。那么自调用问题也就解决了，这种方法在Spring AOP中也可以使用。

【讨论】：