Rely on the RSocket FrameType header

* After introduction an `rsocketFrameType` header in the message,
we don't need a custom `IntegrationRSocket` any more.
Fully rely on the `MessagingRSocket` from the Spring Messaging, only
handle properly a `RSocketFrameTypeMessageCondition.CONNECT_CONDITION`
for connections from clients to emit an `RSocketConnectedEvent`
* Copy a `ChannelSendOperator` from the Spring Messaging for the proper
reply handling, when we are interested in the source `Publisher`
subscription first.
See its JavaDocs for more info
* Reusing already `public PayloadUtils` instead of its method copies

Author: artembilan

spring-integration-rsocket/src/main/java/org/springframework/integration/rsocket/AbstractRSocketConnector.java

@@ -53,7 +53,7 @@ public abstract class AbstractRSocketConnector
 
 	private MimeType dataMimeType = MimeTypeUtils.TEXT_PLAIN;
 
-	private MimeType metadataMimeType = IntegrationRSocket.COMPOSITE_METADATA;
+	private MimeType metadataMimeType = new MimeType("message", "x.rsocket.composite-metadata.v0");
 
 	private RSocketStrategies rsocketStrategies =
 			RSocketStrategies.builder()

spring-integration-rsocket/src/main/java/org/springframework/integration/rsocket/IntegrationRSocket.java

@@ -19,30 +19,18 @@
 import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.List;
-import java.util.function.BiFunction;
 
 import org.springframework.context.ApplicationContext;
 import org.springframework.core.MethodParameter;
-import org.springframework.lang.Nullable;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.ReactiveMessageHandler;
 import org.springframework.messaging.handler.CompositeMessageCondition;
 import org.springframework.messaging.handler.DestinationPatternsMessageCondition;
 import org.springframework.messaging.handler.invocation.reactive.HandlerMethodArgumentResolver;
 import org.springframework.messaging.handler.invocation.reactive.SyncHandlerMethodArgumentResolver;
-import org.springframework.messaging.rsocket.RSocketRequester;
-import org.springframework.messaging.rsocket.RSocketStrategies;
-import org.springframework.messaging.rsocket.annotation.support.DefaultMetadataExtractor;
-import org.springframework.messaging.rsocket.annotation.support.MetadataExtractor;
+import org.springframework.messaging.rsocket.annotation.support.RSocketFrameTypeMessageCondition;
 import org.springframework.messaging.rsocket.annotation.support.RSocketMessageHandler;
-import org.springframework.util.Assert;
-import org.springframework.util.MimeType;
-import org.springframework.util.MimeTypeUtils;
 import org.springframework.util.ReflectionUtils;
