Revert "Remove RuntimeHintsUtils"

This reverts commit 3e327f5641.

spring-beans/src/main/java/org/springframework/beans/factory/annotation/BeanFactoryAnnotationsRuntimeHints.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.beans.factory.annotation;
+
+import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.RuntimeHintsRegistrar;
+import org.springframework.aot.hint.support.RuntimeHintsUtils;
+import org.springframework.lang.Nullable;
+
+/**
+ * {@link RuntimeHintsRegistrar} implementation for bean factory annotations.
+ *
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+class BeanFactoryAnnotationsRuntimeHints implements RuntimeHintsRegistrar {
+
+	@Override
+	@SuppressWarnings("deprecation")
+	public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) {
+		RuntimeHintsUtils.registerSynthesizedAnnotation(hints, Qualifier.class);
+	}
+}

spring-beans/src/main/resources/META-INF/spring/aot.factories

@@ -1,4 +1,5 @@
 org.springframework.aot.hint.RuntimeHintsRegistrar=\
+org.springframework.beans.factory.annotation.BeanFactoryAnnotationsRuntimeHints,\
 org.springframework.beans.factory.annotation.JakartaAnnotationsRuntimeHints
 
 org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor=\

spring-core/src/main/java/org/springframework/aot/hint/annotation/ReflectiveRuntimeHintsRegistrar.java

@@ -28,6 +28,8 @@ import java.util.function.Consumer;
 
 import org.springframework.aot.hint.ReflectionHints;
 import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.support.RuntimeHintsUtils;
+import org.springframework.core.annotation.MergedAnnotation;
 import org.springframework.core.annotation.MergedAnnotations;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ReflectionUtils;
@@ -60,9 +62,20 @@ public class ReflectiveRuntimeHintsRegistrar {
 		entries.forEach(entry -> {
 			AnnotatedElement element = entry.element();
 			entry.processor().registerReflectionHints(runtimeHints.reflection(), element);
+			registerAnnotationIfNecessary(runtimeHints, element);
 		});
 	}
 
+	@SuppressWarnings("deprecation")
+	private void registerAnnotationIfNecessary(RuntimeHints hints, AnnotatedElement element) {
+		MergedAnnotation<Reflective> reflectiveAnnotation = MergedAnnotations.from(element)
+				.get(Reflective.class);
+		MergedAnnotation<?> metaSource = reflectiveAnnotation.getMetaSource();
+		if (metaSource != null) {
+			RuntimeHintsUtils.registerAnnotationIfNecessary(hints, metaSource);
+		}
+	}
+
 	private void processType(Set<Entry> entries, Class<?> typeToProcess) {
 		if (isReflective(typeToProcess)) {
 			entries.add(createEntry(typeToProcess));

spring-core/src/main/java/org/springframework/aot/hint/support/RuntimeHintsUtils.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aot.hint.support;
+
+import java.util.function.Consumer;
+
+import org.springframework.aot.hint.MemberCategory;
+import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.TypeHint;
+import org.springframework.aot.hint.TypeHint.Builder;
+import org.springframework.core.annotation.AliasFor;
+import org.springframework.core.annotation.MergedAnnotation;
+
+/**
+ * Utility methods for runtime hints support code.
+ *
+ * @author Stephane Nicoll
+ * @author Sam Brannen
+ * @since 6.0
+ */
+public abstract class RuntimeHintsUtils {
+
+	/**
+	 * A {@link TypeHint} customizer suitable for an annotation. Make sure
+	 * that its attributes are visible.
+	 * @deprecated as annotation attributes are visible without additional hints
+	 */
+	@Deprecated
+	public static final Consumer<Builder> ANNOTATION_HINT = hint ->
+			hint.withMembers(MemberCategory.INVOKE_DECLARED_METHODS);
+
+	/**
+	 * Register the necessary hints so that the specified annotation is visible
+	 * at runtime.
+	 * @param hints the {@link RuntimeHints} instance to use
+	 * @param annotationType the annotation type
+	 * @deprecated For removal prior to Spring Framework 6.0
+	 */
+	@Deprecated
+	public static void registerAnnotation(RuntimeHints hints, Class<?> annotationType) {
+		registerSynthesizedAnnotation(hints, annotationType);
+	}
+
+	/**
+	 * Register the necessary hints so that the specified annotation can be
+	 * synthesized at runtime if necessary. Such hints are usually required
+	 * if any of the following apply:
+	 * <ul>
+	 * <li>Use {@link AliasFor} for local aliases</li>
+	 * <li>Has a meta-annotation that uses {@link AliasFor} for attribute overrides</li>
+	 * <li>Has nested annotations or arrays of annotations that are synthesizable</li>
+	 * </ul>
+	 * Consider using {@link #registerAnnotationIfNecessary(RuntimeHints, MergedAnnotation)}
+	 * that determines if the hints are required.
+	 * @param hints the {@link RuntimeHints} instance to use
+	 * @param annotationType the annotation type
+	 * @deprecated For removal prior to Spring Framework 6.0
+	 */
+	@Deprecated
+	@SuppressWarnings("deprecation")
+	public static void registerSynthesizedAnnotation(RuntimeHints hints, Class<?> annotationType) {
+		hints.proxies().registerJdkProxy(annotationType,
+				org.springframework.core.annotation.SynthesizedAnnotation.class);
+	}
+
+	/**
+	 * Determine if the specified annotation can be synthesized at runtime, and
+	 * register the necessary hints accordingly.
+	 * @param hints the {@link RuntimeHints} instance to use
+	 * @param annotation the annotation
+	 * @see #registerSynthesizedAnnotation(RuntimeHints, Class)
+	 * @deprecated For removal prior to Spring Framework 6.0
+	 */
+	@Deprecated
+	public static void registerAnnotationIfNecessary(RuntimeHints hints, MergedAnnotation<?> annotation) {
+		if (annotation.isSynthesizable()) {
+			registerSynthesizedAnnotation(hints, annotation.getType());
+		}
+	}
+
+}

