结合 Guice 和 AOP

Question

我正在构建一个包，它试图根据标志截取函数的返回值。我的设计涉及一些 AOP。这个想法是一个类FirstIntercept拦截一个调用firstCall并将参数存储在Parameters对象中。然后稍后，第二个类 SecondIntercept 拦截另一个调用 secondCall 并根据 Parameters 中填充的内容执行一些逻辑：

// pseudoish code 
public class FirstIntercept {
   private Parameters param;

   @AfterReturning(pointcut = "execution(* ...firstCall(..))", returning = "payload")
   public void loadParam(Joinpoint joinPoint, Object payload) {
      // logic handling payload returned from firstCall()
      // logic provides a Boolean flag
      this.param = new Parameters(flag);
   }
}



public class Parameters {
   @Getter
   private Boolean flag;

   public Parameters(Boolean flag) {
      this.flag = flag;
   }
}



public class SecondIntercept {
   private static Parameters params;
   
   @Around("execution(* ...secondCall(..))")
   public void handleSecondCallIntercept(ProceedingJoinPoint joinPoint) {
      // want to do logic here based on what params contains
   }
}

我想要实现的是Parameters 对象在通过AOP 调用FirstIntercept.loadParam 时一劳永逸地加载。我不太确定我该如何坚持这种坚持。我在网上看了看，Google guice 似乎很有希望。我相信第一步是在Parameters 上使用依赖注入，但我真的不确定。有人可以帮我指出正确的方向吗？

---

编辑：

所以我尝试了这个设置：

public class FirstIntercept implements MethodInterceptor {
   public Object invoke(MethodInvocation invocation) throws Throwable {
      System.out.println("invoked!");
      return invocation.proceed();
   }

   @AfterReturning(pointcut = "execution(* ...firstCall(..))", returning = "payload")
   public void loadParam(Joinpoint joinPoint, Object payload) {
      // do stuff
   }

   public String firstCall() {
      return "hello";
   }
}

public class InterceptionModule extends AbstractModule {
   protected void configure() {
      FirstIntercept first = new FirstIntercept();
      bindInterceptor(Matchers.any(), Matchers.annotatedWith(AfterReturning.class), first);
   }
}

public class FirstIterceptTest {
   @Test
   public void dummy() {
      Injector injector = Guice.createInjector(new InterceptionModule());
      FirstIntercept intercept = injector.getInstance(FirstIntercept.class);

      intercept.firstCall();
   }
}

当我执行.firstCall() 时，我可以看到@AfterReturning 正在运行，但没有调用调用。

Answer 1

如果您扩展 AOP https://github.com/google/guice/wiki/AOP 的文档，您应该会得到以下内容：

public class FirstInterceptor implements MethodInterceptor {

  @Inject Parameters parameters;  // Injected with singleton Parameter

  public Object invoke(MethodInvocation invocation) throws Throwable {
    Object result = invocation.proceed();
    // your logic based on result to set parameters.setFlag()
    return result;
  }
}

然后是第二个：

public class SecondInterceptor implements MethodInterceptor {

  @Inject Parameters parameters;  // Injected with singleton Parameter

  public Object invoke(MethodInvocation invocation) throws Throwable {
    boolean flag = parameters.getFlag();
    // your logic here
    return invocation.proceed(); // maybe maybe not?
  }
}

您的参数是关键，您需要确保它是线程安全的，这是另一个主题。但是要注入这些你需要：

public class InterceptionModule extends AbstractModule {
  protected void configure() {
    // Ensure there is only ever one Parameter injected
    bind(Parameter.class).in(Scopes.SINGLETON);

    // Now inject and bind the first interceptor
    FirstInterceptor firstInterceptor = new FirstInterceptor();
    requestInjection(firstInterceptor );
    bindInterceptor(Matchers.any(), Matchers.annotatedWith(AfterReturning.class),
        firstInterceptor);

    // Now inject and bind the second interceptor
    SecondInterceptor SecondInterceptor = new SecondInterceptor ();
    requestInjection(firstInterceptor);
    bindInterceptor(Matchers.any(), Matchers.annotatedWith(AfterReturning.class),
        SecondInterceptor);
  }
}

编辑 看看你在做什么。

1. 你告诉 Guice 用 @AfterReturn 和 FirstInterceptor 包装一个方法
2. 然后你调用interceptor.firstCall()

第一次调用没有@AfterReturn 注解，那么为什么要匹配那个配置呢？

我猜你是否打过电话：

intercept.loadParam();

你会看到调用方法。此外，这非常适合测试，但在现实生活中，您希望服务级别类具有 @AfterReturn，然后将其注入另一个调用 LoadParam 的 Api/Job/Etc。

编辑 不好了。看看这一行

bindInterceptor(Matchers.any(),  // a class with this matcher
   Matchers.annotatedWith(AfterReturning.class),  // a method with this 
        firstInterceptor); 

这意味着注入器仅在 loadParams 上触发。您需要注释您希望使用@AfterReturning 进行拦截的类的方法。并且您希望 loadParams 成为调用方法。