tessl/maven-org-springframework-boot--spring-boot-starter-rsocket

Starter for building RSocket clients and servers with Spring Boot auto-configuration.

—

Pending

Overview

Eval results

Files

Server Configuration

Name: tessl/maven-org-springframework-boot--spring-boot-starter-rsocket
Author: tessl

RSocket server setup supporting both standalone TCP/WebSocket servers and WebSocket endpoints integrated with Spring WebFlux applications.

Capabilities

Server Properties Configuration

Configure RSocket servers through Spring Boot properties under the spring.rsocket.server prefix.

/**
 * Configuration properties for RSocket server
 */
@ConfigurationProperties("spring.rsocket.server")
class RSocketProperties.Server {
    
    /** Server port - required for standalone server */
    Integer port;
    
    /** Network address to bind (default: all interfaces) */
    InetAddress address;
    
    /** Transport protocol */
    RSocketServer.Transport transport; // TCP, WEBSOCKET
    
    /** WebSocket mapping path (WebSocket transport only) */
    String mappingPath;
    
    /** Maximum frame size before fragmentation */
    DataSize fragmentSize;
    
    /** SSL configuration */
    Ssl ssl;
}

/**
 * RSocket server transport options
 */
enum RSocketServer.Transport {
    TCP,        // Direct TCP transport
    WEBSOCKET   // WebSocket transport  
}

Configuration Examples:

# Standalone TCP server
spring:
  rsocket:
    server:
      port: 9898
      transport: tcp
      address: 0.0.0.0
      fragment-size: 64KB

# WebSocket integration with WebFlux
spring:
  rsocket:
    server:
      transport: websocket
      mapping-path: "/rsocket"
      
# SSL-enabled server
spring:
  rsocket:
    server:
      port: 9899
      ssl:
        enabled: true
        key-store: classpath:keystore.p12
        key-store-password: secret

Standalone Server Factory

Factory for creating standalone RSocket servers with custom configuration.

/**
 * Factory interface for creating RSocket servers
 */
@FunctionalInterface
interface RSocketServerFactory {
    RSocketServer create(SocketAcceptor socketAcceptor);
}

/**
 * Configurable RSocket server factory interface
 */
interface ConfigurableRSocketServerFactory {
    /** Set server port (default: 9898) */
    void setPort(int port);
    
    /** Set network bind address */
    void setAddress(InetAddress address);
    
    /** Set transport protocol (TCP/WebSocket) */
    void setTransport(RSocketServer.Transport transport);
    
    /** Set maximum frame size for fragmentation */
    void setFragmentSize(DataSize fragmentSize);
    
    /** Configure SSL settings */
    void setSsl(Ssl ssl);
    
    /** Set SSL store provider */
    void setSslStoreProvider(SslStoreProvider sslStoreProvider);
}

/**
 * Netty-based RSocket server factory implementation
 */
class NettyRSocketServerFactory implements RSocketServerFactory, ConfigurableRSocketServerFactory {
    
    /** Set server bind address */
    void setAddress(InetAddress address);
    
    /** Set server port */
    void setPort(int port);
    
    /** Set transport protocol (TCP/WebSocket) */
    void setTransport(RSocketServer.Transport transport);
    
    /** Configure frame fragmentation size */
    void setFragmentSize(DataSize fragmentSize);
    
    /** Configure SSL settings */
    void setSsl(Ssl ssl);
    
    /** Set SSL store provider */
    void setSslStoreProvider(SslStoreProvider sslStoreProvider);
    
    /** Set Reactor Netty resource factory */
    void setResourceFactory(ReactorResourceFactory resourceFactory);
    
    /** Set server customizers */
    void setRSocketServerCustomizers(List<RSocketServerCustomizer> customizers);
    
    @Override
    RSocketServer create(SocketAcceptor socketAcceptor);
}

Usage Example:

@Configuration
public class CustomServerConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public RSocketServerFactory customRSocketServerFactory() {
        NettyRSocketServerFactory factory = new NettyRSocketServerFactory();
        factory.setPort(9999);
        factory.setTransport(RSocketServer.Transport.TCP);
        factory.setFragmentSize(DataSize.ofKilobytes(32));
        return factory;
    }
}

Server Bootstrap

Manages RSocket server lifecycle within Spring Boot application context.

/**
 * Bootstrap component for RSocket server lifecycle management
 */
class RSocketServerBootstrap implements ApplicationEventPublisherAware, SmartLifecycle {
    
    /**
     * Creates server bootstrap with factory and socket acceptor
     * @param serverFactory Factory for creating RSocket server instances
     * @param socketAcceptor Handler for incoming RSocket connections
     */
    RSocketServerBootstrap(RSocketServerFactory serverFactory, SocketAcceptor socketAcceptor);
    
    /** Set application event publisher */
    @Override
    void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher);
    
    /** Start the RSocket server */
    @Override
    void start();
    
    /** Stop the RSocket server */
    @Override  
    void stop();
    
    /** Check if server is running */
    @Override
    boolean isRunning();
}

Server Interface

Core RSocket server interface providing lifecycle management.

/**
 * Interface representing a fully configured RSocket server
 */
interface RSocketServer {
    
    /**
     * Start the RSocket server
     * @throws RSocketServerException if server cannot be started
     */
    void start() throws RSocketServerException;
    
    /**
     * Stop the RSocket server  
     * @throws RSocketServerException if server cannot be stopped
     */
    void stop() throws RSocketServerException;
    
