Java Code Examples for org.apache.http.impl.client.HttpClientBuilder#create()

public CloseableHttpResponse post(String url, ContentType contentType, String data, String username, String password) {
    logger.debug("{}: Sending POST request url={} contentType={} data={}", applianceId, url, contentType, data);
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    withUsernameAndPassword(httpClientBuilder, username, password);
    CloseableHttpClient client = httpClientBuilder.setDefaultRequestConfig(getRequestConfig()).build();
    try {
        HttpPost request = new HttpPost(url);
        request.setEntity(new StringEntity(data, contentType));
        CloseableHttpResponse response = client.execute(request);
        return logResponse(response);
    }
    catch(IOException e) {
        logger.error("{}: Error executing POST", applianceId, e);
        return null;
    }
}
 

public void testHttpProxy() throws IOException {
    Settings.setLoggingLevel("org.apache.http.wire", Level.DEBUG);
    Settings.setLoggingLevel("org.apache.http", Level.DEBUG);

    String proxyHost = Settings.getProperty("davmail.proxyHost");
    int proxyPort = Settings.getIntProperty("davmail.proxyPort");
    HttpHost proxy = new HttpHost(proxyHost, proxyPort);
    HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    clientBuilder.setProxy(proxy).setUserAgent(DavGatewayHttpClientFacade.IE_USER_AGENT);

    clientBuilder.setDefaultCredentialsProvider(getProxyCredentialProvider());

    try (CloseableHttpClient httpClient = clientBuilder.build()) {
        HttpGet httpget = new HttpGet("http://davmail.sourceforge.net/version.txt");
        try (CloseableHttpResponse response = httpClient.execute(httpget)) {
            String responseString = new BasicResponseHandler().handleResponse(response);
            System.out.println(responseString);
        }
    }
}
 

public CloseableHttpClient build() {
  HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
  httpClientBuilder.setConnectionManager( manager );

  RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
  if ( socketTimeout > 0 ) {
    requestConfigBuilder.setSocketTimeout( socketTimeout );
  }
  if ( connectionTimeout > 0 ) {
    requestConfigBuilder.setConnectTimeout( socketTimeout );
  }
  if ( proxy != null ) {
    requestConfigBuilder.setProxy( proxy );
  }
  httpClientBuilder.setDefaultRequestConfig( requestConfigBuilder.build() );

  if ( provider != null ) {
    httpClientBuilder.setDefaultCredentialsProvider( provider );
  }
  if ( redirectStrategy != null ) {
    httpClientBuilder.setRedirectStrategy( redirectStrategy );
  }

  return httpClientBuilder.build();
}
 

/**
 * Creates a {@link HttpClientBuilder} considering current settings.
 * 
 * @return a {@link HttpClientBuilder} considering current settings.
 */
public HttpClientBuilder createHttpClientBuilder() {
	HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
	if (getHttpProxy() != null
			&& StringUtils.isNotBlank(getHttpProxy().getHost())) {
		httpClientBuilder = httpClientBuilder.setProxy(new HttpHost(
				getHttpProxy().getHost(), getHttpProxy().getPort(),
				getHttpProxy().getSchema()));
		if (StringUtils.isNotBlank(getHttpProxy().getUser())) {
			Credentials credentials = new UsernamePasswordCredentials(
					getHttpProxy().getUser(), getHttpProxy().getPassword());
			AuthScope authScope = new AuthScope(getHttpProxy().getHost(),
					getHttpProxy().getPort());
			CredentialsProvider credsProvider = new BasicCredentialsProvider();
			credsProvider.setCredentials(authScope, credentials);
			httpClientBuilder = httpClientBuilder
					.setDefaultCredentialsProvider(credsProvider);
			httpClientBuilder.useSystemProperties();
		}
	}
	return httpClientBuilder;
}
 

