Add meta-annotations support for @RequestHeader in spring-webflux

Author: zakaria-shahen

spring-webflux/src/main/java/org/springframework/web/reactive/result/method/HandlerMethodArgumentResolverSupport.java

@@ -118,6 +118,31 @@ protected <A extends Annotation> boolean checkAnnotatedParamNoReactiveWrapper(
 			return false;
 		}
 
+		return checkAnnotatedParamNoReactiveWrapperCommon(parameter, annotation, typePredicate);
+	}
+
+
+	/**
+	 * Evaluate the {@code Predicate} on the method parameter type if it has the
+	 * given annotation, either directly declared or as a meta-annotation,
+	 * nesting within {@link java.util.Optional} if necessary,
+	 * but raise an {@code IllegalStateException} if the same matches the generic
+	 * type within a reactive type wrapper.
+	 */
+	protected <A extends Annotation> boolean checkNestedAnnotatedParamNoReactiveWrapper(
+			MethodParameter parameter, Class<A> annotationType, BiPredicate<A, Class<?>> typePredicate) {
+
+		A annotation = parameter.getParameterNestedAnnotation(annotationType);
+		if (annotation == null) {
+			return false;
+		}
+
+		return checkAnnotatedParamNoReactiveWrapperCommon(parameter, annotation, typePredicate);
+	}
+
+	private  <A extends Annotation> boolean checkAnnotatedParamNoReactiveWrapperCommon(
+			MethodParameter parameter, A annotation, BiPredicate<A, Class<?>> typePredicate) {
+
 		parameter = parameter.nestedIfOptional();
 		Class<?> type = parameter.getNestedParameterType();
 

spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/RequestHeaderMethodArgumentResolver.java

@@ -65,7 +65,7 @@ public RequestHeaderMethodArgumentResolver(@Nullable ConfigurableBeanFactory fac
 
 	@Override
 	public boolean supportsParameter(MethodParameter param) {
-		return checkAnnotatedParamNoReactiveWrapper(param, RequestHeader.class, this::singleParam);
+		return checkNestedAnnotatedParamNoReactiveWrapper(param, RequestHeader.class, this::singleParam);
 	}
 
 	private boolean singleParam(RequestHeader annotation, Class<?> type) {
@@ -74,7 +74,7 @@ private boolean singleParam(RequestHeader annotation, Class<?> type) {
 
 	@Override
 	protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
-		RequestHeader ann = parameter.getParameterAnnotation(RequestHeader.class);
+		RequestHeader ann = parameter.getParameterNestedAnnotation(RequestHeader.class);
 		Assert.state(ann != null, "No RequestHeader annotation");
 		return new RequestHeaderNamedValueInfo(ann);
 	}

spring-webflux/src/test/java/org/springframework/web/reactive/result/method/annotation/RequestHeaderMethodArgumentResolverTests.java

@@ -16,6 +16,10 @@
 
 package org.springframework.web.reactive.result.method.annotation;
 
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.lang.reflect.Method;
 import java.time.Instant;
 import java.time.format.DateTimeFormatter;
@@ -68,6 +72,7 @@ class RequestHeaderMethodArgumentResolverTests {
 	private MethodParameter paramInstant;
 	private MethodParameter paramMono;
 	private MethodParameter primitivePlaceholderParam;
+	private MethodParameter paramWithNestedAnnotated;
 
 
 	@BeforeEach
@@ -92,6 +97,7 @@ void setup() throws Exception {
 		this.paramInstant = new SynthesizingMethodParameter(method, 7);
 		this.paramMono = new SynthesizingMethodParameter(method, 8);
 		this.primitivePlaceholderParam = new SynthesizingMethodParameter(method, 9);
+		this.paramWithNestedAnnotated = new SynthesizingMethodParameter(method, 10);
 	}
 
 
@@ -103,6 +109,8 @@ void supportsParameter() {
 		assertThatIllegalStateException()
 				.isThrownBy(() -> this.resolver.supportsParameter(this.paramMono))
 				.withMessageStartingWith("RequestHeaderMethodArgumentResolver does not support reactive type wrapper");
+		assertThat(resolver.supportsParameter(paramWithNestedAnnotated)).as("String parameter with nested annotated not supported").isTrue();
+
 	}
 
 	@Test
@@ -265,6 +273,16 @@ void instantConversion() {
 		assertThat(result).isEqualTo(Instant.from(DateTimeFormatter.RFC_1123_DATE_TIME.parse(rfc1123val)));
 	}
 
+	@Test
+	void resolveStringWithNestedAnnotatedArgument() {
+		String expected = "foo";
+		ServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/").header("name", expected));
+
+		Mono<Object> mono = this.resolver.resolveArgument(
+				this.paramWithNestedAnnotated, this.bindingContext, exchange);
+
+		assertThat(mono.block()).isEqualTo(expected);
+	}
 
 	@SuppressWarnings("unused")
 	public void params(
@@ -277,7 +295,14 @@ public void params(
 			@RequestHeader("name") Date dateParam,
 			@RequestHeader("name") Instant instantParam,
 			@RequestHeader Mono<String> alsoNotSupported,
-			@RequestHeader(value = "${systemProperty}", required = false) int primitivePlaceholderParam) {
+			@RequestHeader(value = "${systemProperty}", required = false) int primitivePlaceholderParam,
+			@NameRequestHeader String param6) {
+	}
+
+	@Target(ElementType.PARAMETER)
+	@Retention(RetentionPolicy.RUNTIME)
+	@RequestHeader(name = "name", defaultValue = "bar")
+	private @interface NameRequestHeader {
 	}
 
 }