问题：

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

笪煌

2023-03-14

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

在其他事情中，我需要延长endpoint的名称。一、我需要读出映射注释的值。

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

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

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

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

为了能够选择我遇到的任何映射，我遵循这个问题的公认答案：Spring Aspectj@在所有rest方法之前

@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块（也许我可以用一些fiddeling来做一个切换）。

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

共有2个答案

富钧

2023-03-14

您可以在任何Spring方面接受连接点，并从中提取调用签名（在您的情况下，该签名应该始终是方法签名）。然后您可以使用该签名来获得一个被调用的方法。

获得该方法后，您可以使用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 sythnesize为您提供注释，如下所示：

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

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

程博学

2023-03-14

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

关于请求映射（RequestMapping），所有其他映射（Mapping）都是语法糖，并被记录为作为快捷方式的组合注释，请参见例如GetMapping（GetMapping）：

具体来说，@GetMapping是一个组合注释，用作@RequestMapping（method=RequestMethod.GET）的快捷方式。

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

AeyJ有一种用于查找带注释注释（也是嵌套的）的语法，参见例如我在这里的答案。在这种情况下，我们可以使用该语法来通用地匹配由@Request estMap注释的所有注释。

这仍然给我们留下了两种情况，即直接注释和语法糖注释，但它还是稍微简化了代码。我想出了这个纯JavaAeyJ示例应用程序，只导入了spring-web JAR以便访问注释。否则我不使用Spring，但切入点和建议在Spring AOP中看起来是一样的，您甚至可以消除

驱动程序应用程序：

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();
  }
}

请注意，我是如何混合不同的注释类型的，以及我是如何在一个方法中添加另一个注释的，以便为我们不感兴趣的注释提供一个否定的测试用例。

方面：

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

这在干燥方面并不完美，但我们只能尽可能地去做。我仍然认为它是紧凑、可读和可维护的，而不必列出要匹配的每个注释类型。

你觉得怎么样？

更新：

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

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：

如果您想使用Spring的AnnotatedElementUtils和AnnotationAttributes来隐藏反射内容，正如@M.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、相当可读和可维护的方面代码以及以简单的方式访问所有（元）注释信息。

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

共有2个答案

相关问答

相关文章

相关阅读

相关工具

相关文档