public static void getMnistPNG() throws IOException {
    String tmpDirStr = System.getProperty("java.io.tmpdir");
    String archizePath = DATA_PATH + "/mnist_png.tar.gz";

    if (tmpDirStr == null) {
        throw new IOException("System property 'java.io.tmpdir' does specify a tmp dir");
    }
    String url = "http://github.com/myleott/mnist_png/raw/master/mnist_png.tar.gz";
    File f = new File(archizePath);
    File dir = new File(tmpDirStr);
    if (!f.exists()) {
        HttpClientBuilder builder = HttpClientBuilder.create();
        CloseableHttpClient client = builder.build();
        try (CloseableHttpResponse response = client.execute(new HttpGet(url))) {
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                try (FileOutputStream outstream = new FileOutputStream(f)) {
                    entity.writeTo(outstream);
                    outstream.flush();
                    outstream.close();
                }
            }

        }
        System.out.println("Data downloaded to " + f.getAbsolutePath());
    } else {
        System.out.println("Using existing directory at " + f.getAbsolutePath());
    }

}
 

/**
 * Creates a httpcomponents HttpClient for service invocation.
    *
    * <p>The client is configured by the HttpClientConfigurer</p>
 */
public HttpClient getHttpClient() {
       HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

       getHttpClientConfigurer().customizeHttpClient(httpClientBuilder);

       return httpClientBuilder.build();
}
 

public void testBasicGetRequest() throws IOException {
    HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    try (CloseableHttpClient httpClient = clientBuilder.build()) {
        HttpGet httpget = new HttpGet("http://davmail.sourceforge.net/version.txt");
        try (CloseableHttpResponse response = httpClient.execute(httpget)) {
            String responseString = new BasicResponseHandler().handleResponse(response);
            System.out.println(responseString);
        }
    }
}
 

protected HttpActivityExecutor createHttpActivityExecutor() {
    HttpClientConfig config = CommandContextUtil.getCmmnEngineConfiguration().getHttpClientConfig();
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

    // https settings
    if (config.isDisableCertVerify()) {
        try {
            SSLContextBuilder builder = new SSLContextBuilder();
            builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
            httpClientBuilder.setSSLSocketFactory(
                    new SSLConnectionSocketFactory(builder.build(), new HostnameVerifier() {
                        @Override
                        public boolean verify(String s, SSLSession sslSession) {
                            return true;
                        }
                    }));

        } catch (Exception e) {
            LOGGER.error("Could not configure HTTP client SSL self signed strategy", e);
        }
    }

    // request retry settings
    int retryCount = 0;
    if (config.getRequestRetryLimit() > 0) {
        retryCount = config.getRequestRetryLimit();
    }
    httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(retryCount, false));

    // client builder settings
    if (config.isUseSystemProperties()) {
        httpClientBuilder.useSystemProperties();
    }

    return new HttpActivityExecutor(httpClientBuilder, new NopErrorPropagator(),
            CommandContextUtil.getCmmnEngineConfiguration().getObjectMapper());
}
 

public static String getFileInfo(String baseUrl, String externalId, String receiverAddress, String urkundUsername, String urkundPassword, int timeout){
	String ret = null;
	RequestConfig.Builder requestBuilder = RequestConfig.custom();
	requestBuilder = requestBuilder.setConnectTimeout(timeout);
	requestBuilder = requestBuilder.setConnectionRequestTimeout(timeout);
	
	HttpClientBuilder builder = HttpClientBuilder.create();     
	builder.setDefaultRequestConfig(requestBuilder.build());
	try (CloseableHttpClient httpClient = builder.build()) {
		HttpGet httpget = new HttpGet(baseUrl+"submissions/"+receiverAddress+"/"+externalId);
		
		//------------------------------------------------------------
		if(StringUtils.isNotBlank(urkundUsername) && StringUtils.isNotBlank(urkundPassword)) {
			addAuthorization(httpget, urkundUsername, urkundPassword);
		}
		//------------------------------------------------------------
		httpget.addHeader("Accept", "application/json");
		//------------------------------------------------------------
		
		HttpResponse response = httpClient.execute(httpget);
		HttpEntity resEntity = response.getEntity();

		if (resEntity != null) {
			ret = EntityUtils.toString(resEntity);
			EntityUtils.consume(resEntity);
		}
		
	} catch (IOException e) {
		log.error("ERROR getting File Info : ", e);
	}
	return ret;
}
 

