Java .net和spring boot RSocket之间的RSocket连接

我尝试通过RSocket协议将消息从.net服务发送到sping引导服务，连接已建立，但消息未到达目标。在这两种情况下，.net服务器-java客户端和java服务器-.net客户端。 可能有人已经设置了一个工作配置（.net-spring-boot-over-rsocket）

字符串消息的工作配置（java服务器-.net客户端）

import io.rsocket.AbstractRSocket；
导入io.rsocket.ConnectionSetupPayload；
导入io.rsocket.DuplexConnection；
导入io.rsocket.Payload；
导入io.rsocket.rsocket；
导入io.rsocket.RSocketFactory；
导入io.rsocket.SocketAcceptor；
导入io.rsocket.frame.decoder.PayloadDecoder；
导入io.rsocket.transport.ServerTransport；
导入io.rsocket.transport.netty.WebsocketDuplexConnection；
导入io.rsocket.util.DefaultPayload；
导入reactor.core.publisher.Flux；
导入reactor.core.publisher.Mono；
导入reactor.core.scheduler.Schedulers；
进口反应器网络连接；
导入reactor.netty.DisposableServer；
导入reactor.netty.http.server.HttpServer；
ServerTransport.ConnectionAcceptor接受程序=
RSocketFactory.receive（）
.frameDecoder（PayloadDecoder.ZERO\u副本）
.acceptor（新的SocketAcceptorImpl（））
.toConnectionAcceptor（）；
可处置服务器可处置服务器=
HttpServer.create（）
.host（“本地主机”）
.port（服务器端口）
.路线(
路线->
routes.ws(
"/",
（输入，输出）->{
DuplexConnection连接=新的WebsocketDuplexConnection（（连接）输入）；
返回acceptor.apply（连接）.then（out.neverComplete（））；
}))
.bindNow（）；
类SocketAcceptorImpl实现SocketAcceptor{
@凌驾
公共Mono接受（ConnectionSetupPayload设置有效负载，RSocket反应套接字）{
返回单声道(
新AbstractRSocket（）{
@凌驾
公共单声道fireAndForget（有效载荷）{
有效载荷。释放（）；
返回Mono.empty（）；
}
@凌驾
公共Mono请求响应（有效负载）{
返回Mono.just（有效载荷）；
}
@凌驾
公共流量请求频道（发布者有效负载）{
返回Flux.from（有效载荷）.subscribeOn（Schedulers.single（））；
}
@凌驾
公共流量请求流（有效负载）{
字符串dataUtf8=payload.getDataUtf8（）；
返回Flux.just（DefaultPayload.create（“！！！”+dataUtf8+“！！！”）；
}
});
}
}

对于从RSocket net客户端到RSocket spring boot Java服务器的

字符串传输，请尝试下面列出的答案

import io.rsocket.AbstractRSocket;
import io.rsocket.ConnectionSetupPayload;
import io.rsocket.DuplexConnection;
import io.rsocket.Payload;
import io.rsocket.RSocket;
import io.rsocket.RSocketFactory;
import io.rsocket.SocketAcceptor;
import io.rsocket.frame.decoder.PayloadDecoder;
import io.rsocket.transport.ServerTransport;
import io.rsocket.transport.netty.WebsocketDuplexConnection;
import io.rsocket.util.DefaultPayload;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;
import reactor.netty.Connection;
import reactor.netty.DisposableServer;
import reactor.netty.http.server.HttpServer;

        ServerTransport.ConnectionAcceptor acceptor =
            RSocketFactory.receive()
                    .frameDecoder(PayloadDecoder.ZERO_COPY)
                    .acceptor(new SocketAcceptorImpl())
                    .toConnectionAcceptor();


    DisposableServer disposableServer =
            HttpServer.create()
                    .host("localhost")
                    .port(serverPort)
                    .route(
                            routes ->
                                    routes.ws(
                                            "/",
                                            (in, out) -> {
                                                DuplexConnection connection = new WebsocketDuplexConnection((Connection) in);
                                                return acceptor.apply(connection).then(out.neverComplete());
                                            }))
                    .bindNow();

class SocketAcceptorImpl implements SocketAcceptor {

    @Override
    public Mono<RSocket> accept(ConnectionSetupPayload setupPayload, RSocket reactiveSocket) {
        return Mono.just(
                new AbstractRSocket() {

                    @Override
                    public Mono<Void> fireAndForget(Payload payload) {
                        payload.release();
                        return Mono.empty();
                    }

                    @Override
                    public Mono<Payload> requestResponse(Payload payload) {
                        return Mono.just(payload);
                    }

                    @Override
                    public Flux<Payload> requestChannel(Publisher<Payload> payloads) {
                        return Flux.from(payloads).subscribeOn(Schedulers.single());
                    }

                    @Override
                    public Flux<Payload> requestStream(Payload payload) {
                        String dataUtf8 = payload.getDataUtf8();
                        return Flux.just(DefaultPayload.create("!!! " + dataUtf8 + " !!!"));
                    }
                });
    }
}