HttpClientDemo.java

// get status code
HttpClient client = HttpClientBuilder.create().build(); 
HttpResponse response = client.execute(new HttpGet(SAMPLE_URL)); 
int statusCode = response.getStatusLine().getStatusCode();
assertThat(statusCode, equalTo(HttpStatus.SC_OK));

// set timeout
//  !!the Connection Timeout (http.connection.timeout) – the time to establish the connection with the remote host
//  !!the Socket Timeout (http.socket.timeout) – the time waiting for data – after the connection was established; maximum time of inactivity between two data packets
//  the Connection Manager Timeout (http.connection- manager.timeout) – the time to wait for a connection from the connection manager/pool 

//set timeout parameter as map key-value
DefaultHttpClient httpClient = new DefaultHttpClient();
int timeout = 5; // seconds
HttpParams httpParams = httpClient.getParams(); 
httpParams.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, timeout * 1000); 
httpParams.setParameter(CoreConnectionPNames.SO_TIMEOUT, timeout * 1000);

// set timeout paramter via API
DefaultHttpClient httpClient = new DefaultHttpClient();
int timeout = 5; // seconds
HttpParams httpParams = httpClient.getParams(); 
HttpConnectionParams.setConnectionTimeout(httpParams, timeout * 1000);
HttpConnectionParams.setSoTimeout(httpParams, timeout * 1000);

// set timeout in 4.3 fluent API
int timeout = 5;
RequestConfig config = RequestConfig.custom()
  .setConnectTimeout(timeout * 1000) 
  .setConnectionRequestTimeout(timeout * 1000) 
  .setSocketTimeout(timeout * 1000).build();
CloseableHttpClient client = HttpClientBuilder.create()
  .setDefaultRequestConfig(config).build();
  
// perform HTTP requests
HttpGet getMethod = new HttpGet("http://host:8080/path");
HttpResponse response = httpClient.execute(getMethod);
System.out.println("HTTP Status of response: " + response.getStatusLine().getStatusCode());

// implement hard timeout for whole request: simple delayed task abort request after delayed time
HttpGet getMethod = new HttpGet ("http://localhost:8080/spring-security-rest-template/api/bars/1");
int hardTimeout = 5; // seconds 
TimerTask task = new TimerTask() {
  @Override
  public void run() {
    if (getMethod != null) {
      getMethod.abort(); 
    }
  }
};
new Timer(true).schedule(task, hardTimeout * 1000);

HttpResponse response = httpClient.execute(getMethod);
System.out.println("HTTP Status of response: " + response.getStatusLine().getStatusCode());

// abort request
HttpClient instance = HttpClients.custom().build(); 
HttpGet request = new HttpGet(SAMPLE_URL); 
HttpResponse response = instance.execute(request);
try { 
  System.out.println(response.getStatusLine()); 
  request.abort();
} finally { 
  response.close();
}

// stop following redirect !!by default redirect is followed

// disable follow redirect before version 4.3
DefaultHttpClient instance = new DefaultHttpClient();
HttpParams params = new BasicHttpParams(); 
params.setParameter(ClientPNames.HANDLE_REDIRECTS, false); // actual raw parameter 
// HttpClientParams.setRedirecting(params, false); // alternative
HttpGet httpGet = new HttpGet("http://t.co/I5YYd9tddw"); 
httpGet.setParams(params);
CloseableHttpResponse response = instance.execute(httpGet); 
assertThat(response.getStatusLine().getStatusCode(), equalTo(301));

// disable follow redirect after version 4.3
HttpClient instance = HttpClientBuilder.create().disableRedirectHandling().build(); 
HttpResponse response = instance.execute(new HttpGet("http://t.co/I5YYd9tddw"));
assertThat(response.getStatusLine().getStatusCode(), equalTo(301));

// set header

// set header before 4.3
HttpClient client = new DefaultHttpClient();
HttpGet request = new HttpGet(SAMPLE_URL); 
request.setHeader(HttpHeaders.CONTENT_TYPE, "application/json"); 
client.execute(request);