@Test
public void testSingleFileUpload(@TempDir Path tempDir) throws IOException {
    // given
    String host = Application.getInstance(Config.class).getConnectorHttpHost();
    int port = Application.getInstance(Config.class).getConnectorHttpPort();
    MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
    multipartEntityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

    // when
       Path path = tempDir.resolve(UUID.randomUUID().toString());
       InputStream attachment = Resources.getResource("attachment.txt").openStream();
       Files.copy(attachment, path);
       multipartEntityBuilder.addPart("attachment", new FileBody(path.toFile()));
       HttpPost httpPost = new HttpPost("http://" + host + ":" + port + "/singlefile");
       httpPost.setEntity(multipartEntityBuilder.build());

       String response = null;
       HttpResponse httpResponse = httpClientBuilder.build().execute(httpPost);

       HttpEntity httpEntity = httpResponse.getEntity();
       if (httpEntity != null) {
           response = EntityUtils.toString(httpEntity);
       }

	// then
	assertThat(httpResponse, not(nullValue()));
	assertThat(response, not(nullValue()));
	assertThat(httpResponse.getStatusLine().getStatusCode(), equalTo(StatusCodes.OK));
	assertThat(response, equalTo("This is an attachment"));
}
 

private void sendRequest(HttpEntity entity) {
    try {
        HttpPost post = new HttpPost("http://localhost:8080/get?a=1&b=b.34&a=4");
        post.setEntity(entity);
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        CloseableHttpClient hc = httpClientBuilder.build();
        hc.execute(post);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

private CloseableHttpClient getHttpClient() {
    if (this.httpClient != null) {
        return this.httpClient;
    }
    PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
    connManager.setDefaultMaxPerRoute(6);
    connManager.setMaxTotal(20);
    connManager.closeIdleConnections(120, TimeUnit.SECONDS);
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    //SOFATracer
    SofaTracerHttpClientBuilder.clientBuilder(httpClientBuilder);
    httpClient = httpClientBuilder.setConnectionManager(connManager).disableAutomaticRetries()
        .setUserAgent("CLIENT_VERSION").build();
    return httpClient;
}
 

public void initHttpClient() {
		HttpClientBuilder builder = HttpClientBuilder.create();
		
		PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
		connManager.setMaxTotal(100);
		connManager.setDefaultMaxPerRoute(100);
		builder.setConnectionManager(connManager);
		builder.disableAutomaticRetries();
		
//		builder.addInterceptorFirst(new HttpRequestInterceptor() {
//			public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException {
//				if (!request.containsHeader("Accept-Encoding")) {
//					request.addHeader("Accept-Encoding", "gzip");
//				}
//			}
//		});
//
//		builder.addInterceptorFirst(new HttpResponseInterceptor() {
//			public void process(final HttpResponse response, final HttpContext context) throws HttpException, IOException {
//				HttpEntity entity = response.getEntity();
//				if (entity != null) {
//					Header ceheader = entity.getContentEncoding();
//					if (ceheader != null) {
//						HeaderElement[] codecs = ceheader.getElements();
//						for (int i = 0; i < codecs.length; i++) {
//							if (codecs[i].getName().equalsIgnoreCase("gzip")) {
//								response.setEntity(new GzipDecompressingEntity(response.getEntity()));
//								return;
//							}
//						}
//					}
//				}
//			}
//		});

		httpClient = builder.build();
	}
 

public static byte[] getBytes(String url, int timeout) throws Exception {
    long start = System.currentTimeMillis();
    HttpClientBuilder builder = HttpClientBuilder.create();
    builder.setMaxConnPerRoute(50);
    builder.setMaxConnTotal(100);
    CloseableHttpClient httpclient = builder.build();
    URI uri = new URIBuilder(url).build();
    RequestConfig config = custom().setConnectTimeout(timeout)
        .setConnectionRequestTimeout(timeout)
        .setSocketTimeout(timeout)
        .build();
    HttpGet httpGet = new HttpGet(uri);
    HttpClientContext context = HttpClientContext.create();
    context.setRequestConfig(config);
    CloseableHttpResponse response = httpclient.execute(httpGet, context);
    try {
        int statusCode = response.getStatusLine().getStatusCode();
        long end = System.currentTimeMillis();
        long cost = end - start;
        if (logger.isWarnEnabled()) {
            logger.warn("post " + url + ", cost : " + cost);
        }
        if (statusCode == HttpStatus.SC_OK) {
            return EntityUtils.toByteArray(response.getEntity());
        } else {
            String errorMsg = EntityUtils.toString(response.getEntity());
            throw new RuntimeException("requestGet remote error, url=" + uri.toString() + ", code=" + statusCode
                                       + ", error msg=" + errorMsg);
        }
    } finally {
        response.close();
        httpGet.releaseConnection();
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public Object getSemanticInterpretation(final DataModel model,
        String utterance) {
    final HttpClientBuilder builder = HttpClientBuilder.create();
    if (PROXY_HOST != null) {
        HttpHost proxy = new HttpHost(PROXY_HOST, PROXY_PORT);
        builder.setProxy(proxy);
    }
    try (CloseableHttpClient client = builder.build()){
        final URIBuilder uribuilder = new URIBuilder(grammarUri);
        uribuilder.addParameter("subscription-key", subscriptionKey);
        uribuilder.addParameter("q", utterance);
        final URI uri = uribuilder.build();
        final HttpGet request = new HttpGet(uri);
        final HttpResponse response = client.execute(request);
        final StatusLine statusLine = response.getStatusLine();
        final int status = statusLine.getStatusCode();
        if (status != HttpStatus.SC_OK) {
            final String reasonPhrase = statusLine.getReasonPhrase();
            LOGGER.error("error accessing '" + uri +"': " +
                    reasonPhrase + " (HTTP error code "
                    + status + ")");
            return null;
        }
        final HttpEntity entity = response.getEntity();
        final InputStream input = entity.getContent();
        final Object interpretation = parseLUISResponse(model, input);
        return interpretation;
    } catch (IOException | URISyntaxException | ParseException | SemanticError e) {
        LOGGER.error(e.getMessage(), e);
        return null;
    }
}
 

public static CloseableHttpClient createHttpClient(int concurrency) {
	HttpClientBuilder builder = HttpClientBuilder.create();

	PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
	connManager.setDefaultMaxPerRoute(concurrency);
	connManager.setMaxTotal(concurrency);

	RequestConfig requestConfig = RequestConfig.custom()//
			.setAuthenticationEnabled(true)//
			.setSocketTimeout(SOCKET_TIMEOUT)//
			.setConnectionRequestTimeout(CONNECTION_REQUEST_TIMEOUT)//
			.setConnectTimeout(CONNECT_TIMEOUT)//
			.setRedirectsEnabled(true)//
			.setRelativeRedirectsAllowed(true)//
			.setMaxRedirects(15)//
			.build();

	SocketConfig socketConfig = SocketConfig.custom()//
			.setSoKeepAlive(true)//
			.setSoReuseAddress(true)//
			.build();

	builder.setConnectionManager(connManager);
	builder.setDefaultSocketConfig(socketConfig);
	builder.setDefaultRequestConfig(requestConfig);

	return builder.build();
}
 

public static CloseableHttpClient acceptsUntrustedCertsHttpClient(boolean withProxy, ProxyHostInfo hostInfo, int connectionTimeout, int connectionRequestTimeout, int socketTimeout)
		throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
	HttpClientBuilder b = HttpClientBuilder.create();
	
	/**
	 * set http proxy
	 */
	
	b.setDefaultRequestConfig( 
			RequestConfig.custom().setConnectTimeout(connectionTimeout).setConnectionRequestTimeout(connectionRequestTimeout).setSocketTimeout(socketTimeout).build()
			);
	
	if(withProxy){
		HttpHost proxy=new HttpHost(hostInfo.getHostName(),hostInfo.getPort());
		b.setProxy(proxy);
		CredentialsProvider credsProvider = new BasicCredentialsProvider();
		credsProvider.setCredentials(
				new AuthScope(proxy.getHostName(), proxy.getPort()),
				new UsernamePasswordCredentials(hostInfo.getUserName(), hostInfo.getPassword()));
		b.setDefaultCredentialsProvider(credsProvider);
	}
	
	SSLContext sslContext = new SSLContextBuilder().useProtocol("TLSv1.2").loadTrustMaterial(null, new TrustStrategy() {
		public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
			return true;
		}
	}).build();
	b.setSSLContext(sslContext);
	b.setConnectionTimeToLive(180, TimeUnit.SECONDS);

	HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE;

	SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
	Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
			.register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", sslSocketFactory)
			.build();

	PoolingHttpClientConnectionManager connMgr = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
	connMgr.setMaxTotal(200);
	connMgr.setDefaultMaxPerRoute(100);
	b.setConnectionManager(connMgr);
	CloseableHttpClient client = b.build();
	return client;
}
 

private static HttpClient initWeakSSLClient() {
    HttpClientBuilder b = HttpClientBuilder.create();
    // setup a Trust Strategy that allows all certificates.
    //
    SSLContext sslContext = null;
    try {
        sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
            public boolean isTrusted(X509Certificate[] arg0, String arg1) {
                return true;
            }
        }).build();
    } catch (NoSuchAlgorithmException | KeyManagementException | KeyStoreException e) {
        // do nothing, has been handled outside
    }
    b.setSslcontext(sslContext);

    // don't check Hostnames, either.
    // -- use SSLConnectionSocketFactory.getDefaultHostnameVerifier(), if you don't want to weaken
    X509HostnameVerifier hostnameVerifier = SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;

    // here's the special part:
    // -- need to create an SSL Socket Factory, to use our weakened "trust strategy";
    // -- and create a Registry, to register it.
    //
    SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
    Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
            .register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", sslSocketFactory)
            .build();

    // now, we create connection-manager using our Registry.
    // -- allows multi-threaded use
    PoolingHttpClientConnectionManager connMgr = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
    b.setConnectionManager(connMgr);

    /**
     * Set timeout option
     */
    RequestConfig.Builder configBuilder = RequestConfig.custom();
    configBuilder.setConnectTimeout(TIMEOUT);
    configBuilder.setSocketTimeout(TIMEOUT);
    b.setDefaultRequestConfig(configBuilder.build());

    // finally, build the HttpClient;
    // -- done!
    HttpClient sslClient = b.build();
    return sslClient;
}
 

