java.net.http.HttpClient.Version Java Examples

public static void pushRequest() throws URISyntaxException, InterruptedException {
    System.out.println("Running HTTP/2 Server Push example...");

    HttpClient httpClient = HttpClient.newBuilder()
        .version(Version.HTTP_2)
        .build();

    HttpRequest pageRequest = HttpRequest.newBuilder()
        .uri(URI.create("https://http2.golang.org/serverpush"))
        .build();

    // Interface HttpResponse.PushPromiseHandler<T>
    // void applyPushPromise​(HttpRequest initiatingRequest, HttpRequest pushPromiseRequest, Function<HttpResponse.BodyHandler<T>,​CompletableFuture<HttpResponse<T>>> acceptor)
    httpClient.sendAsync(pageRequest, BodyHandlers.ofString(), pushPromiseHandler())
        .thenAccept(pageResponse -> {
            System.out.println("Page response status code: " + pageResponse.statusCode());
            System.out.println("Page response headers: " + pageResponse.headers());
            String responseBody = pageResponse.body();
            System.out.println(responseBody);
        }).join();

    Thread.sleep(1000); // waiting for full response
}
 

@SneakyThrows
	private HttpClient buildClient() {
		Builder builder = HttpClient.newBuilder();
		if (!HttpOptionsPluginProvider.options().isHttp2Support()){
			builder.version(Version.HTTP_1_1);
		}

		if (HttpOptionsPluginProvider.options().isUseProxy()) {
			URL url = new URL(HttpOptionsPluginProvider.options().getProxyUrl());
			builder.proxy(new ProxyExclusionRoutePlanner(url, HttpOptionsPluginProvider.options().getProxyExclusion()).java());
			
			//we dont use Authenticator because it might result in an exception if there is a 401 response
			// see https://github.com/AdoptOpenJDK/openjdk-jdk11/blob/master/src/java.net.http/share/classes/jdk/internal/net/http/AuthenticationFilter.java#L263
			//we manually add Proxy-Authorization header instead
//			if (proxyCredentials != null) {
//				builder.authenticator(new Authenticator() {
//					@Override
//					protected PasswordAuthentication getPasswordAuthentication() {
//						return proxyCredentials;
//					}
//				});
//			}
		}

		if (!HttpOptionsPluginProvider.options().isCertificateValidation()) {
			disableSsl(builder);
		}
		
		if (HttpOptionsPluginProvider.options().isFollowRedirects()) {
			builder.followRedirects(Redirect.ALWAYS);
		}

		setupSslLegacyProtocolSupport(builder);

		return builder
				.build();
	}
 

private void buildStatusView(ResponseInfo httpResponse, RestResponseContainer response, long responseTimeInMs) {
	String versionStr = httpResponse.version().toString();
	if (httpResponse.version() == Version.HTTP_1_1) {
		versionStr = "1.1";
	} else if (httpResponse.version() == Version.HTTP_2) {
		versionStr = "2.0";
	}
	LinkedHashMap<String, String> statusKeys = new LinkedHashMap<>();
	statusKeys.put("Status", ""+httpResponse.statusCode());
	statusKeys.put("Time", responseTimeInMs + "ms");
	statusKeys.put("Http", versionStr);
	
	response.getStatusInformations().complete(statusKeys);
}
 

public OreKitDataClient(List<String> urls) {
	if (urls == null || urls.isEmpty()) {
		throw new IllegalArgumentException("urls are blank. at least 1 is expected");
	}
	this.urls = urls;
	this.httpclient = HttpClient.newBuilder().version(Version.HTTP_2).followRedirects(Redirect.NORMAL).connectTimeout(Duration.ofMillis(TIMEOUT)).build();
}
 

public RestClient(String baseUrl) throws Exception {
	if (baseUrl == null) {
		this.baseUrl = "http://localhost:8097";
	} else {
		this.baseUrl = baseUrl;
	}
	this.httpclient = HttpClient.newBuilder().version(Version.HTTP_2).followRedirects(Redirect.NORMAL).connectTimeout(Duration.ofMinutes(1L)).build();
}
 

public static void httpGetRequest() throws URISyntaxException, IOException, InterruptedException {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
        .version(HttpClient.Version.HTTP_2)
        .uri(URI.create("http://jsonplaceholder.typicode.com/posts/1"))
        .headers("Accept-Enconding", "gzip, deflate")
        .build();
    HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

    String responseBody = response.body();
    int responseStatusCode = response.statusCode();

    System.out.println("httpGetRequest: " + responseBody);
    System.out.println("httpGetRequest status code: " + responseStatusCode);
}
 

public static void httpPostRequest() throws URISyntaxException, IOException, InterruptedException {
    HttpClient client = HttpClient.newBuilder()
        .version(HttpClient.Version.HTTP_2)
        .build();
    HttpRequest request = HttpRequest.newBuilder(new URI("http://jsonplaceholder.typicode.com/posts"))
        .version(HttpClient.Version.HTTP_2)
        .POST(BodyPublishers.ofString("Sample Post Request"))
        .build();
    HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
    String responseBody = response.body();
    System.out.println("httpPostRequest : " + responseBody);
}
 

public static void asynchronousGetRequest() throws URISyntaxException {
    HttpClient client = HttpClient.newHttpClient();
    URI httpURI = new URI("http://jsonplaceholder.typicode.com/posts/1");
    HttpRequest request = HttpRequest.newBuilder(httpURI)
        .version(HttpClient.Version.HTTP_2)
        .build();
    CompletableFuture<Void> futureResponse = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
        .thenAccept(resp -> {
            System.out.println("Got pushed response " + resp.uri());
            System.out.println("Response statuscode: " + resp.statusCode());
            System.out.println("Response body: " + resp.body());
        });
    System.out.println("futureResponse" + futureResponse);

}
 

@Override
public Version version() {
	return null;
}
 

public R2ServerClient(Configuration config) {
	this.config = config;
	this.hostname = config.getProperty("r2server.hostname");
	this.httpclient = HttpClient.newBuilder().version(Version.HTTP_2).followRedirects(Redirect.NORMAL).connectTimeout(Duration.ofMillis(config.getInteger("r2server.connectionTimeout"))).build();
}
 

public NoIpClient(String hostname, String username, String password) {
	this.hostname = hostname;
	this.username = username;
	this.password = password;
	this.httpclient = HttpClient.newBuilder().version(Version.HTTP_2).followRedirects(Redirect.NORMAL).connectTimeout(Duration.ofMinutes(1L)).build();
}
 

public ExternalIpClient(String host) {
	this.host = host;
	this.httpclient = HttpClient.newBuilder().version(Version.HTTP_2).followRedirects(Redirect.NORMAL).connectTimeout(Duration.ofMinutes(1L)).build();
}
 

public Http2Client() {
  this(HttpClient.newBuilder()
      .followRedirects(Redirect.ALWAYS)
      .version(Version.HTTP_2)
      .build());
}