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

Updating database using SQL prepared statement
getApplicationContext (Context)
putExtra (Intent)
setContentView (Activity)
BufferedInputStream (java.io)
A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the i
BufferedReader (java.io)
Wraps an existing Reader and buffers the input. Expensive interaction with the underlying reader is
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
Date (java.sql)
A class which can consume and produce dates in SQL Date format. Dates are represented in SQL as yyyy
Queue (java.util)
A collection designed for holding elements prior to processing. Besides basic java.util.Collection o
JList (javax.swing)

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