    /**
     * Get the address this server is listening on
     * @return server bind address and port
     */
    InetSocketAddress address();
}

/**
 * Exception thrown during server operations
 */
class RSocketServerException extends RuntimeException {
    RSocketServerException(String message, Throwable cause);
}

WebSocket Integration

Integration with Spring WebFlux for RSocket over WebSocket endpoints.

/**
 * Route provider for WebSocket RSocket endpoints in WebFlux applications
 */
class RSocketWebSocketNettyRouteProvider implements NettyRouteProvider {
    
    /**
     * Creates WebSocket route provider
     * @param mappingPath WebSocket endpoint path
     * @param socketAcceptor Handler for RSocket connections
     * @param customizers Server customizers
     */
    RSocketWebSocketNettyRouteProvider(
        String mappingPath, 
        SocketAcceptor socketAcceptor,
        Stream<RSocketServerCustomizer> customizers
    );
    
    /**
     * Configure WebSocket routes
     * @param httpServerRoutes Existing HTTP routes to extend
     * @return Updated routes with WebSocket RSocket endpoint
     */
    @Override
    HttpServerRoutes apply(HttpServerRoutes httpServerRoutes);
}

WebSocket Integration Requirements:

Reactive web application (WebApplicationType.REACTIVE)
WebSocket transport configured (transport: websocket)
Mapping path specified (mapping-path: "/rsocket")
No standalone port configured (uses WebFlux server port)

Example Configuration:

spring:
  webflux:
    base-path: /api
  rsocket:
    server:
      transport: websocket
      mapping-path: "/rsocket"

Server Customization

Customize RSocket server configuration through the RSocketServerCustomizer interface.

/**
 * Callback interface for customizing RSocket servers
 */
@FunctionalInterface
interface RSocketServerCustomizer {
    
    /**
     * Customize the RSocket server configuration
     * @param server RSocket server to customize
     */
    void customize(RSocketServer server);
}

Usage Examples:

@Component
public class ServerCustomizers {
    
    // Enable zero-copy frame decoding for performance
    @Bean
    public RSocketServerCustomizer frameDecoderCustomizer() {
        return server -> server.payloadDecoder(PayloadDecoder.ZERO_COPY);
    }
    
    // Configure connection handling
    @Bean
    public RSocketServerCustomizer connectionCustomizer() {
        return server -> {
            server.resume(Duration.ofMinutes(5));
            server.lease(Leases::disabled);
        };
    }
    
    // Add request interceptors
    @Bean
    public RSocketServerCustomizer interceptorCustomizer() {
        return server -> {
            server.interceptors(registry -> {
                registry.forConnection(new LoggingConnectionInterceptor());
                registry.forRequester(new MetricsRequesterInterceptor());
            });
        };
    }
}

Configuration Scenarios

Scenario 1: Standalone TCP Server

spring:
  rsocket:
    server:
      port: 7878
      transport: tcp

Creates dedicated RSocket server on port 7878 using TCP transport.

Scenario 2: WebSocket with WebFlux

server:
  port: 8080
spring:
  rsocket:
    server:
      transport: websocket
      mapping-path: "/rsocket"

Adds RSocket WebSocket endpoint at ws://localhost:8080/rsocket to existing WebFlux server.

Scenario 3: SSL-Enabled Server

spring:
  rsocket:
    server:
      port: 9443
      transport: tcp
      ssl:
        enabled: true
        key-store: file:server.p12
        key-store-password: changeit
        key-store-type: PKCS12

Scenario 4: Custom Server Factory

@Configuration
public class CustomServerConfig {
    
    @Bean
    @Primary
    public RSocketServerFactory customFactory(ReactorResourceFactory resourceFactory) {
        NettyRSocketServerFactory factory = new NettyRSocketServerFactory();
        factory.setResourceFactory(resourceFactory);
        factory.setTransport(RSocketServer.Transport.TCP);
        factory.setFragmentSize(DataSize.ofKilobytes(128));
        return factory;
    }
}

Events and Context

Server Events

/**
 * Event published when RSocket server is initialized
 */
class RSocketServerInitializedEvent extends ApplicationEvent {
    
    /**
     * Get the initialized server instance
     * @return RSocket server that was initialized
     */
    RSocketServer getServer();
}

Port Information

/**
 * Annotation for injecting local RSocket server port (deprecated)
 * @deprecated since 2.7.0 for removal in 3.0.0
 */
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Value("${local.rsocket.server.port}")
@Deprecated
@interface LocalRSocketServerPort {
}

/**
 * Test annotation for injecting local RSocket server port (replacement)
 * @since 2.7.0
 */
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Value("${local.rsocket.server.port}")
@interface org.springframework.boot.test.rsocket.server.LocalRSocketServerPort {
}

Usage Example:

@Component
public class ServerPortAware {
    
    @LocalRSocketServerPort
    private int rSocketPort;
    
    @EventListener
    public void onServerInitialized(RSocketServerInitializedEvent event) {
        log.info("RSocket server started on port: {}", rSocketPort);
        log.info("Server address: {}", event.getServer().address());
    }
}

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework-boot--spring-boot-starter-rsocket

docs

auto-configuration.md

client-configuration.md

codec-configuration.md

index.md

message-handling.md

server-configuration.md

tile.json

tessl/maven-org-springframework-boot--spring-boot-starter-rsocket