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

Question

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

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

我想以通用的方式解决这个问题。即 "Give me the value of the Mapping whatever the exact mapping is".

所以我现在所做的基本上就是这个答案中提出的：

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

然后我将 getMapping 传递给我的建议并得到它的价值。

为了能够 select 我遇到的任何映射，我都遵循了这个问题的公认答案：

@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) {}

然后取值，因为所有的Mapping都是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' s 元注释。

Answer 2

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

关于 @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 具有用于查找带注释的注释（也嵌套）的语法，请参见例如。在这种情况下，我们可以使用该语法来一般匹配由 @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，它并不完美，但我们只能走得更远。我仍然认为它是紧凑的、可读的和可维护的，而不必列出要匹配的每个注解类型。

你怎么看？

更新：

如果要获取"syntactic sugar"请求映射注解的值，整个代码如下所示：

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

更新二：

如果您想按照 @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 
 */
@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，相当可读和可维护的方面代码，并以一种简单的方式访问所有（元）注释信息。

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

Get parameters of different annotations in a single Pointcut

java

aop

annotations

aspectj

spring-aop