// set header after 4.3 fluent API
HttpClient client = HttpClients.custom().build();
HttpUriRequest request = RequestBuilder.get()
  .setUri(SAMPLE_URL)
  .setHeader(HttpHeaders.CONTENT_TYPE, "application/json")
  .build(); 
client.execute(request);

// set default header for every request >= 4.3
Header header = new BasicHeader(HttpHeaders.CONTENT_TYPE, "application/json"); 
List<Header> headers = Lists.newArrayList(header);
HttpClient client = HttpClients.custom().setDefaultHeaders(headers).build(); 
HttpUriRequest request = RequestBuilder.get().setUri(SAMPLE_URL).build(); 
client.execute(request);

// SSL

// accept all certificates
TrustStrategy acceptingTrustStrategy = new TrustStrategy() { 
  @Override
  public boolean isTrusted(X509Certificate[] certificate, String authType) { 
    return true;
  } 
};
SSLSocketFactory sf = new SSLSocketFactory(acceptingTrustStrategy, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("https", 8443, sf));
ClientConnectionManager ccm = new PoolingClientConnectionManager(registry);
DefaultHttpClient httpClient = new DefaultHttpClient(ccm);
String urlOverHttps = "https://localhost:8443/spring-security-rest-basic-auth/api/bars/1";
HttpGet getMethod = new HttpGet(urlOverHttps);
HttpResponse response = httpClient.execute(getMethod); 
assertThat(response.getStatusLine().getStatusCode(), equalTo(200));

// SSL with RestTemplate
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
DefaultHttpClient httpClient = (DefaultHttpClient) requestFactory.getHttpClient(); 
TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
  @Override
  public boolean isTrusted(X509Certificate[] certificate, String authType) { 
    return true;
  }
};
SSLSocketFactory sf = new SSLSocketFactory(acceptingTrustStrategy, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 8443, sf));
String urlOverHttps = "https://localhost:8443/spring-security-rest-basic-auth/api/bars/1";
ResponseEntity<String> response = new RestTemplate(requestFactory)
  .exchange(urlOverHttps, HttpMethod.GET, null, String.class);
assertThat(response.getStatusCode().value(), equalTo(200));

// send custom cookies >=4.3 on httpclient
BasicCookieStore cookieStore = new BasicCookieStore();
BasicClientCookie cookie = new BasicClientCookie("JSESSIONID", "1234"); 
cookie.setDomain(".github.com"); // important to set
cookie.setPath("/");
cookieStore.addCookie(cookie);
HttpClient client = HttpClientBuilder.create()
  .setDefaultCookieStore(cookieStore).build();
final HttpGet request = new HttpGet("http://www.github.com");
response = client.execute(request); 
assertThat(response.getStatusLine().getStatusCode(), equalTo(200));

// send custom cookies < 4.3 on httpclient
BasicCookieStore cookieStore = new BasicCookieStore(); 
BasicClientCookie cookie = new BasicClientCookie("JSESSIONID", "1234"); 
cookie.setDomain(".github.com");
cookie.setPath("/");
cookieStore.addCookie(cookie);
DefaultHttpClient client = new DefaultHttpClient(); 
client.setCookieStore(cookieStore);
HttpGet request = new HttpGet("http://www.github.com"); 
response = client.execute(request);
assertThat(response.getStatusLine().getStatusCode(), equalTo(200));

// send custom cookies on request
BasicCookieStore cookieStore = new BasicCookieStore(); 
BasicClientCookie cookie = new BasicClientCookie("JSESSIONID", "1234"); 
cookie.setDomain(".github.com");
cookie.setPath("/");
cookieStore.addCookie(cookie);
instance = HttpClientBuilder.create().build();
HttpGet request = new HttpGet("http://www.github.com");
HttpContext localContext = new BasicHttpContext(); 
localContext.setAttribute(HttpClientContext.COOKIE_STORE, cookieStore);
// localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore); // before 4.3 
response = instance.execute(request, localContext);
assertThat(response.getStatusLine().getStatusCode(), equalTo(200));

