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

Common ways to obtain HttpClientResponse

private void myMethod () {
 HttpClientResponse h =HttpClientResponse httpClientResponse;httpClientResponse.resume()
HttpClientResponse httpClientResponse;httpClientResponse.pause()
Smart code suggestions by Codota
}

private void testResponseCompression(boolean enabled) throws Exception {
 byte[] expected = TestUtils.randomAlphaString(1000).getBytes();
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 GZIPOutputStream in = new GZIPOutputStream(baos);
 in.write(expected);
 in.close();
 byte[] compressed = baos.toByteArray();
 server.close();
 server = vertx.createHttpServer(serverOptions);
 server.requestHandler(req -> {
  assertEquals(enabled ? "deflate, gzip" : null, req.getHeader(HttpHeaderNames.ACCEPT_ENCODING));
  req.response().putHeader(HttpHeaderNames.CONTENT_ENCODING.toLowerCase(), "gzip").end(Buffer.buffer(compressed));
 });
 startServer();
 client.close();
 client = vertx.createHttpClient(clientOptions.setTryUseCompression(enabled));
 client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
  String encoding = resp.getHeader(HttpHeaderNames.CONTENT_ENCODING);
  assertEquals(enabled ? null : "gzip", encoding);
  resp.bodyHandler(buff -> {
   assertEquals(Buffer.buffer(enabled ? expected : compressed), buff);
   testComplete();
  });
 })).end();
 await();
}

@Test
public void testResponseHeadersWithCharSequence() {
 HashMap<CharSequence, String> headers = new HashMap<>();
 headers.put(HttpHeaders.TEXT_HTML, "text/html");
 headers.put(HttpHeaders.USER_AGENT, "User-Agent");
 headers.put(HttpHeaders.APPLICATION_X_WWW_FORM_URLENCODED, "application/x-www-form-urlencoded");
 server.requestHandler(req -> {
  headers.forEach((k, v) -> req.response().headers().add(k, v));
  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());
   headers.forEach((k,v) -> assertEquals(v, resp.headers().get(k)));
   headers.forEach((k,v) -> assertEquals(v, resp.getHeader(k)));
   testComplete();
  })).end();
 }));
 await();
}

@Override
public String getContentType() {
 return clientResponse.getHeader(HttpHeaders.CONTENT_TYPE);
}

@Override
public String getHeader(String name) {
 return clientResponse.getHeader(name);
}

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();
}

@Test
public void testUnknownContentLengthIsSetToZeroWithHTTP_1_0() throws Exception {
 server.requestHandler(req -> {
  req.response().write("Some-String").end();
 });
 startServer();
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0));
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
  assertNull(resp.getHeader("Content-Length"));
  testComplete();
 }));
 await();
}

req.handler(resp -> {
 process.write(resp.statusCode() + " " + resp.statusMessage() + "\n");
 String contentType = resp.getHeader("Content-Type");
 String contentLength = resp.getHeader("Content-Length");
 process.write("Length: " + (contentLength != null ? contentLength : "unspecified"));
 if (contentType != null) {

@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 testChunkedServerResponse() {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.setChunked(true);
  assertTrue(resp.isChunked());
  resp.write("the-chunk");
  vertx.setTimer(1, id -> {
   resp.end();
  });
 }).listen(onSuccess(server -> {
  client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> {
   assertEquals("chunked", res.getHeader("transfer-encoding"));
   res.bodyHandler(body -> {
    assertEquals("the-chunk", body.toString());
    testComplete();
   });
  }));
 }));
 await();
}

@Test
public void testHttp10KeepAliveConnectionNotClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_0, req.version());
  assertEquals(req.getHeader("Connection"), "keep-alive");
  req.response().end();
  assertFalse(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(true));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertEquals(resp.getHeader("Connection"), "keep-alive");
    assertEquals(resp.getHeader("Content-Length"), "0");
    testComplete();
   });
  }));
  req.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();
}

@Test
public void testFoo() throws Exception {
 waitFor(2);
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.write("Hello");
  resp.end("World");
  assertNull(resp.headers().get("content-length"));
  complete();
 });
 startServer();
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
  assertNull(resp.getHeader("content-length"));
  resp.bodyHandler(body -> {
   assertEquals("HelloWorld", body.toString());
   complete();
  });
 }));
 await();
}

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));

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

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

public ReadStreamPart(Context context, HttpClientResponse httpClientResponse) {
 this(context, (ReadStream<Buffer>) httpClientResponse);
 setSubmittedFileName(
   HttpUtils.parseFileNameFromHeaderValue(httpClientResponse.getHeader(HttpHeaders.CONTENT_DISPOSITION)));
 String contentType = httpClientResponse.getHeader(HttpHeaders.CONTENT_TYPE);
 if (StringUtils.isNotEmpty(contentType)) {
  this.contentType(contentType);
 }
}

@Test
public void testContentTypeSupport() throws Exception {
 testRequest(HttpMethod.GET, "/somedir/range.jpg", req -> {
 }, res -> {
  assertNotNull(res.getHeader("Content-Type"));
  assertEquals("image/jpeg", res.getHeader("Content-Type"));
  testComplete();
 }, 200, "OK", null);
 await();
}

@Test
public void testRerouteClearHeader() throws Exception {
 router.get("/users/:name").handler(ctx -> ctx.response().end("/users/:name"));
 router.get("/me").handler(ctx -> {
  ctx.response().putHeader("X-woop", "durp");
  ctx.reroute("/users/paulo");
 });
 testRequest(HttpMethod.GET, "/me", null, res -> assertNull(res.getHeader("X-woop")), 200, "OK", "/users/:name");
}

private void testGreeting(String uri) {
 client.getNow(uri, onSuccess(resp -> {
  assertEquals(200, resp.statusCode());
  assertEquals("text/plain; charset=UTF-8", resp.getHeader("content-type"));
  resp.bodyHandler(buff -> {
   assertEquals("Welcome to SockJS!\n", buff.toString());
   complete();
  });
 }));
}

@Test
public void testRerouteClearHeader2() throws Exception {
 router.get("/users/:name").handler(ctx -> {
  ctx.response().putHeader("X-woop", "durp2");
  ctx.response().end("/users/:name");
 });
 router.get("/me").handler(ctx -> {
  ctx.response().putHeader("X-woop", "durp");
  ctx.reroute("/users/paulo");
 });
 testRequest(HttpMethod.GET, "/me", null, res -> assertEquals("durp2", res.getHeader("X-woop")), 200, "OK", "/users/:name");
}

Javadoc

Return the first header value with the specified name

Popular methods of HttpClientResponse

statusCode
bodyHandler
Convenience method for receiving the entire request body in one piece. This saves you having to manu
statusMessage
headers
exceptionHandler
endHandler
handler
pause
resume
request
cookies
netSocket
Get a net socket for the underlying connection of this request. USE THIS WITH CAUTION! Writing to th

Popular in Java

Creating JSON documents from java classes using gson
notifyDataSetChanged (ArrayAdapter)
requestLocationUpdates (LocationManager)
compareTo (BigDecimal)
Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
Menu (java.awt)
ServerSocket (java.net)
This class represents a server-side socket that waits for incoming client connections. A ServerSocke
LinkedHashMap (java.util)
Hash table and linked list implementation of the Map interface, with predictable iteration order. Th
List (java.util)
A List is a collection which maintains an ordering for its elements. Every element in the List has a
Annotation (javassist.bytecode.annotation)
The annotation structure.An instance of this class is returned bygetAnnotations() in AnnotationsAttr
JFileChooser (javax.swing)

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

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

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