Add native support for RSocketExchange.

This commit introduces new AOT processors that look for
`@RSocketExchange` annotated methods on interfaces implemented by beans
and registers reachability metadata accordingly:

* JDK proxies for the beans themselves
* invocation reflection for annotated methods
* binding reflection for arguments and return types

This allows to compile such clients to Native Images.

Closes gh-29877
This commit is contained in:
Olga Maciaszek-Sharma
2023-01-23 18:29:25 +01:00
committed by Brian Clozel
parent 06fd6ecf1f
commit 4beb05ddb3
7 changed files with 404 additions and 0 deletions

View File

@@ -0,0 +1,95 @@
/*
* Copyright 2002-2023 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.rsocket.service;
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 org.springframework.messaging.handler.annotation.Payload;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
* Tests for {@link RSocketExchangeBeanRegistrationAotProcessor}.
*
* @author Sebastien Deleuze
* @author Olga Maciaszek-Sharma
*/
class RSocketExchangeBeanRegistrationAotProcessorTests {
private final RSocketExchangeBeanRegistrationAotProcessor processor =
new RSocketExchangeBeanRegistrationAotProcessor();
private final GenerationContext generationContext = new TestGenerationContext();
@Test
void shouldProcessesAnnotatedInterface() {
process(AnnotatedInterface.class);
assertThat(RuntimeHintsPredicates.proxies().forInterfaces(AnnotatedInterface.class,
SpringProxy.class, Advised.class, DecoratingProxy.class))
.accepts(this.generationContext.getRuntimeHints());
}
@Test
void shouldSkipNonAnnotatedInterface() {
process(NonAnnotatedInterface.class);
assertThat(this.generationContext.getRuntimeHints().proxies().jdkProxyHints()).isEmpty();
}
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 {
@RSocketExchange
void exchange(@Payload String testPayload);
}
}

View File

@@ -0,0 +1,151 @@
/*
* Copyright 2002-2023 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.rsocket.service;
import java.lang.reflect.Method;
import org.junit.jupiter.api.Test;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.predicate.RuntimeHintsPredicates;
import org.springframework.messaging.handler.annotation.DestinationVariable;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.util.MimeType;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link RSocketExchangeReflectiveProcessor}.
*
* @author Sebastien Deleuze
* @author Olga Maciaszek-Sharma
*/
class RSocketExchangeReflectiveProcessorTests {
private final RSocketExchangeReflectiveProcessor processor = new RSocketExchangeReflectiveProcessor();
private final RuntimeHints hints = new RuntimeHints();
@Test
void shouldRegisterReflectionHintsForMethod() throws NoSuchMethodException {
Method method = SampleService.class.getDeclaredMethod("get", Request.class, Variable.class,
Metadata.class, MimeType.class);
processor.registerReflectionHints(hints.reflection(), method);
assertThat(RuntimeHintsPredicates.reflection().onType(SampleService.class))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(SampleService.class, "get"))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onType(Response.class))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(Response.class, "getMessage"))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(Response.class, "setMessage"))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onType(Request.class))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(Request.class, "getMessage"))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(Request.class, "setMessage"))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onType(Variable.class))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(Variable.class, "getValue"))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(Variable.class, "setValue"))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onType(Metadata.class))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(Metadata.class, "getValue"))
.accepts(hints);
assertThat(RuntimeHintsPredicates.reflection().onMethod(Metadata.class, "setValue"))
.accepts(hints);
}
interface SampleService {
@RSocketExchange
Response get(@Payload Request request, @DestinationVariable Variable variable,
Metadata metadata, MimeType mimeType);
}
static class Request {
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
static class Response {
private String message;
public Response(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
static class Variable {
private String value;
public Variable(String value) {
this.value = value;
}
public void setValue(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}
static class Metadata {
private String value;
public Metadata(String value) {
this.value = value;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
}