Updates to RSocket[Strategies|Requester] defaults

1. RSocketStrategies hooks in the basic codecs from spring-core by
default. Now that we have support for composite metadata, it makes
sense to have multiple codecs available.

2. RSocketStrategies is pre-configured with NettyDataBufferFactory.

3. DefaultRSocketRequesterBuilder configures RSocket with a frame
decoder that matches the DataBufferFactory choice, i.e. ensuring
consistency of zero copy vs default (copy) choice.

4. DefaultRSocketRequesterBuilder now tries to find a single non-basic
decoder to select a default data MimeType (e.g. CBOR), or otherwise
fall back on the first default decoder (e.g. String).

See gh-23314

Author: rstoyanchev

spring-messaging/src/main/java/org/springframework/messaging/rsocket/DefaultRSocketRequesterBuilder.java

@@ -18,9 +18,9 @@
 
 import java.net.URI;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.Consumer;
-import java.util.stream.Stream;
 
 import io.rsocket.RSocketFactory;
 import io.rsocket.frame.decoder.PayloadDecoder;
@@ -29,6 +29,9 @@
 import io.rsocket.transport.netty.client.WebsocketClientTransport;
 import reactor.core.publisher.Mono;
 
+import org.springframework.core.codec.Decoder;
+import org.springframework.core.codec.StringDecoder;
+import org.springframework.core.io.buffer.NettyDataBufferFactory;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.MimeType;
@@ -110,7 +113,10 @@ private Mono<RSocketRequester> doConnect(ClientTransport transport) {
 		MimeType dataMimeType = getDataMimeType(rsocketStrategies);
 		rsocketFactory.dataMimeType(dataMimeType.toString());
 		rsocketFactory.metadataMimeType(this.metadataMimeType.toString());
-		rsocketFactory.frameDecoder(PayloadDecoder.ZERO_COPY);
+
+		if (rsocketStrategies.dataBufferFactory() instanceof NettyDataBufferFactory) {
+			rsocketFactory.frameDecoder(PayloadDecoder.ZERO_COPY);
+		}
 
 		this.rsocketFactoryConfigurers.forEach(configurer -> {
 			configurer.configureWithStrategies(rsocketStrategies);
@@ -139,16 +145,35 @@ private MimeType getDataMimeType(RSocketStrategies strategies) {
 		if (this.dataMimeType != null) {
 			return this.dataMimeType;
 		}
-		return Stream
-				.concat(
-						strategies.encoders().stream()
-								.flatMap(encoder -> encoder.getEncodableMimeTypes().stream()),
-						strategies.decoders().stream()
-								.flatMap(encoder -> encoder.getDecodableMimeTypes().stream())
-				)
-				.filter(MimeType::isConcrete)
-				.findFirst()
-				.orElseThrow(() -> new IllegalArgumentException("Failed to select data MimeType to use."));
+		// Look for non-basic Decoder (e.g. CBOR, Protobuf)
+		MimeType selected = null;
+		List<Decoder<?>> decoders = strategies.decoders();
+		for (Decoder<?> candidate : decoders) {
+			if (!isCoreCodec(candidate) && !candidate.getDecodableMimeTypes().isEmpty()) {
+				Assert.state(selected == null,
+						() -> "Cannot select default data MimeType based on configured decoders: " + decoders);
+				selected = getMimeType(candidate);
+			}
+		}
+		if (selected != null) {
+			return selected;
+		}
+		// Fall back on 1st decoder (e.g. String)
+		for (Decoder<?> decoder : decoders) {
+			if (!decoder.getDecodableMimeTypes().isEmpty()) {
+				return getMimeType(decoder);
+			}
+		}
+		throw new IllegalArgumentException("Failed to select data MimeType to use.");
+	}
+
+	private static boolean isCoreCodec(Object codec) {
+		return codec.getClass().getPackage().equals(StringDecoder.class.getPackage());
+	}
+
+	private static MimeType getMimeType(Decoder<?> decoder) {
+		MimeType mimeType = decoder.getDecodableMimeTypes().get(0);
+		return new MimeType(mimeType, Collections.emptyMap());
 	}
 
 }

spring-messaging/src/main/java/org/springframework/messaging/rsocket/DefaultRSocketStrategies.java

@@ -22,11 +22,21 @@
 import java.util.List;
 import java.util.function.Consumer;
 
+import io.netty.buffer.PooledByteBufAllocator;
+
 import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.core.codec.ByteArrayDecoder;
+import org.springframework.core.codec.ByteArrayEncoder;
+import org.springframework.core.codec.ByteBufferDecoder;
+import org.springframework.core.codec.ByteBufferEncoder;
+import org.springframework.core.codec.CharSequenceEncoder;
+import org.springframework.core.codec.DataBufferDecoder;
+import org.springframework.core.codec.DataBufferEncoder;
 import org.springframework.core.codec.Decoder;
 import org.springframework.core.codec.Encoder;
+import org.springframework.core.codec.StringDecoder;
 import org.springframework.core.io.buffer.DataBufferFactory;
-import org.springframework.core.io.buffer.DefaultDataBufferFactory;
+import org.springframework.core.io.buffer.NettyDataBufferFactory;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
@@ -90,18 +100,33 @@ static class DefaultRSocketStrategiesBuilder implements RSocketStrategies.Builde
 		private ReactiveAdapterRegistry adapterRegistry = ReactiveAdapterRegistry.getSharedInstance();
 
 		@Nullable
-		private DataBufferFactory dataBufferFactory;
+		private DataBufferFactory bufferFactory;
+
+
+		DefaultRSocketStrategiesBuilder() {
+
+			// Order of decoders may be significant for default data MimeType
+			// selection in RSocketRequester.Builder
 
-		public DefaultRSocketStrategiesBuilder() {
+			this.decoders.add(StringDecoder.allMimeTypes());
+			this.decoders.add(new ByteBufferDecoder());
+			this.decoders.add(new ByteArrayDecoder());
+			this.decoders.add(new DataBufferDecoder());
+
+			this.encoders.add(CharSequenceEncoder.allMimeTypes());
+			this.encoders.add(new ByteBufferEncoder());
+			this.encoders.add(new ByteArrayEncoder());
+			this.encoders.add(new DataBufferEncoder());
 		}
 
-		public DefaultRSocketStrategiesBuilder(RSocketStrategies other) {
+		DefaultRSocketStrategiesBuilder(RSocketStrategies other) {
 			this.encoders.addAll(other.encoders());
 			this.decoders.addAll(other.decoders());
 			this.adapterRegistry = other.reactiveAdapterRegistry();
-			this.dataBufferFactory = other.dataBufferFactory();
+			this.bufferFactory = other.dataBufferFactory();
 		}
 
+
 		@Override
 		public Builder encoder(Encoder<?>... encoders) {
 			this.encoders.addAll(Arrays.asList(encoders));
@@ -135,14 +160,19 @@ public Builder reactiveAdapterStrategy(ReactiveAdapterRegistry registry) {
 
 		@Override
 		public Builder dataBufferFactory(DataBufferFactory bufferFactory) {
-			this.dataBufferFactory = bufferFactory;
+			this.bufferFactory = bufferFactory;
 			return this;
 		}
 
 		@Override
 		public RSocketStrategies build() {
-			return new DefaultRSocketStrategies(this.encoders, this.decoders, this.adapterRegistry,
-					this.dataBufferFactory != null ? this.dataBufferFactory : new DefaultDataBufferFactory());
+			return new DefaultRSocketStrategies(
+					this.encoders, this.decoders, this.adapterRegistry, initBufferFactory());
+		}
+
+		private DataBufferFactory initBufferFactory() {
+			return this.bufferFactory != null ? this.bufferFactory :
+					new NettyDataBufferFactory(PooledByteBufAllocator.DEFAULT);
 		}
 	}
 

spring-messaging/src/main/java/org/springframework/messaging/rsocket/RSocketRequester.java

@@ -28,6 +28,7 @@
 
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.core.codec.Decoder;
 import org.springframework.lang.Nullable;
 import org.springframework.messaging.rsocket.annotation.support.AnnotationClientResponderConfigurer;
 import org.springframework.util.MimeType;
@@ -125,32 +126,32 @@ static RSocketRequester wrap(
 	interface Builder {
 
 		/**
-		 * Configure the MimeType for payload data which is then specified
-		 * on the {@code SETUP} frame and applies to the whole connection.
-		 * <p>By default this is set to the first concrete mime type supported
-		 * by the configured encoders and decoders.
-		 * @param mimeType the data MimeType to use
+		 * Configure the payload data MimeType to specify on the {@code SETUP}
+		 * frame that applies to the whole connection.
+		 * <p>If this is not set, the builder will try to select the mime type
+		 * based on the presence of a single
+		 * {@link RSocketStrategies.Builder#decoder(Decoder[])  non-default}
+		 * {@code Decoder}, or the first default decoder otherwise
+		 * (i.e. {@code String}) if no others are configured.
 		 */
 		RSocketRequester.Builder dataMimeType(@Nullable MimeType mimeType);
 
 		/**
-		 * Configure the MimeType for payload metadata which is then specified
-		 * on the {@code SETUP} frame and applies to the whole connection.
+		 * Configure the payload metadata MimeType to specify on the {@code SETUP}
+		 * frame and applies to the whole connection.
 		 * <p>By default this is set to
 		 * {@code "message/x.rsocket.composite-metadata.v0"} in which case the
 		 * route, if provided, is encoded as a
-		 * {@code "message/x.rsocket.routing.v0"} metadata entry, potentially
-		 * with other metadata entries added too. If this is set to any other
-		 * mime type, and a route is provided, it is assumed the mime type is
-		 * for the route.
-		 * @param mimeType the data MimeType to use
+		 * {@code "message/x.rsocket.routing.v0"} composite metadata entry.
+		 * For any other MimeType, it is assumed to be the MimeType for the
+		 * route, if provided.
 		 */
 		RSocketRequester.Builder metadataMimeType(MimeType mimeType);
 
 		/**
-		 * Set the {@link RSocketStrategies} to use for access to encoders,
-		 * decoders, and a factory for {@code DataBuffer's}.
-		 * @param strategies the codecs strategies to use
+		 * Set the {@link RSocketStrategies} to use.
+		 * <p>By default this is set to {@code RSocketStrategies.builder().build()}
+		 * but may be further customized via {@link #rsocketStrategies(Consumer)}.
 		 */
 		RSocketRequester.Builder rsocketStrategies(@Nullable RSocketStrategies strategies);
 
@@ -159,7 +160,6 @@ interface Builder {
 		 * <p>By default this starts out with an empty builder, i.e.
 		 * {@link RSocketStrategies#builder()}, but the strategies can also be
 		 * set via {@link #rsocketStrategies(RSocketStrategies)}.
-		 * @param configurer the configurer to apply
 		 */
 		RSocketRequester.Builder rsocketStrategies(Consumer<RSocketStrategies.Builder> configurer);
 
@@ -172,7 +172,6 @@ interface Builder {
 		 * {@code ClientRSocketFactory}. Use the shortcuts on this builder
 		 * instead since the created {@code RSocketRequester} needs to be aware
 		 * of those settings.
-		 * @param configurer consumer to customize the factory
 		 * @see AnnotationClientResponderConfigurer
 		 */
 		RSocketRequester.Builder rsocketFactory(ClientRSocketFactoryConfigurer configurer);

spring-messaging/src/main/java/org/springframework/messaging/rsocket/RSocketStrategies.java

@@ -19,13 +19,17 @@
 import java.util.List;
 import java.util.function.Consumer;
 
-import io.netty.buffer.PooledByteBufAllocator;
+import io.rsocket.Payload;
+import io.rsocket.RSocketFactory.ClientRSocketFactory;
+import io.rsocket.RSocketFactory.ServerRSocketFactory;
 
 import org.springframework.core.ReactiveAdapterRegistry;
 import org.springframework.core.ResolvableType;
 import org.springframework.core.codec.Decoder;
 import org.springframework.core.codec.Encoder;
 import org.springframework.core.io.buffer.DataBufferFactory;
+import org.springframework.core.io.buffer.DefaultDataBufferFactory;
+import org.springframework.core.io.buffer.NettyDataBufferFactory;
 import org.springframework.lang.Nullable;
 import org.springframework.util.MimeType;
 
@@ -120,24 +124,28 @@ default Builder mutate() {
 	interface Builder {
 
 		/**
-		 * Add encoders to use for serializing Objects.
-		 * <p>By default this is empty.
+		 * Append to the list of encoders to use for serializing Objects to the
+		 * data or metadata of a {@link Payload}.
+		 * <p>By default this is initialized with encoders for {@code String},
+		 * {@code byte[]}, {@code ByteBuffer}, and {@code DataBuffer}.
 		 */
 		Builder encoder(Encoder<?>... encoder);
 
 		/**
-		 * Access and manipulate the list of configured {@link #encoder encoders}.
+		 * Apply the consumer to the list of configured encoders, immediately.
 		 */
 		Builder encoders(Consumer<List<Encoder<?>>> consumer);
 
 		/**
-		 * Add decoders for de-serializing Objects.
-		 * <p>By default this is empty.
+		 * Append to the list of decoders to use for de-serializing Objects from
+		 * the data or metadata of a {@link Payload}.
+		 * <p>By default this is initialized with decoders for {@code String},
+		 * {@code byte[]}, {@code ByteBuffer}, and {@code DataBuffer}.
 		 */
 		Builder decoder(Decoder<?>... decoder);
 
 		/**
-		 * Access and manipulate the list of configured {@link #encoder decoders}.
+		 * Apply the consumer to the list of configured decoders, immediately.
 		 */
 		Builder decoders(Consumer<List<Decoder<?>>> consumer);
 
@@ -146,28 +154,23 @@ interface Builder {
 		 * to adapt to, and/or determine the semantics of a given
 		 * {@link org.reactivestreams.Publisher Publisher}.
 		 * <p>By default this {@link ReactiveAdapterRegistry#getSharedInstance()}.
-		 * @param registry the registry to use
 		 */
 		Builder reactiveAdapterStrategy(ReactiveAdapterRegistry registry);
 
 		/**
-		 * Configure the DataBufferFactory to use for allocating buffers, for
-		 * example when preparing requests or when responding. The choice here
-		 * must be aligned with the frame decoder configured in
-		 * {@link io.rsocket.RSocketFactory}.
-		 * <p>By default this property is an instance of
-		 * {@link org.springframework.core.io.buffer.DefaultDataBufferFactory
-		 * DefaultDataBufferFactory} matching to the default frame decoder in
-		 * {@link io.rsocket.RSocketFactory} which copies the payload. This
-		 * comes at cost to performance but does not require reference counting
-		 * and eliminates possibility for memory leaks.
-		 * <p>To switch to a zero-copy strategy,
-		 * <a href="https://github.com/rsocket/rsocket-java#zero-copy">configure RSocket</a>
-		 * accordingly, and then configure this property with an instance of
-		 * {@link org.springframework.core.io.buffer.NettyDataBufferFactory
-		 * NettyDataBufferFactory} with a pooled allocator such as
-		 * {@link PooledByteBufAllocator#DEFAULT}.
-		 * @param bufferFactory the DataBufferFactory to use
+		 * Configure the DataBufferFactory to use for allocating buffers when
+		 * preparing requests or creating responses.
+		 * <p>By default this is set to {@link NettyDataBufferFactory} with
+		 * pooled, allocated buffers for zero copy. RSocket must also be
+		 * <a href="https://github.com/rsocket/rsocket-java#zero-copy">configured</a>
+		 * for zero copy. For client setup, {@link RSocketRequester.Builder}
+		 * adapts automatically to the {@code DataBufferFactory} configured
+		 * here, and sets the frame decoder in {@link ClientRSocketFactory
+		 * ClientRSocketFactory} accordingly. For server setup, the
+		 * {@link ServerRSocketFactory ServerRSocketFactory} must be configured
+		 * accordingly too for zero copy.
+		 * <p>If using {@link DefaultDataBufferFactory} instead, there is no
+		 * need for related config changes in RSocket.
 		 */
 		Builder dataBufferFactory(DataBufferFactory bufferFactory);