From c6bcf79c0e4a79a4632e9366514223180a195160 Mon Sep 17 00:00:00 2001 From: Stephane Nicoll Date: Tue, 23 Aug 2022 14:22:36 +0200 Subject: [PATCH] Add hint for use of Qualifier in meta-annotations Closes gh-29000 --- .../BeanFactoryAnnotationsRuntimeHints.java | 36 +++++++++++++++++++ .../resources/META-INF/spring/aot.factories | 3 ++ .../ApplicationContextAotGeneratorTests.java | 19 +++++++--- 3 files changed, 54 insertions(+), 4 deletions(-) create mode 100644 spring-beans/src/main/java/org/springframework/beans/factory/annotation/BeanFactoryAnnotationsRuntimeHints.java diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/annotation/BeanFactoryAnnotationsRuntimeHints.java b/spring-beans/src/main/java/org/springframework/beans/factory/annotation/BeanFactoryAnnotationsRuntimeHints.java new file mode 100644 index 000000000000..f7cf4c4c296e --- /dev/null +++ b/spring-beans/src/main/java/org/springframework/beans/factory/annotation/BeanFactoryAnnotationsRuntimeHints.java @@ -0,0 +1,36 @@ +/* + * 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 + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + RuntimeHintsUtils.registerSynthesizedAnnotation(hints, Qualifier.class); + } +} diff --git a/spring-beans/src/main/resources/META-INF/spring/aot.factories b/spring-beans/src/main/resources/META-INF/spring/aot.factories index b95137025d8a..b96644577c17 100644 --- a/spring-beans/src/main/resources/META-INF/spring/aot.factories +++ b/spring-beans/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,5 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.springframework.beans.factory.annotation.BeanFactoryAnnotationsRuntimeHints + org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor=\ org.springframework.beans.factory.aot.BeanRegistrationsAotProcessor diff --git a/spring-context/src/test/java/org/springframework/context/aot/ApplicationContextAotGeneratorTests.java b/spring-context/src/test/java/org/springframework/context/aot/ApplicationContextAotGeneratorTests.java index 1a8ab04b3aa4..ace1f8fac6b5 100644 --- a/spring-context/src/test/java/org/springframework/context/aot/ApplicationContextAotGeneratorTests.java +++ b/spring-context/src/test/java/org/springframework/context/aot/ApplicationContextAotGeneratorTests.java @@ -18,12 +18,15 @@ import java.io.IOException; import java.lang.reflect.Proxy; +import java.util.List; import java.util.function.BiConsumer; +import java.util.function.Consumer; import org.junit.jupiter.api.Test; import org.springframework.aot.generate.GeneratedFiles.Kind; import org.springframework.aot.generate.GenerationContext; +import org.springframework.aot.hint.JdkProxyHint; import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.TypeReference; @@ -111,7 +114,8 @@ void processAheadOfTimeWhenHasLazyAutowiringOnField() { ResourceLoader resourceLoader = bean.getResourceLoader(); assertThat(resourceLoader).isNotInstanceOf(Proxy.class); RuntimeHints runtimeHints = generationContext.getRuntimeHints(); - assertThat(runtimeHints.proxies().jdkProxies()).singleElement().satisfies(proxyHint -> + assertThat(runtimeHints.proxies().jdkProxies()).satisfies(doesNotHaveProxyFor(ResourceLoader.class)); + assertThat(runtimeHints.proxies().jdkProxies()).anySatisfy(proxyHint -> assertThat(proxyHint.getProxiedInterfaces()).isEqualTo(TypeReference.listOf( environment.getClass().getInterfaces()))); @@ -126,7 +130,8 @@ void processAheadOfTimeWhenHasLazyAutowiringOnMethod() { ResourceLoader resourceLoader = bean.getResourceLoader(); assertThat(resourceLoader).isInstanceOf(Proxy.class); RuntimeHints runtimeHints = generationContext.getRuntimeHints(); - assertThat(runtimeHints.proxies().jdkProxies()).singleElement().satisfies(proxyHint -> + assertThat(runtimeHints.proxies().jdkProxies()).satisfies(doesNotHaveProxyFor(Environment.class)); + assertThat(runtimeHints.proxies().jdkProxies()).anySatisfy(proxyHint -> assertThat(proxyHint.getProxiedInterfaces()).isEqualTo(TypeReference.listOf( resourceLoader.getClass().getInterfaces()))); }); @@ -140,7 +145,8 @@ void processAheadOfTimeWhenHasLazyAutowiringOnConstructor() { ResourceLoader resourceLoader = bean.getResourceLoader(); assertThat(resourceLoader).isNotInstanceOf(Proxy.class); RuntimeHints runtimeHints = generationContext.getRuntimeHints(); - assertThat(runtimeHints.proxies().jdkProxies()).singleElement().satisfies(proxyHint -> + assertThat(runtimeHints.proxies().jdkProxies()).satisfies(doesNotHaveProxyFor(ResourceLoader.class)); + assertThat(runtimeHints.proxies().jdkProxies()).anySatisfy(proxyHint -> assertThat(proxyHint.getProxiedInterfaces()).isEqualTo(TypeReference.listOf( environment.getClass().getInterfaces()))); }); @@ -156,7 +162,8 @@ void processAheadOfTimeWhenHasLazyAutowiringOnFactoryMethod() { ResourceLoader resourceLoader = bean.getResourceLoader(); assertThat(resourceLoader).isNotInstanceOf(Proxy.class); RuntimeHints runtimeHints = generationContext.getRuntimeHints(); - assertThat(runtimeHints.proxies().jdkProxies()).singleElement().satisfies(proxyHint -> + assertThat(runtimeHints.proxies().jdkProxies()).satisfies(doesNotHaveProxyFor(ResourceLoader.class)); + assertThat(runtimeHints.proxies().jdkProxies()).anySatisfy(proxyHint -> assertThat(proxyHint.getProxiedInterfaces()).isEqualTo(TypeReference.listOf( environment.getClass().getInterfaces()))); }); @@ -272,6 +279,10 @@ void processAheadOfTimeWhenHasCglibProxyWriteProxyAndGenerateReflectionHints() t .withMemberCategory(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS)).accepts(context.getRuntimeHints()); } + private Consumer> doesNotHaveProxyFor(Class target) { + return hints -> assertThat(hints).noneMatch(hint -> hint.getProxiedInterfaces().get(0).equals(target)); + } + private static TestGenerationContext processAheadOfTime(GenericApplicationContext applicationContext) { ApplicationContextAotGenerator generator = new ApplicationContextAotGenerator(); TestGenerationContext generationContext = new TestGenerationContext();