io.vertx.core.http.HttpClientResponse java code examples

Refine search

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 List l =new ArrayList()
new LinkedList()
Smart code suggestions by Tabnine
}

private void testHttpProxyRequest2(Function<Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> reqFact) throws Exception {
 server.requestHandler(req -> {
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = reqFact.apply(onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertNotNull("request did not go through proxy", proxy.getLastUri());
   assertEquals("Host header doesn't contain target host", "localhost:8080", proxy.getLastRequestHeaders().get("Host"));
   testComplete();
  }));
  req.exceptionHandler(this::fail);
  req.end();
 }));
 await();
}

@Test
public void testResponseEndHandlers2() {
 waitFor(2);
 AtomicInteger cnt = new AtomicInteger();
 String content = "blah";
 server.requestHandler(req -> {
  req.response().headersEndHandler(v -> {
   // Insert another header
   req.response().putHeader("extraheader", "wibble");
   assertEquals(0, cnt.getAndIncrement());
  });
  req.response().bodyEndHandler(v -> {
   assertEquals(content.length(), req.response().bytesWritten());
   assertEquals(1, cnt.getAndIncrement());
   complete();
  });
  req.response().end(content);
 }).listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
   assertEquals(200, res.statusCode());
   assertEquals("wibble", res.headers().get("extraheader"));
   res.bodyHandler(buff -> {
    assertEquals(Buffer.buffer(content), buff);
    complete();
   });
  })).end();
 }));
 await();
}

 assertEquals(2, req.headers().getAll("juu_request").size());
 assertEquals("juu_request_value_1", req.headers().getAll("juu_request").get(0));
 assertEquals("juu_request_value_2", req.headers().getAll("juu_request").get(1));
});
startServer();
client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath",
 onSuccess(resp -> {
  Context ctx = vertx.getOrCreateContext();
  assertOnIOContext(ctx);
  assertEquals(1, resp.request().streamId());
  assertEquals(1, reqCount.get());
  assertEquals(HttpVersion.HTTP_2, resp.version());
  assertEquals(200, resp.statusCode());
  assertEquals("OK", resp.statusMessage());
  assertEquals("text/plain", resp.getHeader("content-type"));
  assertEquals("200", resp.getHeader(":status"));
  assertEquals("foo_value", resp.getHeader("foo_response"));
  assertEquals("bar_value", resp.getHeader("bar_response"));
  assertEquals(2, resp.headers().getAll("juu_response").size());
  assertEquals("juu_value_1", resp.headers().getAll("juu_response").get(0));
  assertEquals("juu_value_2", resp.headers().getAll("juu_response").get(1));
  resp.endHandler(v -> {
   assertOnIOContext(ctx);
   testComplete();
  });
 })).putHeader("Foo_request", "foo_request_value")
  .putHeader("bar_request", "bar_request_value")

@Test
public void testHttpClientResponsePauseIsIgnoredAtRequestEnd() throws Exception {
 testHttpClientResponsePause(resp -> {
  resp.endHandler(v -> {
   // Pausing the request in end handler should be a no-op
   resp.pause();
  });
 });
}

protected MultiMap checkEmptyHttpResponse(HttpMethod method, int sc, MultiMap reqHeaders) throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.setStatusCode(sc);
  resp.headers().addAll(reqHeaders);
  resp.end();
 });
 startServer();
 try {
  CompletableFuture<MultiMap> result = new CompletableFuture<>();
  client.request(method, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, "/", onSuccess(resp -> {
   Buffer body = Buffer.buffer();
   resp.exceptionHandler(result::completeExceptionally);
   resp.handler(body::appendBuffer);
   resp.endHandler(v -> {
    if (body.length() > 0) {
     result.completeExceptionally(new Exception());
    } else {
     result.complete(resp.headers());
    }
   });
  })).setFollowRedirects(false)
   .exceptionHandler(result::completeExceptionally)
   .end();
  return result.get(20, TimeUnit.SECONDS);
 } finally {
  client.close();
 }
}

@Test
public void testClientExceptionHandlerCalledWhenExceptionOnBodyHandler() throws Exception {
 server.requestHandler(request -> {
  request.response().end("foo");
 }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
  // Exception handler should be called for any exceptions in the data handler
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.bodyHandler(data -> {
    throw new RuntimeException("should be caught");
   });
   resp.exceptionHandler(t -> testComplete());
  })).exceptionHandler(error -> fail()).end();
 }));
 await();
}

