java - 获取单个切入点中不同注释的参数

Question

每当调用 RESTendpoint 时，我都需要记录。我正在尝试使用 Spring AOP 来做到这一点。

除其他事项外，我需要长知道调用的端点。即我需要读出 Mapping 注释的值。

我想以通用的方式解决这个问题。即“无论确切的映射是什么，请给我映射的值”。

所以我现在所做的基本上就是这个答案中提出的: https://stackoverflow.com/a/26945251/2995907

@Pointcut("@annotation(getMapping)")
    public void getMappingAnnotations(GetMapping getMapping){ }

然后我将 getMapping 传递给我的建议并获取其值。

为了能够选择我遇到的任何映射，我遵循了这个问题中接受的答案: Spring Aspectj @Before all rest method

@Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping) " +
    "|| @annotation(org.springframework.web.bind.annotation.GetMapping)" +
    "|| @annotation(org.springframework.web.bind.annotation.PostMapping)" +
    "|| @annotation(org.springframework.web.bind.annotation.PathVariable)" +
    "|| @annotation(org.springframework.web.bind.annotation.PutMapping)" +
    "|| @annotation(org.springframework.web.bind.annotation.DeleteMapping)"
)
public void mappingAnnotations() {}

我想写一些类似的东西

public void mappingAnnotations(RequestMapping requestMapping) {}

然后从中获取值，因为所有映射都是 RequestMapping 的别名。不幸的是，这不起作用。到目前为止，看起来我必须为每种映射做一个单独的切入点，然后为每个映射都有一个方法(这将非常相似 - 不是很干)或相当丑陋的 if-else block (也许我可以通过一些摆弄使它成为一个开关)。

所以问题是我如何以干净的方式解决这个问题。我只想记录任何类型的映射并获取注释携带的相应路径参数。

Answer 1

在通常情况下，我会给出与 Nándor 相同的答案。 AspectJ 绑定(bind)到 || 不同分支的参数是不明确的，因为两个分支都可以匹配，所以这是不行的。

关于@RequestMapping，所有其他@*Mapping注释都是语法糖，并被记录为充当快捷方式的组合注释，请参见例如@GetMapping :

Specifically, @GetMapping is a composed annotation that acts as a shortcut for @RequestMapping(method = RequestMethod.GET).

即类型 GetMapping 本身由 @RequestMapping(method = RequestMethod.GET) 注释。这同样适用于其他组合(语法糖)注释。我们可以利用这种情况来实现我们的目的。

AspectJ 有一个用于查找带注释的注释(也是嵌套的)的语法，请参见例如my answer here 。在这种情况下，我们可以使用该语法来一般匹配 @RequestMapping 注释的所有注释。

这仍然给我们留下了两种情况，即直接注释和语法糖注释，但无论如何它简化了代码一点。我想出了这个纯 Java + AspectJ 示例应用程序，仅导入了 spring-web JAR 才能访问注释。否则我不会使用 Spring，但是切入点和建议在 Spring AOP 中看起来是一样的，您甚至可以从第一个切入点中删除 &&execution(* *(..)) 部分，因为 Spring AOP无论如何，除了执行切入点之外什么都不知道(但 AspectJ 知道并且也会匹配 call()，例如)。

驱动程序应用程序:

package de.scrum_master.app;

import org.springframework.web.bind.annotation.*;
import static org.springframework.web.bind.annotation.RequestMethod.*;

public class Application {
  @GetMapping public void get() {}
  @PostMapping public void post() {}
  @RequestMapping(method = HEAD) public void head() {}
  @RequestMapping(method = OPTIONS) public void options() {}
  @PutMapping public void put() {}
  @PatchMapping public void patch() {}
  @DeleteMapping @Deprecated public void delete() {}
  @RequestMapping(method = TRACE) public void trace() {}
  @RequestMapping(method = { GET, POST, HEAD}) public void mixed() {}

  public static void main(String[] args) {
    Application application = new Application();
    application.get();
    application.post();
    application.head();
    application.options();
    application.put();
    application.patch();
    application.delete();
    application.trace();
    application.mixed();
  }
}

请注意我如何混合不同的注释类型以及如何向一个方法添加另一个注释 @Deprecated 以便为我们不感兴趣的注释提供负面测试用例。

方面:

package de.scrum_master.aspect;

import java.lang.annotation.Annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Aspect
public class RequestMappingAspect {

  @Before("@annotation(requestMapping) && execution(* *(..))")
  public void genericMapping(JoinPoint thisJoinPoint, RequestMapping requestMapping) {
    System.out.println(thisJoinPoint);
    for (RequestMethod method : requestMapping.method())
      System.out.println("  " + method);
  }

  @Before("execution(@(@org.springframework.web.bind.annotation.RequestMapping *) * *(..))")
  public void metaMapping(JoinPoint thisJoinPoint) {
    System.out.println(thisJoinPoint);
    for (Annotation annotation : ((MethodSignature) thisJoinPoint.getSignature()).getMethod().getAnnotations()) {
      RequestMapping requestMapping = annotation.annotationType().getAnnotation(RequestMapping.class);
      if (requestMapping == null)
        continue;
      for (RequestMethod method : requestMapping.method())
        System.out.println("  " + method);
    }
  }

}

控制台日志:

execution(void de.scrum_master.app.Application.get())
  GET
execution(void de.scrum_master.app.Application.post())
  POST
execution(void de.scrum_master.app.Application.head())
  HEAD
