Integrating Spring Cloud Service Discovery with RSocket for Load‑Balanced RPC

Overview

RSocket is a binary, asynchronous messaging protocol that is built into Spring Framework 5.2. Spring Boot 2.3 provides spring-boot-starter-rsocket to simplify the creation and consumption of RSocket services.

Service Registration and Discovery

The discovery model involves three roles: provider, consumer, and a registry (Consul is used in the example). A provider registers its name, IP, ports, and metadata (group, version, RSocket port, etc.) with the registry.

A naming convention based on reverse‑domain style with hyphens is adopted for the application name, e.g. com-example-calculator. The full service name is constructed as:

String serviceFullName = appName.replace("-", ".") + "." + serviceInterfaceName;

Valid examples:

com.example.calculator.MathCalculatorService

com.example.calculator.ExchangeCalculatorService

Consul can be started in development mode with: consul agent -dev or via Docker Compose. The application registers itself using the spring-cloud-starter-consul-discovery starter.

RSocket Service Implementation

After adding spring-boot-starter-rsocket, a controller is annotated with @MessageMapping to expose routes:

@Controller
@MessageMapping("com.example.calculator.MathCalculatorService")
public class MathCalculatorController implements MathCalculatorService {
    @MessageMapping("square")
    public Mono<Integer> square(Integer input) {
        System.out.println("received: " + input);
        return Mono.just(input * input);
    }
}

To make the implementation look like a traditional RPC service, a custom meta‑annotation @SpringRSocketService is introduced:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@MessageMapping()
public @interface SpringRSocketService {
    @AliasFor(annotation = MessageMapping.class)
    String[] value() default {};
}

Using the custom annotation the service becomes:

@SpringRSocketService("com.example.calculator.MathCalculatorService")
public class MathCalculatorImpl implements MathCalculatorService {
    @RSocketHandler("square")
    public Mono<Integer> square(Integer input) {
        System.out.println("received: " + input);
        return Mono.just(input * input);
    }
}

Configuration

Application properties configure Consul discovery metadata and the RSocket server port:

spring.application.name=com-example-calculator
spring.cloud.consul.discovery.instance-id=com-example-calculator-${random.uuid}
spring.cloud.consul.discovery.prefer-ip-address=true
server.port=0
spring.rsocket.server.port=6565
spring.cloud.consul.discovery.metadata.rsocketPort=${spring.rsocket.server.port}
spring.cloud.consul.discovery.tags=com.example.calculator.ExchangeCalculatorService,com.example.calculator.MathCalculatorService

RSocket Client Integration

The client obtains a ReactiveDiscoveryClient bean, resolves the application name from the full service interface name, fetches ServiceInstance objects, converts them to LoadbalanceTarget objects, and builds a load‑balanced RSocketRequester:

rsocketRequester.route("com.example.calculator.MathCalculatorService.square")
    .data(number)
    .retrieveMono(Integer.class)

A periodic task refreshes the target list; the RSocket load‑balancer automatically drops failed connections and opens new ones.

Developer‑Experience Considerations

RSocket follows an interface‑based RPC model similar to Dubbo or gRPC. Calls accept a single argument; Java 8 default methods can provide convenient overloads without affecting the wire protocol:

public interface ExchangeCalculatorService {
    double exchange(ExchangeRequest request);
    default double rmbToDollar(double amount) {
        return exchange(new ExchangeRequest(amount, "CNY", "USD"));
    }
}

RSocket Broker Support

A broker architecture can be used by prefixing the service name with the broker identifier, e.g. broker0:com.example.calculator.MathCalculatorService. The client extracts the prefix, discovers the broker instance via Consul, and forwards the request through the broker. This enables scenarios such as beta testing by routing traffic to a specific broker‑registered version, e.g.

com-example-calculator-beta1:com.example.calculator.MathCalculatorService

.

Conclusion

By applying a simple naming scheme and leveraging Spring Cloud’s discovery mechanisms, RSocket can provide RPC‑style communication with built‑in load balancing and optional broker support, without requiring a separate service‑registry solution. The pattern works with Consul, Nacos, Eureka, or ZooKeeper, reducing operational overhead.