0. RSocket 简介
采用二进制点对点数据传输，主要应用于分布式架构之中，是一种基于Reactive Stream规范标准实现的新的通信协议。
相关文档和资料：
在这里我们在客户端使用 rsocket-java 原生库，在服务端使用 spring-boot-starter-rsocket。
1. 服务端
1.1 SETUP阶段 - 处理客户端发起的连接请求
新建一个 RSocketController 类来处理 RSocket 相关的请求。
@Controller
public class RSocketController {
private static Logger logger = LoggerFactory.getLogger(RSocketController.class);
// 对到来的连接做一些处理
@ConnectMapping("connect.setup")
public Mono setup(String data, RSocketRequester rSocketRequester) {
logger.info("[connect.setup]Client connection: {}\n", data);
return Mono.empty();
}
}
RSocket 的 metadata 中可以包含路由（Routing）信息，这和 一般 WEB 框架通过解析 URL 将请求导向不同的处理函数是一样的。在连接建立时，客户端会发送一个 SETUP Payload，@ConnectMapping 可以通过解析 SETUP Payload 的 metadata 中的路由信息来使用不同的连接建立阶段的处理函数。在这里，只要 SETUP Payload 的 metadata 中的路由信息是 connect.setup ，该函数就会处理建立连接后客户端发送的 SETUP Payload。
1.2 保存客户端的 Requester
RSocket 协议支持双方主动调用对方的函数。如果服务端想要主动向客户端发送请求，他就可以在连接建立时保存 RSocketRequester 对象以便服务端在需要时向客户端发起请求。
首先在这里我们假设客户端建立连接时会将 UUID 放在 SETUP Payload 的 data 中。然后我们声明一个类来保存 RSocketRequester，代码如下：
public class ConnectedClient {
public RSocketRequester requester;
public Date connectedTime;
ConnectedClient(RSocketRequester requester) {
this.requester = requester;
this.connectedTime = new Date();
}
}
然后我们建立一个 Service 来管理客户端的 RSocketRequester。在这里使用 ConcurrentHashMap 来存储 Requester，键是客户端的 UUID，值是 ConnectedClient 对象。
@Service
public class ConnectedClientsManager {
private static Logger logger = LoggerFactory.getLogger(ConnectedClientsManager.class);
public final ConcurrentHashMap clients;
public ConnectedClientsManager() {
this.clients = new ConcurrentHashMap<>();
}
public Set getAllClientIdentifier() {
return this.clients.keySet();
}
public RSocketRequester getClientRequester(String clientIdentifier) {
return this.clients.get(clientIdentifier).requester;
}
public void putClientRequester(String clientIdentifier, RSocketRequester requester) {
requester.rsocket()
.onClose()
.doFirst(() -> this.clients.put(clientIdentifier, new ConnectedClient(requester)))
.doFinally(sig -> {
logger.info("Client closed, uuid is {}. signal is {}.", clientIdentifier, sig.toString());
this.clients.remove(clientIdentifier);
}).subscribe();
}
public void removeClientRequester(String clientIdentifier) {
this.clients.remove(clientIdentifier);
}
}
然后我们就可以在 RSocketController 中引入 ConnectedClientsManager 了。
@Controller
public class RSocketController {
private static Logger logger = LoggerFactory.getLogger(RSocketController.class);
public static ConnectedClientsManager clientsManager;
@Autowired
private void initializeClientsManager() {
clientsManager = new ConnectedClientsManager();
}
...
最后我们编写连接处理函数，将 Requester 保存起来：
@ConnectMapping("connect.setup")
public Mono setup(String data, RSocketRequester rSocketRequester) {
logger.info("[connect.setup]Client connection: {}\n", data);
clientsManager.putClientRequester(data, rSocketRequester);
return Mono.empty();
}
下面是 spring application 配置 application.yaml：
spring:
rsocket:
server:
port: 8099
transport: tcp
2. 客户端
- 第一步：随机生成标识客户端身份的 UUID
public class ConnectionSetup {
public static void main(String[] args) {
final Logger logger = LoggerFactory.getLogger(RSocketClientRaw.class);
UUID uuid = UUID.randomUUID();
......
- 第二步：生成 SETUP Payload 使用的 routing 信息
ByteBuf setupRouteMetadata = TaggingMetadataCodec.createTaggingContent(
ByteBufAllocator.DEFAULT,
Collections.singletonList("connect.setup"));
- 第三步：使用
RSocketConnector建立 RSocket：- 在这里首先需要设置元数据的 MIME 类型，方便服务端根据 MIME 类型确定
metadata的内容 - 然后生成 SETUP Payload，
data中存放 UUID 字符串，metadata中存放路由信息 - 设置重连策略
- 最后指定
ClientTransport和服务端建立连接 - 使用
block()在连接建立真正之前阻塞进程
- 在这里首先需要设置元数据的 MIME 类型，方便服务端根据 MIME 类型确定
RSocket socket = RSocketConnector.create()
// 设置 metadata MIME Type，方便服务端根据 MIME 类型确定 metadata 内容
.metadataMimeType(WellKnownMimeType.MESSAGE_RSOCKET_ROUTING.getString())
// SETUP 阶段的 Payload，data 里面存放 UUID
.setupPayload(ByteBufPayload.create(
ByteBufUtil.writeUtf8(ByteBufAllocator.DEFAULT, uuid.toString()),
setupRouteMetadata))
// 设置重连策略
.reconnect(Retry.backoff(2, Duration.ofMillis(500)))
.connect(
TcpClientTransport.create(
TcpClient.create()
.host("127.0.0.1")
.port(8099)))
.block();
然后可以使用 socket.onClose().block(); 保持连接。此时如果我们运行客户端，然后再关闭客户端的话，会在服务端看到输出：
表明客户端和服务端建立了连接之后又关闭了连接。