-import org.springframework.util.StringUtils;
-
-import io.rsocket.ConnectionSetupPayload;
-import io.rsocket.RSocket;
 
 /**
  * The {@link RSocketMessageHandler} extension for Spring Integration needs.
@@ -60,63 +48,10 @@ class IntegrationRSocketMessageHandler extends RSocketMessageHandler {
 	private static final Method HANDLE_MESSAGE_METHOD =
 			ReflectionUtils.findMethod(ReactiveMessageHandler.class, "handleMessage", Message.class);
 
-	@Nullable
-	private MimeType defaultDataMimeType;
-
-	private MimeType defaultMetadataMimeType = IntegrationRSocket.COMPOSITE_METADATA;
-
-	private MetadataExtractor metadataExtractor;
-
 	IntegrationRSocketMessageHandler() {
 		setHandlerPredicate((clazz) -> false);
 	}
 
-	/**
-	 * Configure the default content type to use for data payloads.
-	 * <p>By default this is not set. However a server acceptor will use the
-	 * content type from the {@link io.rsocket.ConnectionSetupPayload}, so this is typically
-	 * required for clients but can also be used on servers as a fallback.
-	 * @param defaultDataMimeType the MimeType to use
-	 */
-	@Override
-	public void setDefaultDataMimeType(@Nullable MimeType defaultDataMimeType) {
-		super.setDefaultDataMimeType(defaultDataMimeType);
-		this.defaultDataMimeType = defaultDataMimeType;
-	}
-
-
-	/**
-	 * Configure the default {@code MimeType} for payload data if the
-	 * {@code SETUP} frame did not specify one.
-	 * <p>By default this is set to {@code "message/x.rsocket.composite-metadata.v0"}
-	 * @param mimeType the MimeType to use
-	 */
-	@Override
-	public void setDefaultMetadataMimeType(MimeType mimeType) {
-		super.setDefaultMetadataMimeType(mimeType);
-		this.defaultMetadataMimeType = mimeType;
-	}
-
-	/**
-	 * Configure a {@link MetadataExtractor} to extract the route and possibly
-	 * other metadata from the first payload of incoming requests.
-	 * <p>By default this is a {@link DefaultMetadataExtractor} with the
-	 * configured {@link RSocketStrategies} (and decoders), extracting a route
-	 * from {@code "message/x.rsocket.routing.v0"} or {@code "text/plain"}
-	 * metadata entries.
-	 * @param extractor the extractor to use
-	 */
-	@Override
-	public void setMetadataExtractor(MetadataExtractor extractor) {
-		super.setMetadataExtractor(extractor);
-		this.metadataExtractor = extractor;
-	}
-
-	@Override
-	public BiFunction<ConnectionSetupPayload, RSocket, RSocket> clientAcceptor() {
-		return this::createRSocket;
-	}
-
 	public boolean detectEndpoints() {
 		ApplicationContext applicationContext = getApplicationContext();
 		if (applicationContext != null && getHandlerMethods().isEmpty()) {
@@ -135,6 +70,7 @@ public boolean detectEndpoints() {
 	public void addEndpoint(IntegrationRSocketEndpoint endpoint) {
 		registerHandlerMethod(endpoint, HANDLE_MESSAGE_METHOD,
 				new CompositeMessageCondition(
+						RSocketFrameTypeMessageCondition.REQUEST_CONDITION,
 						new DestinationPatternsMessageCondition(endpoint.getPath(), getRouteMatcher())));
 	}
 
@@ -143,36 +79,6 @@ protected List<? extends HandlerMethodArgumentResolver> initArgumentResolvers()
 		return Collections.singletonList(new MessageHandlerMethodArgumentResolver());
 	}
 
-	@Override
-	public void afterPropertiesSet() {
-		super.afterPropertiesSet();
-		if (this.metadataExtractor == null) {
-			DefaultMetadataExtractor extractor = new DefaultMetadataExtractor(getRSocketStrategies()); // NOSONAR
-			extractor.metadataToExtract(MimeTypeUtils.TEXT_PLAIN, String.class, MetadataExtractor.ROUTE_KEY);
-			this.metadataExtractor = extractor;
-		}
-	}
-
-	protected IntegrationRSocket createRSocket(ConnectionSetupPayload setupPayload, RSocket rsocket) {
-		String mimeType = setupPayload.dataMimeType();
-		MimeType dataMimeType =
-				StringUtils.hasText(mimeType)
-						? MimeTypeUtils.parseMimeType(mimeType)
-						: this.defaultDataMimeType;
-		Assert.notNull(dataMimeType, "No `dataMimeType` in ConnectionSetupPayload and no default value");
-		mimeType = setupPayload.metadataMimeType();
-		MimeType metaMimeType =
-				StringUtils.hasText(mimeType)
-						? MimeTypeUtils.parseMimeType(mimeType)
-						: this.defaultMetadataMimeType;
-		Assert.notNull(dataMimeType, "No `metadataMimeType` in ConnectionSetupPayload and no default value");
-		RSocketStrategies rSocketStrategies = getRSocketStrategies();
-		Assert.notNull(rSocketStrategies, "No `rSocketStrategies` provided");
-		RSocketRequester requester = RSocketRequester.wrap(rsocket, dataMimeType, metaMimeType, rSocketStrategies);
-		return new IntegrationRSocket(this, getRouteMatcher(), requester, dataMimeType, metaMimeType,
-				this.metadataExtractor, rSocketStrategies.dataBufferFactory());
-	}
-
 	private static final class MessageHandlerMethodArgumentResolver implements SyncHandlerMethodArgumentResolver {
 
 		@Override