Java 将一个websocket客户端的输出作为输入发送到另一个客户端

快速搜索，所以没有找到我一个类似的问题，所以我们来了

我基本上希望RSocket的requestChannel语法与Webflux一起使用，这样我就能够在WebSocketClient.execute（）方法之外处理接收到的Flux，并编写如下代码（会话仅在订阅返回的流量时打开，错误传播正确，入站和出站流量完成时自动完成和关闭WS-session- 由服务器端完成或由使用者取消）

服务/f将其收到的字符串消息包装在“f（…）”：“str”->“f（str）”中

服务/g对“g（…）”执行相同的操作，并通过以下测试：

    private final DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();

    private WebSocketMessage serializeString(final String text) {
        return new WebSocketMessage(Type.TEXT, dataBufferFactory.wrap(text.getBytes(StandardCharsets.UTF_8)));
    }

    @Test
    void test() {
        var requests = 5;
        var input = Flux.range(0, requests).map(String::valueOf);

        var wsClient = new ReactorNettyWebSocketClient(
            HttpClient.from(TcpClient.create(ConnectionProvider.newConnection())));

        var f = requestChannel(wsClient, fUri, input.map(this::serializeString))
            .map(WebSocketMessage::getPayloadAsText);

        var g = requestChannel(wsClient, gUri, f.map(this::serializeString))
            .map(WebSocketMessage::getPayloadAsText);

        var responses = g.take(requests);

        var expectedResponses = Stream.range(0, requests)
                                           .map(i -> "g(f(" + i + "))")
                                           .toJavaArray(String[]::new);

        StepVerifier.create(responses)
                    .expectSubscription()
                    .expectNext(expectedResponses)
                    .verifyComplete();
    }

---

到目前为止，这似乎对我有效

    public static Flux<WebSocketMessage> requestChannel(
        WebSocketClient wsClient, URI uri, Flux<WebSocketMessage> outbound) {

        CompletableFuture<Flux<WebSocketMessage>> recvFuture = new CompletableFuture<>();
        CompletableFuture<Integer> consumerDoneCallback = new CompletableFuture<>();

        var executeMono = wsClient.execute(uri,
            wss -> {
                recvFuture.complete(wss.receive().log("requestChannel.receive " + uri, Level.FINE));
                return wss.send(outbound)
                          .and(Mono.fromFuture(consumerDoneCallback));
            }).log("requestChannel.execute " + uri, Level.FINE);

        return Mono.fromFuture(recvFuture)
                   .flatMapMany(recv -> recv.doOnComplete(() -> consumerDoneCallback.complete(1)))
                   .mergeWith(executeMono.cast(WebSocketMessage.class));
    }

公共静态流量请求通道(
WebSocketClient（wsClient、URI、流量出站）{
CompletableFuture recvFuture=新的CompletableFuture（）；
CompletableFuture consumerDoneCallback=新建CompletableFuture（）；
var executeMono=wsClient.execute（uri，
wss->{
recvFuture.complete（wss.receive（）.log（“requestChannel.receive”+uri，Level.FINE））；
返回wss.send（出站）
.和（Mono.fromFuture（consumerDoneCallback））；
}).log（“requestChannel.execute”+uri，Level.FINE）；
返回Mono.fromFuture（recvFuture）
.flatMapMany（recv->recv.doOnComplete（（）->consumerDoneCallback.complete（1）））
.mergeWith（executeMono.cast（WebSocketMessage.class））；
}

如果这个解决方案有任何缺陷，我会非常感兴趣