如何在RxJava Vert.x中结束链接http请求？

如何在Rx Vert.X中结束链接请求

 HttpClient client = Vertx.vertx().createHttpClient();
        HttpClientRequest request = client.request(HttpMethod.POST,
                "someURL")
                .putHeader("content-type", "application/x-www-form-urlencoded")
                .putHeader("content-length", Integer.toString(jsonData.length())).write(jsonData);
        request.toObservable().
                //flatmap HttpClientResponse -> Observable<Buffer>
                        flatMap(httpClientResponse -> { //something
                    return httpClientResponse.toObservable();
                }).
                        map(buffer -> {return buffer.toString()}).
                //flatmap data -> Observable<HttpClientResponse>
                        flatMap(postData -> client.request(HttpMethod.POST,
                        someURL")
                        .putHeader("content-type", "application/x-www-form-urlencoded")
                        .putHeader("content-length", Integer.toString(postData.length())).write(postData).toObservable()).
                //flatmap HttpClientResponse -> Observable<Buffer>
                        flatMap(httpClientResponse -> {
                    return httpClientResponse.toObservable();
                })......//other operators
request.end();

HttpClient-client=Vertx.Vertx（）.createHttpClient（）；
HttpClientRequest=client.request（HttpMethod.POST，
“someURL”）
.putHeader（“内容类型”、“应用程序/x-www-form-urlencoded”）
.putHeader（“内容长度”，Integer.toString（jsonData.length（）））.write（jsonData）；
request.toObservable（）。
//平面图HttpClientResponse->Observable
flatMap（httpClientResponse->{//something
返回httpClientResponse.toObservable（）；
}).
映射（buffer->{return buffer.toString（）}）。
//平面图数据->可观察
flatMap（postData->client.request（HttpMethod.POST），
someURL“）
.putHeader（“内容类型”、“应用程序/x-www-form-urlencoded”）
.putHeader（“内容长度”，Integer.toString（postData.length（））.write（postData.toObservable（））。
//平面图HttpClientResponse->Observable
平面图（httpClientResponse->{
返回httpClientResponse.toObservable（）；
})……其他运营商
request.end（）；

---

请注意，对于顶部请求，我有。

end（）

。如何结束位于。

flatmap

中的请求？我甚至需要结束它吗？

有多种方法可以确保调用

request.end（）

。但我会深入研究Vert.x的文档，或者如果有，只打开源代码，看看它是否调用end（）给你的，否则就有一个

final HttpClientRequest request = ...
request.toObservable()
       .doOnUnsubscribe(new Action0() {
           @Override
           public void call() {
               request.end();
           }
       });

---

我认为您可以执行以下代码

其主要思想是，您不直接使用由

Vertx

客户端获得的

HttpClientRequest

，而是创建另一个flowable，在收到第一个订阅后立即调用

end（）

例如，在这里，您可以通过一对自定义方法获得请求：在本例中，是

request1（）

和

request2（）

。它们都使用

doOnSubscribe（）

来触发所需的

end（）

此示例使用了vertx和reactivex，我希望您可以使用此设置

import io.reactivex.Flowable;
import io.vertx.core.http.HttpMethod;
import io.vertx.reactivex.core.Vertx;
import io.vertx.reactivex.core.buffer.Buffer;
import io.vertx.reactivex.core.http.HttpClient;
import io.vertx.reactivex.core.http.HttpClientRequest;
import io.vertx.reactivex.core.http.HttpClientResponse;
import org.junit.Test;

public class StackOverflow {

    @Test public void test(){

        Buffer jsonData = Buffer.buffer("..."); // the json data.

        HttpClient client = Vertx.vertx().createHttpClient(); // the vertx client.

        request1(client)
            .flatMap(httpClientResponse -> httpClientResponse.toFlowable())
            .map(buffer -> buffer.toString())
            .flatMap(postData -> request2(client, postData) )
            .forEach( httpResponse -> {
                // do something with returned data);
            });

    }

    private Flowable<HttpClientResponse> request1(HttpClient client) {
        HttpClientRequest request = client.request(HttpMethod.POST,"someURL");
        return request
                .toFlowable()
                .doOnSubscribe( subscription -> request.end() );
    }

    private Flowable<HttpClientResponse> request2(HttpClient client, String postData) {
        HttpClientRequest request = client.request(HttpMethod.POST,"someURL");
        // do something with postData
        return request
                .toFlowable()
                .doOnSubscribe( subscription -> request.end() );
    }

}

import io.reactivex.Flowable；
导入io.vertx.core.http.HttpMethod；
导入io.vertx.reactivex.core.vertx；
导入io.vertx.reactivex.core.buffer.buffer；
导入io.vertx.reactivex.core.http.HttpClient；
导入io.vertx.reactivex.core.http.HttpClientRequest；
导入io.vertx.reactivex.core.http.HttpClientResponse；
导入org.junit.Test；
公共类堆栈溢出{
@测试公共无效测试（）{
Buffer jsonData=Buffer.Buffer（“…”）；//json数据。
HttpClient=Vertx.Vertx（）.createHttpClient（）；//Vertx客户端。
请求1（客户端）
.flatMap（httpClientResponse->httpClientResponse.toFlowable（））
.map（buffer->buffer.toString（））
.flatMap（postData->request2（客户端，postData））
.forEach（httpResponse->{
//处理返回的数据）；
});
}
私有可流动请求1（HttpClient客户端）{
HttpClientRequest=client.request（HttpMethod.POST，“someURL”）；
退货申请
.toFlowable（）
.doOnSubscribe（订阅->请求.end（））；
}
私有可流动请求2（HttpClient客户端，字符串postData）{
HttpClientRequest=client.request（HttpMethod.POST，“someURL”）；
//用postData做点什么
退货申请
.toFlowable（）
.doOnSubscribe（订阅->请求.end（））；
}
}