@Override public void start() throws Exception { HttpClient client = vertx.createHttpClient(); HttpClientRequest req = client.request(HttpMethod.GET, 8080, "localhost", "/"); req.toObservable(). flatMap(HttpClientResponse::toObservable). // Unmarshall the response to the Data object via Jackon lift(io.vertx.rxjava.core.RxHelper.unmarshaller(Data.class)). subscribe( data -> { System.out.println("Got response " + data.message); }); // End request req.end(); } }
@Override public void start() throws Exception { HttpClient client = vertx.createHttpClient(); client.put(8080, "localhost", "/", resp -> { System.out.println("Got response " + resp.statusCode()); resp.handler(buf -> System.out.println(buf.toString("UTF-8"))); }).setChunked(true).putHeader("Content-Type", "text/plain").write("hello").end(); } }
/** * Returns an {@code Observable<HttpClientResponse>} that performs a <i>get</i> request each time it is subscribed. The * returned observable can be used to consume the response.<p> * * This is different from the {@link HttpClientRequest#toObservable()} that should be subscribed before the request is ended * and should be consumed immediatly and once. * * @param client the http client * @param port the remote port * @param host the remote host * @param requestURI the request URI * @param headers the request headers * @return the response observable */ public static Observable<HttpClientResponse> get(HttpClient client, int port, String host, String requestURI, MultiMap headers) { return Observable.create(subscriber -> { HttpClientRequest req = client.get(port, host, requestURI); req.headers().addAll(headers); Observable<HttpClientResponse> resp = req.toObservable(); resp.subscribe(subscriber); req.end(); }); }
HttpClientRequest req = client.getAbs(downloadUrl); req.exceptionHandler(t -> handler.handle(Future.failedFuture(t))); req.handler(res -> { if (res.statusCode() != 200) { handler.handle(Future.failedFuture(new HttpException(res.statusCode(), }); req.end();
void sendDatapoint(String dbname, String msg) { LOG.trace("Sending measures length = {} Bytes ", msg.length()); this.http.post("/write?db=" + dbname, response -> { if (response.statusCode() >= 400) { LOG.warn("{} {}", response.statusCode(), response.statusMessage()); response.bodyHandler(data -> LOG.warn(data.toString())); } }).end(msg); }
public synchronized io.vertx.rx.java.WriteStreamSubscriber<io.vertx.rxjava.core.buffer.Buffer> toSubscriber() { if (subscriber == null) { java.util.function.Function<io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.buffer.Buffer> conv = io.vertx.rxjava.core.buffer.Buffer::getDelegate; subscriber = io.vertx.rx.java.RxHelper.toSubscriber(getDelegate(), conv); } return subscriber; }
public static HttpClientRequest newInstance(io.vertx.core.http.HttpClientRequest arg) { return arg != null ? new HttpClientRequest(arg) : null; } }
public synchronized io.vertx.rx.java.WriteStreamSubscriber<io.vertx.rxjava.core.buffer.Buffer> toSubscriber() { if (subscriber == null) { java.util.function.Function<io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.buffer.Buffer> conv = io.vertx.rxjava.core.buffer.Buffer::getDelegate; subscriber = io.vertx.rx.java.RxHelper.toSubscriber(getDelegate(), conv); } return subscriber; }
public static HttpClientRequest newInstance(io.vertx.core.http.HttpClientRequest arg) { return arg != null ? new HttpClientRequest(arg) : null; } }
@Override public void start() throws Exception { HttpClient client = vertx.createHttpClient(); // Create two requests HttpClientRequest req1 = client.request(HttpMethod.GET, 8080, "localhost", "/"); HttpClientRequest req2 = client.request(HttpMethod.GET, 8080, "localhost", "/"); // Turn the requests responses into Observable<JsonObject> Observable<JsonObject> obs1 = req1.toObservable().flatMap(HttpClientResponse::toObservable). map(buf -> new JsonObject(buf.toString("UTF-8"))); Observable<JsonObject> obs2 = req2.toObservable().flatMap(HttpClientResponse::toObservable). map(buf -> new JsonObject(buf.toString("UTF-8"))); // Combine the responses with the zip into a single response obs1.zipWith(obs2, (b1, b2) -> new JsonObject().put("req1", b1).put("req2", b2)). subscribe(json -> { System.out.println("Got combined result " + json); }, err -> { err.printStackTrace(); }); req1.end(); req2.end(); } }
@Override public void start() throws Exception { HttpClient client = vertx.createHttpClient(); HttpClientRequest req = client.request(HttpMethod.GET, 8080, "localhost", "/"); req.toObservable(). // Status code check and -> Observable<Buffer> flatMap(resp -> { if (resp.statusCode() != 200) { throw new RuntimeException("Wrong status code " + resp.statusCode()); } return resp.toObservable(); }). subscribe(data -> System.out.println("Server content " + data.toString("UTF-8"))); // End request req.end(); } }
@Override public void start() throws Exception { HttpClient client = vertx.createHttpClient(); HttpClientRequest req = client.request(HttpMethod.GET, 8080, "localhost", "/"); req.toObservable(). // Status code check and -> Observable<Buffer> flatMap(resp -> { if (resp.statusCode() != 200) { throw new RuntimeException("Wrong status code " + resp.statusCode()); } return Observable.just(Buffer.buffer()).mergeWith(resp.toObservable()); }). // Reduce all buffers in a single buffer reduce(Buffer::appendBuffer). // Turn in to a string map(buffer -> buffer.toString("UTF-8")). // Get a single buffer subscribe(data -> System.out.println("Server content " + data)); // End request req.end(); } }
/** * @see #get(HttpClient, int, String, String, MultiMap) */ public static Observable<HttpClientResponse> get(HttpClient client, String host, String requestURI) { return Observable.create(subscriber -> { HttpClientRequest req = client.get(host, requestURI); Observable<HttpClientResponse> resp = req.toObservable(); resp.subscribe(subscriber); req.end(); }); }
/** * @see #get(HttpClient, int, String, String, MultiMap) */ public static Observable<HttpClientResponse> get(HttpClient client, String requestURI) { return Observable.create(subscriber -> { HttpClientRequest req = client.get(requestURI); Observable<HttpClientResponse> resp = req.toObservable(); resp.subscribe(subscriber); req.end(); }); }
/** * @see #get(HttpClient, int, String, String, MultiMap) */ public static Observable<HttpClientResponse> get(HttpClient client, int port, String host, String requestURI) { return Observable.create(subscriber -> { HttpClientRequest req = client.get(port, host, requestURI); Observable<HttpClientResponse> resp = req.toObservable(); resp.subscribe(subscriber); req.end(); }); }