@Test
public void testContainsValueString() {
 server.requestHandler(req -> {
  assertTrue(req.headers().contains("Foo", "foo", false));
  assertFalse(req.headers().contains("Foo", "fOo", false));
  req.response().putHeader("quux", "quux");
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertTrue(resp.headers().contains("Quux", "quux", false));
   assertFalse(resp.headers().contains("Quux", "quUx", false));
   testComplete();
  }));
  req.putHeader("foo", "foo");
  req.end();
 }));
 await();
}

@Test
public void testHeadCanSetContentLength() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // Head never contains a body but it can contain a Content-Length header
  // Since headers from HEAD must correspond EXACTLY with corresponding headers for GET
  req.response().headers().set("Content-Length", String.valueOf(41));
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals("41", resp.headers().get("Content-Length"));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}

@Test
public void testHttp11PersistentConnectionNotClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  assertNull(req.getHeader("Connection"));
  req.response().end();
  assertFalse(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(true));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertNull(resp.getHeader("Connection"));
    assertEquals(resp.getHeader("Content-Length"), "0");
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}

private void testResponseHeaders(boolean individually) {
 MultiMap headers = getHeaders(10);
 server.requestHandler(req -> {
  if (individually) {
   for (Map.Entry<String, String> header : headers) {
    req.response().headers().add(header.getKey(), header.getValue());
   }
  } else {
   req.response().headers().setAll(headers);
  }
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertTrue(headers.size() < resp.headers().size());
   for (Map.Entry<String, String> entry : headers) {
    assertEquals(entry.getValue(), resp.headers().get(entry.getKey()));
    assertEquals(entry.getValue(), resp.getHeader(entry.getKey()));
   }
   testComplete();
  })).end();
 }));
 await();
}

int numGets = 100;
int maxPoolSize = 10;
client.close();
client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(keepAlive).setPipelining(pipelining).setMaxPoolSize(maxPoolSize));
server.requestHandler(req -> {
 String cnt = req.headers().get("count");
 req.response().headers().set("count", cnt);
 req.response().end();
});
server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   assertEquals(theCount, Integer.parseInt(resp.headers().get("count")));
   if (cnt.incrementAndGet() == numGets) {
    testComplete();
  req.exceptionHandler(t -> {
   fail("Should not throw exception: " + t.getMessage());
  });
  req.headers().set("count", String.valueOf(i));
  req.end();

private void testStatusCode(int code, String statusMessage) {
 server.requestHandler(req -> {
  if (code != -1) {
   req.response().setStatusCode(code);
  }
  if (statusMessage != null) {
   req.response().setStatusMessage(statusMessage);
  }
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   int theCode;
   if (code == -1) {
    // Default code - 200
    assertEquals(200, resp.statusCode());
    theCode = 200;
   } else {
    theCode = code;
   }
   if (statusMessage != null && resp.version() != HttpVersion.HTTP_2) {
    assertEquals(statusMessage, resp.statusMessage());
   } else {
    assertEquals(HttpResponseStatus.valueOf(theCode).reasonPhrase(), resp.statusMessage());
   }
   testComplete();
  })).end();
 }));
 await();
}

@Test
public void testPutHeadersOnRequest() {
 server.requestHandler(req -> {
  assertEquals("bar", req.headers().get("foo"));
  assertEquals("bar", req.getHeader("foo"));
  req.response().end();
 });
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   testComplete();
  })).putHeader("foo", "bar").end();
 }));
 await();
}

@Test
public void testClientMaxHeaderSizeOption() {
 String longHeader = TestUtils.randomAlphaString(9000);
 // min 9023 = 9000 for longHeader and 23 for "Content-Length: 0 t: "
 vertx.createHttpServer(new HttpServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> {
  // Add longHeader
  req.response().putHeader("t", longHeader).end();
 }).listen(onSuccess(res -> {
  HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions().setMaxHeaderSize(10000))
    .request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
     assertEquals(200, resp.statusCode());
     assertEquals(resp.getHeader("t"), longHeader);
     testComplete();
    }));
  req.end();
 }));
 await();
}

@Test
public void testServerResponseWriteBufferFromOtherThread() throws Exception {
 server.requestHandler(req -> {
  runAsync(() -> {
   req.response().write("hello ").end("world");
  });
 }).listen(onSuccess(v -> {
  client.get(8080, "localhost", "/somepath", onSuccess(resp -> {
   assertEquals(200, resp.statusCode());
   resp.bodyHandler(buff -> {
    assertEquals(Buffer.buffer("hello world"), buff);
    testComplete();
   });
  })).exceptionHandler(this::fail).end();
 }));
 await();
}

