public class RSocketMessageHandler extends MessageMappingMessageHandler
MessageMappingMessageHandler for handling RSocket
requests with @ConnectMapping and
@MessageMapping methods.
For server scenarios this class can be declared as a bean in Spring
configuration and that would detect @MessageMapping methods in
@Controller beans. What beans are checked can be changed through a
handlerPredicate. Given an instance
of this class, you can then use responder() to obtain a
SocketAcceptor adapter to register with the
RSocketServer.
For a client, possibly in the same process as a server, consider using the
static factory method responder(RSocketStrategies, Object...) to
obtain a client responder to be registered via
RSocketRequester.Builder.
For @MessageMapping methods, this class automatically determines
the RSocket interaction type based on the input and output cardinality of the
method. See the
"Annotated Responders" section of the Spring Framework reference for more details.
logger| Constructor and Description |
|---|
RSocketMessageHandler() |
| Modifier and Type | Method and Description |
|---|---|
void |
afterPropertiesSet()
Invoked by the containing
BeanFactory after it has set all bean properties
and satisfied BeanFactoryAware, ApplicationContextAware etc. |
protected CompositeMessageCondition |
extendMapping(CompositeMessageCondition composite,
HandlerMethod handler)
This method is invoked just before mappings are added.
|
protected CompositeMessageCondition |
getCondition(AnnotatedElement element)
Determine the mapping condition for the given annotated element.
|
MimeType |
getDefaultDataMimeType()
Return the configured
defaultDataMimeType, or null. |
MimeType |
getDefaultMetadataMimeType()
Return the configured
defaultMetadataMimeType. |
List<? extends Encoder<?>> |
getEncoders()
Return the configured
encoders. |
MetadataExtractor |
getMetadataExtractor()
Return the configured
MetadataExtractor. |
RSocketStrategies |
getRSocketStrategies()
Return the
configured RSocketStrategies. |
protected void |
handleNoMatch(RouteMatcher.Route destination,
Message<?> message)
Invoked when no matching handler is found.
|
protected List<? extends HandlerMethodReturnValueHandler> |
initReturnValueHandlers()
Return the list of return value handlers to use.
|
io.rsocket.SocketAcceptor |
responder()
Return an RSocket
SocketAcceptor backed by this
RSocketMessageHandler instance that can be plugged in as a
client or
server
RSocket responder. |
static io.rsocket.SocketAcceptor |
responder(RSocketStrategies strategies,
Object... candidateHandlers)
Static factory method to create an RSocket
SocketAcceptor
backed by handlers with annotated methods. |
void |
setDecoders(List<? extends Decoder<?>> decoders)
Configure the decoders to use for incoming payloads.
|
void |
setDefaultDataMimeType(MimeType mimeType)
Configure the default content type to use for data payloads if the
SETUP frame did not specify one. |
void |
setDefaultMetadataMimeType(MimeType mimeType)
Configure the default
MimeType for payload data if the
SETUP frame did not specify one. |
void |
setEncoders(List<? extends Encoder<?>> encoders)
Configure the encoders to use for encoding handler method return values.
|
void |
setMetadataExtractor(MetadataExtractor extractor)
Configure a
MetadataExtractor to extract the route along with
other metadata. |
void |
setReactiveAdapterRegistry(ReactiveAdapterRegistry registry)
Configure the registry for adapting various reactive types.
|
void |
setRouteMatcher(RouteMatcher routeMatcher)
Set the
RouteMatcher to use for mapping messages to handlers
based on the route patterns they're configured with. |
void |
setRSocketStrategies(RSocketStrategies rsocketStrategies)
Configure this handler through an
RSocketStrategies instance which
can be re-used to initialize a client-side RSocketRequester. |
createExceptionMethodResolverFor, getConversionService, getDecoders, getDestination, getDirectLookupMappings, getMappingComparator, getMappingForMethod, getMatchingMapping, getRouteMatcher, getValidator, handleMatch, initArgumentResolvers, obtainRouteMatcher, processDestinations, setConversionService, setEmbeddedValueResolver, setValidatordetectHandlerMethods, getApplicationContext, getArgumentResolverConfigurer, getArgumentResolvers, getBeanName, getDestinationLookup, getHandlerMethods, getHandlerPredicate, getReactiveAdapterRegistry, getReturnValueHandlerConfigurer, handleMessage, registerExceptionHandlerAdvice, registerHandlerMethod, setApplicationContext, setArgumentResolverConfigurer, setBeanName, setHandlerPredicate, setHandlers, setReturnValueHandlerConfigurerpublic void setEncoders(List<? extends Encoder<?>> encoders)
When rsocketStrategies
is set, this property is re-initialized with the encoders in it, and
likewise when this property is set the RSocketStrategies are
mutated to change the encoders in it.
By default this is set to the
defaults
from RSocketStrategies.
public void setDecoders(List<? extends Decoder<?>> decoders)
When rsocketStrategies
is set, this property is re-initialized with the decoders in it, and
likewise when this property is set the RSocketStrategies are
mutated to change the decoders in them.
By default this is set to the
defaults
from RSocketStrategies.
setDecoders in class MessageMappingMessageHandlerpublic void setRouteMatcher(@Nullable RouteMatcher routeMatcher)
RouteMatcher to use for mapping messages to handlers
based on the route patterns they're configured with.
By default, SimpleRouteMatcher is used, backed by
AntPathMatcher with "." as separator. For greater
efficiency consider using the PathPatternRouteMatcher from
spring-web instead.
When rsocketStrategies
is set, this property is re-initialized with the route matcher in it, and
likewise when this property is set the RSocketStrategies are
mutated to change the matcher in it.
By default this is set to the
defaults
from RSocketStrategies.
setRouteMatcher in class MessageMappingMessageHandlerpublic void setReactiveAdapterRegistry(ReactiveAdapterRegistry registry)
When rsocketStrategies
is set, this property is re-initialized with the registry in it, and
likewise when this property is set the RSocketStrategies are
mutated to change the registry in it.
By default this is set to the
defaults
from RSocketStrategies.
setReactiveAdapterRegistry in class AbstractMethodMessageHandler<CompositeMessageCondition>public void setMetadataExtractor(MetadataExtractor extractor)
MetadataExtractor to extract the route along with
other metadata.
When rsocketStrategies
is set, this property is re-initialized with the extractor in it, and
likewise when this property is set the RSocketStrategies are
mutated to change the extractor in it.
By default this is set to the
RSocketStrategies.Builder.metadataExtractor(MetadataExtractor) defaults}
from RSocketStrategies.
extractor - the extractor to usepublic MetadataExtractor getMetadataExtractor()
MetadataExtractor.public void setRSocketStrategies(RSocketStrategies rsocketStrategies)
RSocketStrategies instance which
can be re-used to initialize a client-side RSocketRequester.
When this property is set, in turn it sets the following:
setDecoders(List)
setEncoders(List)
setRouteMatcher(RouteMatcher)
setMetadataExtractor(MetadataExtractor)
setReactiveAdapterRegistry(ReactiveAdapterRegistry)
By default this is set to RSocketStrategies.create() which in
turn sets default settings for all related properties.
public RSocketStrategies getRSocketStrategies()
configured RSocketStrategies.public void setDefaultDataMimeType(@Nullable MimeType mimeType)
SETUP frame did not specify one.
By default this is not set.
mimeType - the MimeType to use@Nullable public MimeType getDefaultDataMimeType()
defaultDataMimeType, or null.public void setDefaultMetadataMimeType(MimeType mimeType)
MimeType for payload data if the
SETUP frame did not specify one.
By default this is set to "message/x.rsocket.composite-metadata.v0"
mimeType - the MimeType to usepublic MimeType getDefaultMetadataMimeType()
defaultMetadataMimeType.public void afterPropertiesSet()
InitializingBeanBeanFactory after it has set all bean properties
and satisfied BeanFactoryAware, ApplicationContextAware etc.
This method allows the bean instance to perform validation of its overall configuration and final initialization when all bean properties have been set.
afterPropertiesSet in interface InitializingBeanafterPropertiesSet in class MessageMappingMessageHandlerprotected List<? extends HandlerMethodReturnValueHandler> initReturnValueHandlers()
AbstractMethodMessageHandlerSubclasses should also take into account custom return value types configured
via AbstractMethodMessageHandler.setReturnValueHandlerConfigurer(org.springframework.messaging.handler.invocation.reactive.ReturnValueHandlerConfigurer).
initReturnValueHandlers in class MessageMappingMessageHandler@Nullable protected CompositeMessageCondition getCondition(AnnotatedElement element)
MessageMappingMessageHandlergetCondition in class MessageMappingMessageHandlerelement - the element to checknullprotected CompositeMessageCondition extendMapping(CompositeMessageCondition composite, HandlerMethod handler)
AbstractMethodMessageHandlerHandlerMethod in mind.
This can be useful when the method signature is used to refine the
mapping, e.g. based on the cardinality of input and output.
By default this method returns the mapping that is passed in.
extendMapping in class AbstractMethodMessageHandler<CompositeMessageCondition>composite - the mapping to be addedhandler - the target handler for the mappingprotected void handleNoMatch(@Nullable RouteMatcher.Route destination, Message<?> message)
AbstractMethodMessageHandlerhandleNoMatch in class AbstractMethodMessageHandler<CompositeMessageCondition>destination - the destinationmessage - the messagepublic io.rsocket.SocketAcceptor responder()
SocketAcceptor backed by this
RSocketMessageHandler instance that can be plugged in as a
client or
server
RSocket responder.
The initial ConnectionSetupPayload is handled through
@ConnectionMapping methods that can be asynchronous
and return Mono<Void> with an error signal preventing the
connection. Such a method can also start requests to the client but that
must be done decoupled from handling and from the current thread.
Subsequent requests on the connection can be handled with
MessageMapping methods.
public static io.rsocket.SocketAcceptor responder(RSocketStrategies strategies, Object... candidateHandlers)
SocketAcceptor
backed by handlers with annotated methods. Effectively a shortcut for:
RSocketMessageHandler handler = new RSocketMessageHandler(); handler.setHandlers(handlers); handler.setRSocketStrategies(strategies); handler.afterPropertiesSet(); SocketAcceptor acceptor = handler.responder();
This is intended for programmatic creation and registration of a client-side responder. For example:
SocketAcceptor responder =
RSocketMessageHandler.responder(strategies, new ClientHandler());
RSocketRequester.builder()
.rsocketConnector(connector -> connector.acceptor(responder))
.connectTcp("localhost", server.address().getPort());
Note that the given handlers do not need to have any stereotype
annotations such as @Controller which helps to avoid overlap with
server side handlers that may be used in the same application. However,
for more advanced scenarios, e.g. discovering handlers through a custom
stereotype annotation, consider declaring RSocketMessageHandler
as a bean, and then obtain the responder from it.
strategies - the strategies to set on the created
RSocketMessageHandlercandidateHandlers - a list of Objects and/or Classes with annotated
handler methods; used to call AbstractMethodMessageHandler.setHandlers(List) with
on the created RSocketMessageHandlerRSocketRequester.Builder.rsocketConnector(org.springframework.messaging.rsocket.RSocketConnectorConfigurer)