spring-core/src/test/java/org/springframework/aot/hint/annotation/ReflectiveRuntimeHintsRegistrarTests.java

@@ -86,6 +86,23 @@ class ReflectiveRuntimeHintsRegistrarTests {
 						.satisfies(methodHint -> assertThat(methodHint.getName()).isEqualTo("managed")));
 	}
 
+	@Test
+	void shouldNotRegisterAnnotationProxyIfNotNeeded() {
+		process(SampleMethodMetaAnnotatedBean.class);
+		RuntimeHints runtimeHints = this.runtimeHints;
+		assertThat(runtimeHints.proxies().jdkProxies()).isEmpty();
+	}
+
+	@Test
+	@SuppressWarnings("deprecation")
+	void shouldRegisterAnnotationProxy() {
+		process(SampleMethodMetaAnnotatedBeanWithAlias.class);
+		RuntimeHints runtimeHints = this.runtimeHints;
+		assertThat(RuntimeHintsPredicates.proxies()
+				.forInterfaces(SampleInvoker.class, org.springframework.core.annotation.SynthesizedAnnotation.class))
+					.accepts(runtimeHints);
+	}
+
 	@Test
 	void shouldProcessAnnotationOnInterface() {
 		process(SampleMethodAnnotatedBeanWithInterface.class);

spring-core/src/test/java/org/springframework/aot/hint/support/RuntimeHintsUtilsTests.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aot.hint.support;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.function.Consumer;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aot.hint.JdkProxyHint;
+import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.TypeReference;
+import org.springframework.core.annotation.AliasFor;
+import org.springframework.core.annotation.MergedAnnotation;
+import org.springframework.core.annotation.MergedAnnotations;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link RuntimeHintsUtils}.
+ *
+ * @author Stephane Nicoll
+ * @author Sam Brannen
+ */
+class RuntimeHintsUtilsTests {
+
+	private final RuntimeHints hints = new RuntimeHints();
+
+	@Test
+	@SuppressWarnings("deprecation")
+	void registerSynthesizedAnnotation() {
+		RuntimeHintsUtils.registerSynthesizedAnnotation(this.hints, SampleInvoker.class);
+		assertThat(this.hints.proxies().jdkProxies()).singleElement()
+				.satisfies(annotationProxy(SampleInvoker.class));
+	}
+
+	@Test
+	@SuppressWarnings("deprecation")
+	void registerAnnotationIfNecessaryWithNonSynthesizedAnnotation() throws NoSuchFieldException {
+		MergedAnnotation<SampleInvoker> annotation = MergedAnnotations
+				.from(TestBean.class.getField("sampleInvoker")).get(SampleInvoker.class);
+		RuntimeHintsUtils.registerAnnotationIfNecessary(this.hints, annotation);
+		assertThat(this.hints.proxies().jdkProxies()).isEmpty();
+	}
+
+	@Test
+	@SuppressWarnings("deprecation")
+	void registerAnnotationIfNecessaryWithLocalAliases() throws NoSuchFieldException {
+		MergedAnnotation<LocalMapping> annotation = MergedAnnotations
+				.from(TestBean.class.getField("localMapping")).get(LocalMapping.class);
+		RuntimeHintsUtils.registerAnnotationIfNecessary(this.hints, annotation);
+		assertThat(this.hints.proxies().jdkProxies()).singleElement()
+				.satisfies(annotationProxy(LocalMapping.class));
+	}
+
+	@Test
+	@SuppressWarnings("deprecation")
+	void registerAnnotationIfNecessaryWithMetaAttributeOverride() throws NoSuchFieldException {
+		MergedAnnotation<SampleInvoker> annotation = MergedAnnotations
+				.from(TestBean.class.getField("retryInvoker")).get(SampleInvoker.class);
+		RuntimeHintsUtils.registerAnnotationIfNecessary(this.hints, annotation);
+		assertThat(this.hints.proxies().jdkProxies()).singleElement()
+				.satisfies(annotationProxy(SampleInvoker.class));
+	}
+
+	@Test
+	@SuppressWarnings("deprecation")
+	void registerAnnotationIfNecessaryWithSynthesizedAttribute() throws NoSuchFieldException {
+		MergedAnnotation<RetryContainer> annotation = MergedAnnotations
+				.from(TestBean.class.getField("retryContainer")).get(RetryContainer.class);
+		RuntimeHintsUtils.registerAnnotationIfNecessary(this.hints, annotation);
+		assertThat(this.hints.proxies().jdkProxies()).singleElement()
+				.satisfies(annotationProxy(RetryContainer.class));
+	}
+
+	@SuppressWarnings("deprecation")
+	private Consumer<JdkProxyHint> annotationProxy(Class<?> type) {
+		return jdkProxyHint -> assertThat(jdkProxyHint.getProxiedInterfaces())
+				.containsExactly(TypeReference.of(type),
+						TypeReference.of(org.springframework.core.annotation.SynthesizedAnnotation.class));
+	}
+
+
+	static class TestBean {
+
+		@SampleInvoker
+		public String sampleInvoker;
+
+		@LocalMapping
+		public String localMapping;
+
+		@RetryInvoker
+		public String retryInvoker;
+
+		@RetryContainer(retry = @RetryInvoker(3))
+		public String retryContainer;
+
+	}
+
+	@Retention(RetentionPolicy.RUNTIME)
+	@interface LocalMapping {
+
+		@AliasFor("retries")
+		int value() default 0;
+
+		@AliasFor("value")
+		int retries() default 0;
+
+	}
+
+
+	@Retention(RetentionPolicy.RUNTIME)
+	@interface SampleInvoker {
+
+		int retries() default 0;
+
+	}
+
+	@Retention(RetentionPolicy.RUNTIME)
+	@SampleInvoker
+	@interface RetryInvoker {
+
+		@AliasFor(attribute = "retries", annotation = SampleInvoker.class)
+		int value() default 1;
+
+	}
+
+	@Retention(RetentionPolicy.RUNTIME)
+	@interface RetryContainer {
+
+		RetryInvoker retry();
+
+	}
+
+}

spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/MessagingAnnotationsRuntimeHints.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.handler.annotation;
+
+import java.util.stream.Stream;
+
+import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.RuntimeHintsRegistrar;
+import org.springframework.aot.hint.support.RuntimeHintsUtils;
+import org.springframework.lang.Nullable;
+import org.springframework.stereotype.Controller;
+
+/**
+ * {@link RuntimeHintsRegistrar} implementation that makes messaging
+ * annotations available at runtime.
+ *
+ * @author Sebastien Deleuze
+ * @since 6.0
+ */
+public class MessagingAnnotationsRuntimeHints implements RuntimeHintsRegistrar {
+
+	@Override
+	@SuppressWarnings("deprecation")
+	public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) {
+		Stream.of(Controller.class, Header.class, Headers.class, Payload.class).forEach(annotationType ->
+				RuntimeHintsUtils.registerSynthesizedAnnotation(hints, annotationType));
+	}
+
+}

spring-messaging/src/main/java/org/springframework/messaging/simp/annotation/SimpAnnotationsRuntimeHints.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.simp.annotation;
+
+import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.RuntimeHintsRegistrar;
+import org.springframework.aot.hint.support.RuntimeHintsUtils;
+
+/**
+ * {@link RuntimeHintsRegistrar} implementation that makes Simp annotations
+ * available at runtime.
+ *
+ * @author Sebastien Deleuze
+ * @since 6.0
+ */
+public class SimpAnnotationsRuntimeHints implements RuntimeHintsRegistrar {
+
+	@Override
+	@SuppressWarnings("deprecation")
+	public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
+		RuntimeHintsUtils.registerSynthesizedAnnotation(hints, SendToUser.class);
+	}
+
+}

