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

Question

我知道这是因为在 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;
} 

Answer 1

如果足以让您检测内部调用，您可以使用本机 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 中也适用。

Answer 2

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

理论上可以，但要注意赖斯定理。任何此类工具有时都会发出误报。

您可以使用“抽象解释”技术来开发这样的工具。您可能需要一年以上的工作。 您可以将此类工具的开发分包给例如

Frama-C

团队。