diff --git a/spring-web/spring-web.gradle b/spring-web/spring-web.gradle index aeb1989c38..e0652e5253 100644 --- a/spring-web/spring-web.gradle +++ b/spring-web/spring-web.gradle @@ -57,6 +57,7 @@ dependencies { optional("org.jetbrains.kotlinx:kotlinx-serialization-cbor") optional("org.jetbrains.kotlinx:kotlinx-serialization-json") optional("org.jetbrains.kotlinx:kotlinx-serialization-protobuf") + testImplementation(project(":spring-core-test")) testImplementation(testFixtures(project(":spring-beans"))) testImplementation(testFixtures(project(":spring-context"))) testImplementation(testFixtures(project(":spring-core"))) diff --git a/spring-web/src/main/java/org/springframework/web/service/annotation/HttpExchangeBeanRegistrationAotProcessor.java b/spring-web/src/main/java/org/springframework/web/service/annotation/HttpExchangeBeanRegistrationAotProcessor.java new file mode 100644 index 0000000000..f875b51872 --- /dev/null +++ b/spring-web/src/main/java/org/springframework/web/service/annotation/HttpExchangeBeanRegistrationAotProcessor.java @@ -0,0 +1,78 @@ +/* + * 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.service.annotation; + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.aop.framework.AopProxyUtils; +import org.springframework.aot.generate.GenerationContext; +import org.springframework.aot.hint.ProxyHints; +import org.springframework.beans.factory.aot.BeanRegistrationAotContribution; +import org.springframework.beans.factory.aot.BeanRegistrationAotProcessor; +import org.springframework.beans.factory.aot.BeanRegistrationCode; +import org.springframework.beans.factory.support.RegisteredBean; +import org.springframework.core.annotation.MergedAnnotations; +import org.springframework.util.ClassUtils; +import org.springframework.util.ReflectionUtils; + +/** + * AOT {@code BeanRegistrationAotProcessor} that detects the presence of + * {@link HttpExchange @HttpExchange} on methods and creates + * the required proxy hints. + * + * @author Sebastien Deleuze + * @since 6.0 + */ +class HttpExchangeBeanRegistrationAotProcessor implements BeanRegistrationAotProcessor { + + @Override + public BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registeredBean) { + Class beanClass = registeredBean.getBeanClass(); + List> exchangeInterfaces = new ArrayList<>(); + for (Class interfaceClass : ClassUtils.getAllInterfacesForClass(beanClass)) { + ReflectionUtils.doWithMethods(interfaceClass, method -> { + if (!exchangeInterfaces.contains(interfaceClass) && + MergedAnnotations.from(method, MergedAnnotations.SearchStrategy.TYPE_HIERARCHY) + .get(HttpExchange.class).isPresent()) { + exchangeInterfaces.add(interfaceClass); + } + }); + } + if (!exchangeInterfaces.isEmpty()) { + return new HttpExchangeBeanRegistrationAotContribution(exchangeInterfaces); + } + return null; + } + + private static class HttpExchangeBeanRegistrationAotContribution implements BeanRegistrationAotContribution { + + private final List> httpExchangeInterfaces; + + public HttpExchangeBeanRegistrationAotContribution(List> httpExchangeInterfaces) { + this.httpExchangeInterfaces = httpExchangeInterfaces; + } + + @Override + public void applyTo(GenerationContext generationContext, BeanRegistrationCode beanRegistrationCode) { + ProxyHints proxyHints = generationContext.getRuntimeHints().proxies(); + for (Class httpExchangeInterface : this.httpExchangeInterfaces) { + proxyHints.registerJdkProxy(AopProxyUtils.completeJdkProxyInterfaces(httpExchangeInterface)); + } + } + } +} diff --git a/spring-web/src/main/resources/META-INF/spring/aot.factories b/spring-web/src/main/resources/META-INF/spring/aot.factories index dc9f0635ae..33e9f3e504 100644 --- a/spring-web/src/main/resources/META-INF/spring/aot.factories +++ b/spring-web/src/main/resources/META-INF/spring/aot.factories @@ -2,4 +2,7 @@ org.springframework.aot.hint.RuntimeHintsRegistrar= \ org.springframework.http.HttpMimeTypesRuntimeHints,\ org.springframework.http.codec.CodecConfigurerRuntimeHints,\ org.springframework.http.converter.json.JacksonModulesRuntimeHints,\ -org.springframework.web.util.WebUtilRuntimeHints \ No newline at end of file +org.springframework.web.util.WebUtilRuntimeHints + +org.springframework.beans.factory.aot.BeanRegistrationAotProcessor=\ +org.springframework.web.service.annotation.HttpExchangeBeanRegistrationAotProcessor \ No newline at end of file diff --git a/spring-web/src/test/java/org/springframework/web/service/annotation/HttpExchangeBeanRegistrationAotProcessorTests.java b/spring-web/src/test/java/org/springframework/web/service/annotation/HttpExchangeBeanRegistrationAotProcessorTests.java new file mode 100644 index 0000000000..43c05c1382 --- /dev/null +++ b/spring-web/src/test/java/org/springframework/web/service/annotation/HttpExchangeBeanRegistrationAotProcessorTests.java @@ -0,0 +1,86 @@ +/* + * 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.service.annotation; + +import org.junit.jupiter.api.Test; + +import org.springframework.aop.SpringProxy; +import org.springframework.aop.framework.Advised; +import org.springframework.aot.generate.GenerationContext; +import org.springframework.aot.hint.predicate.RuntimeHintsPredicates; +import org.springframework.aot.test.generate.TestGenerationContext; +import org.springframework.beans.factory.aot.BeanRegistrationAotContribution; +import org.springframework.beans.factory.aot.BeanRegistrationCode; +import org.springframework.beans.factory.support.DefaultListableBeanFactory; +import org.springframework.beans.factory.support.RegisteredBean; +import org.springframework.beans.factory.support.RootBeanDefinition; +import org.springframework.core.DecoratingProxy; +import org.springframework.lang.Nullable; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; + +/** + * Tests for {@link HttpExchangeBeanRegistrationAotProcessor}. + * + * @author Sebastien Deleuze + */ +class HttpExchangeBeanRegistrationAotProcessorTests { + + private final HttpExchangeBeanRegistrationAotProcessor processor = new HttpExchangeBeanRegistrationAotProcessor(); + + private final GenerationContext generationContext = new TestGenerationContext(); + + @Test + void shouldSkipNonAnnotatedInterface() { + process(NonAnnotatedInterface.class); + assertThat(this.generationContext.getRuntimeHints().proxies().jdkProxyHints()).isEmpty(); + } + + @Test + void shouldProcessAnnotatedInterface() { + process(AnnotatedInterface.class); + assertThat(RuntimeHintsPredicates.proxies().forInterfaces(AnnotatedInterface.class, SpringProxy.class, Advised.class, + DecoratingProxy.class)).accepts(this.generationContext.getRuntimeHints()); + } + + private void process(Class beanClass) { + BeanRegistrationAotContribution contribution = createContribution(beanClass); + if (contribution != null) { + contribution.applyTo(this.generationContext, mock(BeanRegistrationCode.class)); + } + } + + @Nullable + private BeanRegistrationAotContribution createContribution(Class beanClass) { + DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); + beanFactory.registerBeanDefinition(beanClass.getName(), new RootBeanDefinition(beanClass)); + return this.processor.processAheadOfTime(RegisteredBean.of(beanFactory, beanClass.getName())); + } + + interface NonAnnotatedInterface { + + void notExchange(); + } + + interface AnnotatedInterface { + + @GetExchange + void get(); + } + +}