spring-messaging/src/main/java/org/springframework/messaging/simp/config/AbstractMessageBrokerConfiguration.java

@@ -27,6 +27,7 @@ import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ImportRuntimeHints;
 import org.springframework.context.event.SmartApplicationListener;
 import org.springframework.core.task.TaskExecutor;
 import org.springframework.lang.Nullable;
@@ -40,10 +41,12 @@ import org.springframework.messaging.converter.KotlinSerializationJsonMessageCon
 import org.springframework.messaging.converter.MappingJackson2MessageConverter;
 import org.springframework.messaging.converter.MessageConverter;
 import org.springframework.messaging.converter.StringMessageConverter;
+import org.springframework.messaging.handler.annotation.MessagingAnnotationsRuntimeHints;
 import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver;
 import org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler;
 import org.springframework.messaging.simp.SimpLogging;
 import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.messaging.simp.annotation.SimpAnnotationsRuntimeHints;
 import org.springframework.messaging.simp.annotation.support.SimpAnnotationMethodMessageHandler;
 import org.springframework.messaging.simp.broker.AbstractBrokerMessageHandler;
 import org.springframework.messaging.simp.broker.SimpleBrokerMessageHandler;
@@ -95,6 +98,7 @@ import org.springframework.validation.beanvalidation.OptionalValidatorFactoryBea
  * @author Sebastien Deleuze
  * @since 4.0
  */