// low level cookie setting
instance = HttpClientBuilder.create().build();
HttpGet request = new HttpGet("http://www.github.com"); 
request.setHeader("Cookie", "JSESSIONID=1234");
response = instance.execute(request); 
assertThat(response.getStatusLine().getStatusCode(), equalTo(200));

// follow redirect on post !!by default is NOT followed

// follow redirect on post >= 4.3
HttpClient instance =
  HttpClientBuilder.create().setRedirectStrategy(new LaxRedirectStrategy()).build();
HttpResponse response = instance.execute(new HttpPost("http://t.co/I5YYd9tddw")); 
assertThat(response.getStatusLine().getStatusCode(), equalTo(200));

// follow redirect on post = 4.2
DefaultHttpClient client = new DefaultHttpClient(); 
client.setRedirectStrategy(new LaxRedirectStrategy());
HttpResponse response = client.execute(new HttpPost("http://t.co/I5YYd9tddw")); 
assertThat(response.getStatusLine().getStatusCode(), equalTo(200));

// follow redirect < 4.2
DefaultHttpClient client = new DefaultHttpClient(); 
client.setRedirectStrategy(new DefaultRedirectStrategy() {
  /** Redirectable methods. */
  private String[] REDIRECT_METHODS = new String[] { HttpGet.METHOD_NAME, HttpPost.METHOD_NAME, HttpHead.METHOD_NAME };
  @Override
  protected boolean isRedirectable(String method) { 
    for (String m : REDIRECT_METHODS) {
      if (m.equalsIgnoreCase(method)) { return true; }
    }
    return false; 
  }
});

// basic authentication
CredentialsProvider provider = new BasicCredentialsProvider();
UsernamePasswordCredentials credentials = new UsernamePasswordCredentials("user1", "user1Pass"); 
provider.setCredentials(AuthScope.ANY, credentials);
HttpClient client = HttpClientBuilder.create().setDefaultCredentialsProvider(provider).build();
HttpResponse response = client.execute(new HttpGet(URL_SECURED_BY_BASIC_AUTHENTICATION)); 
int statusCode = response.getStatusLine().getStatusCode();
assertThat(statusCode, equalTo(HttpStatus.SC_OK));

// preemptive authentication !!not supported by default
// i.e. pre-sending the Authorization header.
HttpHost targetHost = new HttpHost("localhost", 8080, "http"); 
CredentialsProvider credsProvider = new BasicCredentialsProvider(); 
credsProvider.setCredentials(AuthScope.ANY,
new UsernamePasswordCredentials(DEFAULT_USER, DEFAULT_PASS)); 
AuthCache authCache = new BasicAuthCache();
authCache.put(targetHost, new BasicScheme()); // Add AuthCache to the execution context
final HttpClientContext context = HttpClientContext.create(); 
context.setCredentialsProvider(credsProvider); 
context.setAuthCache(authCache);

HttpClient client = HttpClientBuilder.create().build();
response = client.execute(new HttpGet(URL_SECURED_BY_BASIC_AUTHENTICATION), context);
intstatusCode=response.getStatusLine().getStatusCode(); 

// basic auth with raw header
HttpGet request = new HttpGet(URL_SECURED_BY_BASIC_AUTHENTICATION);
String auth = DEFAULT_USER + ":" + DEFAULT_PASS;
byte[] encodedAuth = Base64.encodeBase64(auth.getBytes(Charset.forName("US-ASCII")));
String authHeader = "Basic " + new String(encodedAuth);
request.setHeader(HttpHeaders.AUTHORIZATION, authHeader);
HttpClient client = HttpClientBuilder.create().build(); 
HttpResponse response = client.execute(request);
intstatusCode=response.getStatusLine().getStatusCode(); 
assertThat(statusCode, equalTo(HttpStatus.SC_OK));