@Test
public void testResponseBodyWriteFixedString() {
 String body = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
 Buffer bodyBuff = Buffer.buffer(body);
 server.requestHandler(req -> {
  req.response().setChunked(true);
  req.response().write(body);
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.bodyHandler(buff -> {
    assertEquals(bodyBuff, buff);
    testComplete();
   });
  })).end();
 }));
 await();
}

@Test
public void testPutHeaderReplacesPreviousHeaders() throws Exception {
 server.requestHandler(req ->
  req.response()
   .putHeader("Location", "http://example1.org")
   .putHeader("location", "http://example2.org")
   .end());
 server.listen(onSuccess(server -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals(singletonList("http://example2.org"), resp.headers().getAll("LocatioN"));
   testComplete();
   })).end();
 }));
 await();
}

@Test
public void testSkipEncoding() throws Exception {
 serverWithMaxCompressionLevel.requestHandler(req -> {
  assertNotNull(req.headers().get("Accept-Encoding"));
  req.response()
   .putHeader(HttpHeaders.CONTENT_ENCODING, HttpHeaders.IDENTITY)
   .end(Buffer.buffer(COMPRESS_TEST_STRING).toString(CharsetUtil.UTF_8));
 });
 startServer(serverWithMaxCompressionLevel);
 clientraw.get(DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST, "some-uri",
  onSuccess(resp -> {
   resp.bodyHandler(responseBuffer -> {
    String responseBody = responseBuffer.toString(CharsetUtil.UTF_8);
    assertEquals(COMPRESS_TEST_STRING, responseBody);
    testComplete();
   });
  })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end();
 await();
}

@Test
public void test100ContinueHandledAutomatically() throws Exception {
 Buffer toSend = TestUtils.randomBuffer(1000);
 server.requestHandler(req -> {
  req.bodyHandler(data -> {
   assertEquals(toSend, data);
   req.response().end();
  });
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> testComplete());
  }));
  req.headers().set("Expect", "100-continue");
  req.setChunked(true);
  req.continueHandler(v -> {
   req.write(toSend);
   req.end();
  });
  req.sendHead();
 }));
 await();
}

@Test
public void testFollowRedirectLimit() throws Exception {
 AtomicInteger redirects = new AtomicInteger();
 server.requestHandler(req -> {
  int val = redirects.incrementAndGet();
  if (val > 16) {
   fail();
  } else {
   String scheme = createBaseServerOptions().isSsl() ? "https" : "http";
   req.response().setStatusCode(301).putHeader(HttpHeaders.LOCATION, scheme + "://localhost:8080/otherpath").end();
  }
 });
 startServer();
 client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> {
  assertEquals(16, redirects.get());
  assertEquals(301, resp.statusCode());
  assertEquals("/otherpath", resp.request().path());
  testComplete();
 })).setFollowRedirects(true).end();
 await();
}

Javadoc

Represents a client-side HTTP response.

Vert.x provides you with one of these via the handler that was provided when creating the io.vertx.core.http.HttpClientRequestor that was set on the io.vertx.core.http.HttpClientRequest instance.

It implements io.vertx.core.streams.ReadStream so it can be used with io.vertx.core.streams.Pump to pump data with flow control.

Most used methods

statusCode
bodyHandler
Convenience method for receiving the entire request body in one piece. This saves you having to manu
statusMessage
headers
exceptionHandler
endHandler
getHeader
Return the first header value with the specified name
handler
pause
resume
request
cookies

Popular in Java

Creating JSON documents from java classes using gson
getExternalFilesDir (Context)
onRequestPermissionsResult (Fragment)
runOnUiThread (Activity)
GridLayout (java.awt)
The GridLayout class is a layout manager that lays out a container's components in a rectangular gri
Format (java.text)
The base class for all formats. This is an abstract base class which specifies the protocol for clas
MessageFormat (java.text)
Produces concatenated messages in language-neutral way. New code should probably use java.util.Forma
Collectors (java.util.stream)
Cipher (javax.crypto)
This class provides access to implementations of cryptographic ciphers for encryption and decryption
JOptionPane (javax.swing)
PhpStorm for WordPress

How to useHttpClientResponse in io.vertx.core.http

Best Java code snippets using io.vertx.core.http.HttpClientResponse (Showing top 20 results out of 909)

Refine search

How to use
HttpClientResponse
in
io.vertx.core.http