private String oozieSubmitJob( String user, String password, String request, int status ) throws IOException, URISyntaxException {
    driver.getMock( "OOZIE" )
        .expect()
        .method( "POST" )
        .pathInfo( "/v1/jobs" )
        .respond()
        .status( HttpStatus.SC_CREATED )
        .content( driver.getResourceBytes( "oozie-jobs-submit-response.json" ) )
        .contentType( "application/json" );
    URL url = new URL( driver.getUrl( "OOZIE" ) + "/v1/jobs?action=start" + ( driver.isUseGateway() ? "" : "&user.name=" + user ) );
    HttpHost targetHost = new HttpHost( url.getHost(), url.getPort(), url.getProtocol() );
    HttpClientBuilder builder = HttpClientBuilder.create();
    CloseableHttpClient client = builder.build();

    HttpClientContext context = HttpClientContext.create();
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(
        new AuthScope( targetHost ),
        new UsernamePasswordCredentials( user, password ) );
    context.setCredentialsProvider( credsProvider );

    // Create AuthCache instance
    AuthCache authCache = new BasicAuthCache();
    // Generate BASIC scheme object and add it to the local auth cache
    BasicScheme basicAuth = new BasicScheme();
    authCache.put( targetHost, basicAuth );
    // Add AuthCache to the execution context
    context.setAuthCache( authCache );

    HttpPost post = new HttpPost( url.toURI() );
//      post.getParams().setParameter( "action", "start" );
    StringEntity entity = new StringEntity( request, org.apache.http.entity.ContentType.create( "application/xml", StandardCharsets.UTF_8.name() ) );
    post.setEntity( entity );
    post.setHeader( "X-XSRF-Header", "ksdjfhdsjkfhds" );
    HttpResponse response = client.execute( targetHost, post, context );
    assertThat( response.getStatusLine().getStatusCode(), Matchers.is(status) );
    String json = EntityUtils.toString( response.getEntity() );

//      String json = given()
//          .log().all()
//          .auth().preemptive().basic( user, password )
//          .queryParam( "action", "start" )
//          .contentType( "application/xml;charset=UTF-8" )
//          .content( request )
//          .then()
//          .log().all()
//          .statusCode( status )
//          .when().post( getUrl( "OOZIE" ) + "/v1/jobs" + ( isUseGateway() ? "" : "?user.name=" + user ) ).asString();
    return JsonPath.from(json).getString( "id" );
  }
 

/**
 * Create an authenticated Jenkins HTTP client
 *
 * @param uri Location of the jenkins server (ex. http://localhost:8080)
 * @param username Username to use when connecting
 * @param password Password or auth token to use when connecting
 */
public JenkinsHttpClient(URI uri, String username, String password) {
    this(uri, HttpClientBuilder.create(), username, password);
}