execution(void de.scrum_master.app.Application.options())
  OPTIONS
execution(void de.scrum_master.app.Application.put())
  PUT
execution(void de.scrum_master.app.Application.patch())
  PATCH
execution(void de.scrum_master.app.Application.delete())
  DELETE
execution(void de.scrum_master.app.Application.trace())
  TRACE
execution(void de.scrum_master.app.Application.mixed())
  GET
  POST
  HEAD

对于DRY来说，它并不完美，但我们只能尽力而为。我仍然认为它是紧凑的、可读的和可维护的，而不必列出要匹配的每个注释类型。

你觉得怎么样？

<小时/>

更新:

如果你想获取“语法糖”请求映射注释的值，整个代码如下所示:

package de.scrum_master.app;

import org.springframework.web.bind.annotation.*;
import static org.springframework.web.bind.annotation.RequestMethod.*;

public class Application {
  @GetMapping public void get() {}
  @PostMapping(value = "foo") public void post() {}
  @RequestMapping(value = {"foo", "bar"}, method = HEAD) public void head() {}
  @RequestMapping(value = "foo", method = OPTIONS) public void options() {}
  @PutMapping(value = "foo") public void put() {}
  @PatchMapping(value = "foo") public void patch() {}
  @DeleteMapping(value = {"foo", "bar"}) @Deprecated public void delete() {}
  @RequestMapping(value = "foo", method = TRACE) public void trace() {}
  @RequestMapping(value = "foo", method = { GET, POST, HEAD}) public void mixed() {}

  public static void main(String[] args) {
    Application application = new Application();
    application.get();
    application.post();
    application.head();
    application.options();
    application.put();
    application.patch();
    application.delete();
    application.trace();
    application.mixed();
  }
}

package de.scrum_master.aspect;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Aspect
public class RequestMappingAspect {

  @Before("@annotation(requestMapping) && execution(* *(..))")
  public void genericMapping(JoinPoint thisJoinPoint, RequestMapping requestMapping) {
    System.out.println(thisJoinPoint);
    for (String value : requestMapping.value())
      System.out.println("  value = " + value);
    for (RequestMethod method : requestMapping.method())
      System.out.println("  method = " + method);
  }

  @Before("execution(@(@org.springframework.web.bind.annotation.RequestMapping *) * *(..))")
  public void metaMapping(JoinPoint thisJoinPoint) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
    System.out.println(thisJoinPoint);
    for (Annotation annotation : ((MethodSignature) thisJoinPoint.getSignature()).getMethod().getAnnotations()) {
      RequestMapping requestMapping = annotation.annotationType().getAnnotation(RequestMapping.class);
      if (requestMapping == null)
        continue;
      for (String value : (String[]) annotation.annotationType().getDeclaredMethod("value").invoke(annotation))
        System.out.println("  value = " + value);
      for (RequestMethod method : requestMapping.method())
        System.out.println("  method = " + method);
    }
  }

}

控制台日志如下所示:

execution(void de.scrum_master.app.Application.get())
  method = GET
execution(void de.scrum_master.app.Application.post())
  value = foo
  method = POST
execution(void de.scrum_master.app.Application.head())
  value = foo
  value = bar
  method = HEAD
execution(void de.scrum_master.app.Application.options())
  value = foo
  method = OPTIONS
execution(void de.scrum_master.app.Application.put())
  value = foo
  method = PUT
execution(void de.scrum_master.app.Application.patch())
  value = foo
  method = PATCH
execution(void de.scrum_master.app.Application.delete())
  value = foo
  value = bar
  method = DELETE
execution(void de.scrum_master.app.Application.trace())
  value = foo
  method = TRACE
execution(void de.scrum_master.app.Application.mixed())
  value = foo
  method = GET
  method = POST
  method = HEAD

<小时/>

更新2:

如果您想按照 @M 最初的建议使用 Spring 的 AnnotatedElementUtils 和 AnnotationAttributes 来隐藏反射内容。 Prokhorov，您可以利用这样一个事实:通过 getMergedAnnotationAttributes，您实际上可以一站式购买原始 RequestMapping 注释和语法糖(例如 ) GetMapping，在单个合并的属性对象中获取方法和值信息。这甚至使您能够消除获取信息的两种不同情况，从而将两个建议合并为一个，如下所示:

package de.scrum_master.aspect;

import static org.springframework.core.annotation.AnnotatedElementUtils.getMergedAnnotationAttributes;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * See https://stackoverflow.com/a/53892842/1082681
 */
@Aspect
public class RequestMappingAspect {
  @Before(
    "execution(@org.springframework.web.bind.annotation.RequestMapping * *(..)) ||" +
    "execution(@(@org.springframework.web.bind.annotation.RequestMapping *) * *(..))"
  )
  public void metaMapping(JoinPoint thisJoinPoint) {
    System.out.println(thisJoinPoint);
      AnnotationAttributes annotationAttributes = getMergedAnnotationAttributes(
        ((MethodSignature) thisJoinPoint.getSignature()).getMethod(),
        RequestMapping.class
      );
      for (String value : (String[]) annotationAttributes.get("value"))
        System.out.println("  value = " + value);
      for (RequestMethod method : (RequestMethod[]) annotationAttributes.get("method"))
        System.out.println("  method = " + method);
  }
}

现在你已经得到了:如你最初希望的那样，DRY，具有相当可读性和可维护性的方面代码，并以简单的方式访问所有(元)注释信息。