在单个Pointcut中获取不同注释的参数

Question

无论何时调用RESTendpoint，我都需要记录。我正在尝试使用Spring AOP进行此操作。

除其他事项外，我还需要延长端点的调用时间。也就是说，我需要读出Mapping注释的值。

我想以一种通用的方式解决这个问题。即“无论确切的映射是什么，都给我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

您可以在任何Spring方面接受JoinPoint，并从中提取呼叫Signature（在您的情况下，该呼叫应始终为MethodSignature）。然后，您可以使用该签名来获取被调用的方法。

一旦有了该方法，就可以使用Spring的元注释API从映射注释中获取所需的所有相关属性。

示例代码：

@PutMapping(path = "/example", consumes = "application/json")
void exampleWebMethod(JsonObject json) {
  /* implementation */
}

/**
 * Your aspect. I used simplified pointcut definition, but yours should work too.
 */
@Before("@annotation(org.springframework.web.bind.annotation.PutMapping)")
public void beforeRestMethods(JoinPoint jp) {
    MethodSignature sgn = (MethodSignature) jp.getSignature();
    Method method = sgn.getMethod();

    AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(
            method,
            RequestMapping.class
    );

    // and a simple test that this works.
    assertEquals(new String[] {"/example"}, attributes.getStringArray("path"));
    assertEquals(new String[] {"application/json"}, attributes.getStringArray("consumes"));

    // notice that this also works, because PutMapping is itself annotated with
    // @RequestMethod(method = PUT), and Spring's programming model lets you discover that

    assertEquals(new RequestMethod[] {RequestMethod.PUT}, (Object[]) attributes.get("method"));
}

如果您确实需要，还可以让Spring为您合成注释，如下所示：

RequestMapping mapping = AnnotatedElementUtils.getMergedAnnotation(
        method,
        RequestMapping.class
);

然后，Spring将创建一个实现注释接口的代理，该代理接口将允许在其上调用方法，就像从该方法获得的实际注释一样，但支持Spring的元注释。

Answer 2

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

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

  

具体来说，@GetMapping是一个组合的注释，它充当@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，它具有相当可读性和可维护性的方面代码，并且可以轻松地访问所有（元）注释信息。