+@ImportRuntimeHints({ MessagingAnnotationsRuntimeHints.class, SimpAnnotationsRuntimeHints.class })
 public abstract class AbstractMessageBrokerConfiguration implements ApplicationContextAware {
 
 	private static final String MVC_VALIDATOR_NAME = "mvcValidator";

spring-test/src/test/java/org/springframework/test/context/aot/TestAotProcessorTests.java

@@ -70,7 +70,8 @@ class TestAotProcessorTests extends AbstractAotTests {
 
 		assertThat(findFiles(resourceOutput)).contains(
 				"META-INF/native-image/org.example/app-tests/reflect-config.json",
-				"META-INF/native-image/org.example/app-tests/resource-config.json");
+				"META-INF/native-image/org.example/app-tests/resource-config.json",
+				"META-INF/native-image/org.example/app-tests/proxy-config.json");
 	}
 
 	private void copy(Class<?> testClass, Path destination) {

spring-tx/src/main/java/org/springframework/transaction/annotation/TransactionRuntimeHints.java

@@ -21,6 +21,7 @@ import org.springframework.aot.hint.RuntimeHints;
 import org.springframework.aot.hint.RuntimeHintsRegistrar;
 import org.springframework.aot.hint.TypeHint;
 import org.springframework.aot.hint.TypeReference;
+import org.springframework.aot.hint.support.RuntimeHintsUtils;
 import org.springframework.transaction.TransactionDefinition;
 
 /**
@@ -34,7 +35,9 @@ import org.springframework.transaction.TransactionDefinition;
 class TransactionRuntimeHints implements RuntimeHintsRegistrar {
 
 	@Override
+	@SuppressWarnings("deprecation")
 	public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
+		RuntimeHintsUtils.registerSynthesizedAnnotation(hints, Transactional.class);
 		hints.reflection().registerTypes(TypeReference.listOf(
 					Isolation.class, Propagation.class, TransactionDefinition.class),
 				TypeHint.builtWith(MemberCategory.DECLARED_FIELDS));

spring-web/src/main/java/org/springframework/web/bind/annotation/WebAnnotationsRuntimeHintsRegistrar.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.web.bind.annotation;
+
+import java.util.stream.Stream;
+
+import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.RuntimeHintsRegistrar;
+import org.springframework.aot.hint.support.RuntimeHintsUtils;
+import org.springframework.lang.Nullable;
+import org.springframework.stereotype.Controller;
+
+/**
+ * {@link RuntimeHintsRegistrar} implementation that makes web binding
+ * annotations available at runtime.
+ *
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+public final class WebAnnotationsRuntimeHintsRegistrar implements RuntimeHintsRegistrar {
+
+	@Override
+	@SuppressWarnings("deprecation")
+	public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) {
+		Stream.of(Controller.class, ControllerAdvice.class, CookieValue.class,
+						CrossOrigin.class, MatrixVariable.class, ModelAttribute.class,
+						PathVariable.class, RequestAttribute.class, RequestHeader.class,
+						RequestMapping.class, RequestParam.class, RequestPart.class,
+						ResponseStatus.class, SessionAttribute.class, SessionAttributes.class)
+				.forEach(annotationType ->
+						RuntimeHintsUtils.registerSynthesizedAnnotation(hints, annotationType));
+	}
+
+}

spring-webflux/src/main/java/org/springframework/web/reactive/config/WebFluxConfigurationSupport.java

@@ -27,6 +27,7 @@ import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ImportRuntimeHints;
 import org.springframework.core.ReactiveAdapterRegistry;
 import org.springframework.core.annotation.Order;
 import org.springframework.core.convert.converter.Converter;
@@ -45,6 +46,7 @@ import org.springframework.validation.MessageCodesResolver;
 import org.springframework.validation.Validator;
 import org.springframework.validation.beanvalidation.OptionalValidatorFactoryBean;
 import org.springframework.web.bind.WebDataBinder;
+import org.springframework.web.bind.annotation.WebAnnotationsRuntimeHintsRegistrar;
 import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
 import org.springframework.web.cors.CorsConfiguration;
 import org.springframework.web.reactive.DispatcherHandler;
@@ -83,6 +85,7 @@ import org.springframework.web.server.i18n.LocaleContextResolver;
  * @author Brian Clozel
  * @since 5.0
  */
+@ImportRuntimeHints(WebAnnotationsRuntimeHintsRegistrar.class)
 public class WebFluxConfigurationSupport implements ApplicationContextAware {
 
 	@Nullable

spring-webmvc/src/main/java/org/springframework/web/servlet/config/annotation/WebMvcConfigurationSupport.java

@@ -32,6 +32,7 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.ImportRuntimeHints;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.core.SpringProperties;
 import org.springframework.core.convert.converter.Converter;
@@ -70,6 +71,7 @@ import org.springframework.validation.beanvalidation.OptionalValidatorFactoryBea
 import org.springframework.web.HttpRequestHandler;
 import org.springframework.web.accept.ContentNegotiationManager;
 import org.springframework.web.bind.WebDataBinder;
+import org.springframework.web.bind.annotation.WebAnnotationsRuntimeHintsRegistrar;
 import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
 import org.springframework.web.context.ServletContextAware;
 import org.springframework.web.cors.CorsConfiguration;
@@ -188,6 +190,7 @@ import org.springframework.web.util.pattern.PathPatternParser;
  * @see EnableWebMvc
  * @see WebMvcConfigurer
  */
+@ImportRuntimeHints(WebAnnotationsRuntimeHintsRegistrar.class)
 public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
 
 	/**