Mastering RSocket with Spring Boot 2.7: Protocol Basics, Interaction Patterns, and Real‑World Code

Overview

RSocket is a binary protocol that can run over TCP, WebSockets, Aeron and other byte‑stream transports. It defines four interaction models:

Request‑Response : send one request, receive one response.

Request‑Stream : send one request, receive a stream of responses.

Channel : bidirectional streams of messages.

Fire‑and‑Forget : send a one‑way message.

After the initial connection, the client and server become symmetric peers, each capable of initiating any of the above interactions.

Key Features of RSocket

Reactive stream semantics across network boundaries with back‑pressure.

Request throttling via a lease mechanism.

Session resumption for lost connections.

Fragmentation and reassembly of large messages.

Keep‑alive (heartbeat) support.

Java Implementation

In Java, RSocket is built on Project Reactor and Reactor Netty for transport.

Protocol Basics

Connecting

The client establishes a TCP or WebSocket connection and sends a SETUP frame to negotiate parameters. The server may reject the SETUP frame; otherwise, both sides can start sending requests unless lease semantics require a LEASE frame first.

Making Requests

After the connection, either side can send REQUEST_RESPONSE, REQUEST_STREAM, REQUEST_CHANNEL, or REQUEST_FNF frames. The responder returns a PAYLOAD frame (or multiple for streams/channels). For streaming interactions, the requester signals demand with REQUEST_N frames. METADATA_PUSH frames can deliver connection‑wide metadata.

Message Format

Each RSocket message contains data and optional metadata. Metadata can carry routing information, security tokens, etc., and is declared via MIME types in the setup.

Application Scenarios

Game Development : low‑latency, real‑time communication between server and clients.

Live Streaming : reliable, ordered delivery of large data streams.

IoT : efficient, bidirectional communication for remote device control.

Distributed Systems : connecting microservice components with back‑pressure.

Real‑time Data Analytics : streaming data from sources to processing nodes.

Practical Example

Below are Spring Boot 2.7 configurations and code snippets demonstrating all four RSocket interaction modes.

Dependencies

<code>&lt;dependency&gt;
  &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
  &lt;artifactId&gt;spring-boot-starter-rsocket&lt;/artifactId&gt;
&lt;/dependency&gt;
&lt;dependency&gt;
  &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
  &lt;artifactId&gt;spring-boot-starter-webflux&lt;/artifactId&gt;
&lt;/dependency&gt;</code>

Server Configuration (application.yml)

<code>spring:
  rsocket:
    server:
      port: 9898
      transport: tcp</code>

Client Template

<code>@Service
public class PackRSocketService {
  private final RSocketRequester rsocketRequester;
  public PackRSocketService(RSocketRequester.Builder builder) {
    this.rsocketRequester = builder.tcp("localhost", 9898);
  }
}</code>

1. Request‑Response

Server

<code>@MessageMapping("message")
public Mono<String> handleMessage(Mono<String> message) {
  return message.doOnNext(msg -> System.out.printf("Received: %s%n", msg))
                .map(msg -> "Server successfully received your message!!!");
}</code>

Client

<code>public void sendMessage(String body) {
  rsocketRequester.route("message")
                 .data(body)
                 .retrieveMono(String.class)
                 .subscribe(System.out::println);
}</code>

Result:

2. Request‑Stream

Server

<code>@MessageMapping("stream")
public Flux<String> handleStream() {
  return Flux.interval(Duration.ofSeconds(2))
             .map(i -> String.valueOf(new Random().nextInt(10000000)))
             .take(10)
             .doOnComplete(() -> System.out.println("completed..."));
}</code>

Client

<code>public void sendStream() {
  rsocketRequester.route("stream")
                 .retrieveFlux(String.class)
                 .subscribe(data -> System.out.printf("%s - Received: %s%n", Thread.currentThread().getName(), data));
}</code>

Result:

3. Channel

Server

<code>@MessageMapping("channel")
public Flux<String> handleChannel(Flux<String> datas) {
  return datas.doOnNext(d -> System.out.printf("[server] %s - Received: %s%n", Thread.currentThread().getName(), d))
              .map(d -> d + " - " + new Random().nextInt(1000));
}</code>

Client

<code>public void sendChannel() {
  rsocketRequester.route("channel")
                 .data(Flux.just("1","2","3","4","5","6").delayElements(Duration.ofSeconds(1)))
                 .retrieveFlux(String.class)
                 .subscribe(d -> System.out.printf("[client] %s - Received: %s%n", Thread.currentThread().getName(), d));
}</code>

Result:

4. Fire‑and‑Forget

Server

<code>@MessageMapping("faf")
public Mono<Void> handleFireAndForget(Mono<String> data) {
  return data.doOnNext(d -> System.out.printf("[server] %s - Received: %s%n", Thread.currentThread().getName(), d))
             .then();
}</code>

Client

<code>public void sendFireAndForget() {
  rsocketRequester.route("faf")
                 .data(Mono.just(String.valueOf(new Random().nextInt(1000))))
                 .send()
                 .subscribe();
}</code>

Result:

Conclusion

Choosing RSocket versus HTTP for microservice communication depends on the specific requirements: RSocket excels when low latency, bidirectional streams, and back‑pressure are critical, while HTTP offers broader maturity and simplicity.