Consistent annotation lookup in MvcUriComponentsBuilder

Previously, a UriComponents build based on a method would require the
given method to be the annotated one as method parameter resolution only
applied locally. This was a problem when a controller was specified on
a method whose mapping is defined in a parent.

This commit harmonies the lookup using AnnotatedMethod who provides
support for a synthesized method parameter that takes annotations from
parent parameter into account.

Closes gh-32553

spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/MvcUriComponentsBuilder.java

@@ -42,7 +42,7 @@
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ParameterNameDiscoverer;
 import org.springframework.core.annotation.AnnotatedElementUtils;
-import org.springframework.core.annotation.SynthesizingMethodParameter;
+import org.springframework.core.annotation.AnnotatedMethod;
 import org.springframework.lang.Nullable;
 import org.springframework.objenesis.ObjenesisException;
 import org.springframework.objenesis.SpringObjenesis;
@@ -538,22 +538,23 @@ public UriComponentsBuilder withMethod(Class<?> controllerType, Method method, O
  private static UriComponentsBuilder fromMethodInternal(@Nullable UriComponentsBuilder builder,
  Class<?> controllerType, Method method, Object... args) {
 
+ AnnotatedMethod annotatedMethod = new AnnotatedMethod(method);
  builder = getBaseUrlToUse(builder);
 
  // Externally configured prefix via PathConfigurer..
  String prefix = getPathPrefix(controllerType);
  builder.path(prefix);
 
  String typePath = getClassMapping(controllerType);
- String methodPath = getMethodMapping(method);
+ String methodPath = getMethodMapping(annotatedMethod);
  String path = pathMatcher.combine(typePath, methodPath);
  path = PathPatternParser.defaultInstance.initFullPathPattern(path);
  if (!StringUtils.hasText(prefix + path)) {
  path = "/";
  }
  builder.path(path);
 
- return applyContributors(builder, method, args);
+ return applyContributors(builder, annotatedMethod, args);
  }
 
  private static UriComponentsBuilder getBaseUrlToUse(@Nullable UriComponentsBuilder baseUrl) {
@@ -587,13 +588,12 @@ private static String getClassMapping(Class<?> controllerType) {
  return getPathMapping(mapping, controllerType.getName());
  }
 
- private static String getMethodMapping(Method method) {
- Assert.notNull(method, "'method' must not be null");
- RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(method, RequestMapping.class);
+ private static String getMethodMapping(AnnotatedMethod annotatedMethod) {
+ RequestMapping requestMapping = annotatedMethod.getMethodAnnotation(RequestMapping.class);
  if (requestMapping == null) {
- throw new IllegalArgumentException("No @RequestMapping on: " + method.toGenericString());
+ throw new IllegalArgumentException("No @RequestMapping on: " + annotatedMethod.getMethod().toGenericString());
  }
- return getPathMapping(requestMapping, method.toGenericString());
+ return getPathMapping(requestMapping, annotatedMethod.getMethod().toGenericString());
  }
 
  private static String getPathMapping(RequestMapping requestMapping, String source) {
@@ -628,10 +628,12 @@ else if (methods.size() > 1) {
  }
  }
 
- private static UriComponentsBuilder applyContributors(UriComponentsBuilder builder, Method method, Object... args) {
+ private static UriComponentsBuilder applyContributors(UriComponentsBuilder builder,
+ AnnotatedMethod annotatedMethod, Object... args) {
+
  CompositeUriComponentsContributor contributor = getUriComponentsContributor();
 
- int paramCount = method.getParameterCount();
+ int paramCount = annotatedMethod.getMethodParameters().length;
  int argCount = args.length;
  if (paramCount != argCount) {
  throw new IllegalArgumentException("Number of method parameters " + paramCount +
@@ -640,7 +642,7 @@ private static UriComponentsBuilder applyContributors(UriComponentsBuilder build
 
  final Map<String, Object> uriVars = new HashMap<>();
  for (int i = 0; i < paramCount; i++) {
- MethodParameter param = new SynthesizingMethodParameter(method, i);
+ MethodParameter param = annotatedMethod.getMethodParameters()[i];
  param.initParameterNameDiscovery(parameterNameDiscoverer);
  contributor.contributeMethodArgument(param, args[i], builder, uriVars);
  }

spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/MvcUriComponentsBuilderTests.java

@@ -42,6 +42,7 @@
 import org.springframework.format.annotation.DateTimeFormat.ISO;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.lang.Nullable;
 import org.springframework.stereotype.Controller;
 import org.springframework.util.MultiValueMap;
@@ -334,6 +335,14 @@ void fromMethodNameConfigurablePath() {
  assertThat(uriComponents.toUriString()).isEqualTo("http://localhost/something/custom/1/foo");
  }
 
+ @Test
+ void fromMethodNameWithAnnotationsOnInterface() {
+ initWebApplicationContext(WebConfig.class);
+ UriComponents uriComponents = fromMethodName(HelloController.class, "get", "test").build();
+
+ assertThat(uriComponents.toString()).isEqualTo("http://localhost/hello/test");
+ }
+
  @Test
  void fromMethodCallOnSubclass() {
  UriComponents uriComponents = fromMethodCall(on(ExtendedController.class).myMethod(null)).build();
@@ -855,4 +864,20 @@ public Savepoint getBooking(@PathVariable Long booking) {
  }
  }
 
+ interface HelloInterface {
+
+ @GetMapping("/hello/{name}")
+ ResponseEntity<String> get(@PathVariable String name);
+ }
+
+ @Controller
+ static class HelloController implements HelloInterface {
+
+ @Override
+ public ResponseEntity<String> get(String name) {
+ return ResponseEntity.ok("Hello " + name);
+ }
+
+ }
+
 }