Java Examples for org.apache.http.impl.client.CloseableHttpClient

public static void main(String[] args) throws Exception {
    CloseableHttpClient httpProvider = ResourceUtils.getHttpProvider();
    Properties nodeConfig = ResourceUtils.getNodeConfig();
    BtcdClient client = new VerboseBtcdClientImpl(httpProvider, nodeConfig);
    client.getGenerate();
    client.getMiningInfo();
    client.getNetworkHashPs();
    client.getNetworkHashPs(1008);
    client.getNetworkHashPs(2016, 278106);
    client.prioritiseTransaction("4ed1f44942405610af66c01f417d2adb0531bff42dba0dac98864c0ff09d220e", new BigDecimal("189233000.51"), 50000000L);
    client.setGenerate(false);
    client.setGenerate(false, 7);
    client.submitBlock("0400000056ed3621936549216e1cd6b82b07abe29138963c6afc7f64240b00000000000057d" + "6991e2a3de157eeee27ac769f5271ad9824d71e0cdcee7781a73dd3e950b27f74d956ffff001d093e075" + "d0101000000010000000000000000000000000000000000000000000000000000000000000000fffffff" + "f29032a080b1c4b6e434d696e6572544553544e455422220f056a36b48a56d974bf0200000000c77d0d0" + "0ffffffff0140be4025000000001976a91470568a7d32ec60b5e27718c4b9d21bebe9cc178988ac00000" + "000");
    client.submitBlock("0400000056ed3621936549216e1cd6b82b07abe29138963c6afc7f64240b00000000000057d" + "6991e2a3de157eeee27ac769f5271ad9824d71e0cdcee7781a73dd3e950b27f74d956ffff001d093e075" + "d0101000000010000000000000000000000000000000000000000000000000000000000000000fffffff" + "f29032a080b1c4b6e434d696e6572544553544e455422220f056a36b48a56d974bf0200000000c77d0d0" + "0ffffffff0140be4025000000001976a91470568a7d32ec60b5e27718c4b9d21bebe9cc178988ac00000" + "000", new HashMap<String, Object>() {

        {
            put("workid", "3f");
            put("prevworkid", 93);
        }
    });
}

public static void main(String[] args) throws Exception {
    CloseableHttpClient client = HttpUtils.getClient();
    HttpGet get = new HttpGet("https://www.yeepay.com/app-merchant-proxy/node");
    CloseableHttpResponse execute = client.execute(get);
    HttpEntity entity = execute.getEntity();
    String content = EntityUtils.toString(entity);
    System.out.println(content);
    client.close();
}

public static void main(String[] args) {
    RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5 * 1000).setConnectionRequestTimeout(5 * 1000).setSocketTimeout(5 * 1000).build();
    PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
    CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(connManager).setDefaultRequestConfig(requestConfig).build();
    ZabbixApi zabbixApi = new DefaultZabbixApi("http://localhost:10051/zabbix/api_jsonrpc.php", httpclient);
    zabbixApi.init();
    String apiVersion = zabbixApi.apiVersion();
    System.out.println("api version:" + apiVersion);
    zabbixApi.destroy();
}

@Test
public void testProxy() {
    CloseableHttpClient httpClient = HttpClients.createDefault();
    HttpGet httpGet = new HttpGet("http://issp.bjike.com/admin/login");
    httpGet.setHeader("Host", "yinyuetai.musicway.cn");
    httpGet.setConfig(RequestConfig.custom().setProxy(new HttpHost("yinyuetai.musicway.cn", 80)).build());
    try {
        HttpResponse response = httpClient.execute(httpGet);
        System.out.println(EntityUtils.toString(response.getEntity(), Consts.UTF_8));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

/**
     * generator
     * <p>
     * 
     * @author chen.chen.9, 2013-8-19
     * @param timeout
     *            time out
     * @return {@link CloseableHttpClient}
     */
public static CloseableHttpClient generate(int timeout) {
    if (timeout <= 0) {
        timeout = DEFAULT_TIME_OUT;
    }
    RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(timeout).setSocketTimeout(timeout).setConnectTimeout(timeout).build();
    HttpClientBuilder httpClientBuilder = HttpClients.custom().setDefaultRequestConfig(requestConfig);
    return httpClientBuilder.build();
}

@Bean
@Scope("prototype")
@SuppressWarnings("deprecation")
public CloseableHttpClient build() {
    final RequestConfig config = RequestConfig.custom().setConnectionRequestTimeout(1000).setConnectTimeout(1000).setSocketTimeout(1000).build();
    try {
        return HttpClientBuilder.create().disableAuthCaching().disableAutomaticRetries().disableConnectionState().disableCookieManagement().disableRedirectHandling().setDefaultRequestConfig(config).setUserAgent("fullstop-job (https://github.com/zalando-stups/fullstop)").setHostnameVerifier(new AllowAllHostnameVerifier()).setSslcontext(new SSLContextBuilder().loadTrustMaterial(null, ( arrayX509Certificate,  value) -> true).build()).build();
    } catch (NoSuchAlgorithmExceptionKeyManagementException | KeyStoreException |  e) {
        throw new IllegalStateException("Could not initialize httpClient", e);
    }
}

public static HttpClient createUnsafeClient() {
    try {
        SSLContextBuilder builder = new SSLContextBuilder();
        builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        return httpclient;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public static HttpClient createUnsafeClient() {
    try {
        SSLContextBuilder builder = new SSLContextBuilder();
        builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        return httpclient;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Test
public void testTokenRequest() throws ClientProtocolException, IOException {
    HttpPost request = new HttpPost(getBaseURL() + "/token/" + getDatabaseName());
    request.setEntity(new StringEntity("grant_type=password&username=admin&password=admin"));
    final CloseableHttpClient httpClient = HttpClients.createDefault();
    CloseableHttpResponse response = httpClient.execute(request);
    assertEquals(response.getStatusLine().getStatusCode(), 400);
    HttpEntity entity = response.getEntity();
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    entity.writeTo(out);
    assertTrue(out.toString().toString().contains("unsupported_grant_type"));
}

public static HttpClient createUnsafeClient() {
    try {
        SSLContextBuilder builder = new SSLContextBuilder();
        builder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(builder.build());
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        return httpclient;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

/**
	 * To simplify client-side coding, the video should be immediately available for download if 
	 * available. At the time of writing, this work is not done synchronously with the session tear-down,
	 * which complicates video retrieval and storage.
	 * 
	 * @throws Exception
	 */
@Test
public void testVideoImmediatelyAvailable() throws Exception {
    DesiredCapabilities caps = DesiredCapabilities.firefox();
    RemoteWebDriver driver = new RemoteWebDriver(caps);
    System.out.println("Session: " + driver.getSessionId().toString());
    driver.get("http://www.google.com");
    SessionId sessionId = driver.getSessionId();
    driver.quit();
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    HttpGet httpGet = new HttpGet("http://127.0.0.1:4444/grid/admin/HubVideoDownloadServlet?sessionId=" + sessionId.toString());
    CloseableHttpResponse response = httpClient.execute(httpGet);
    Assert.assertEquals(200, response.getStatusLine().getStatusCode());
}

@NotNull
public StashFacade build(Configuration configuration) {
    ConnectorDetails connectorDetails = new ConnectorDetails(configuration);
    StashPatchset stashPatchset = buildStashPatchset(configuration);
    HttpHost httpHost = httpHelper.buildHttpHost(connectorDetails);
    HttpClientContext httpClientContext = httpHelper.buildClientContext(httpHost, new BasicScheme());
    CloseableHttpClient closeableHttpClient = httpHelper.buildClient(httpHost, connectorDetails);
    return new StashFacade(new StashConnector(new HttpConnector(closeableHttpClient, httpClientContext, connectorDetails.getPath()), stashPatchset), configuration);
}

public static void main(String[] args) throws URISyntaxException, HttpException, IOException {
    CloseableHttpClient httpclient = HttpClientBuilder.create().build();
    HttpGet httpget = new HttpGet("http://www.google.com/");
    HttpResponse response = httpclient.execute(httpget);
    HttpEntity entity = response.getEntity();
    if (entity != null) {
        InputStream instream = entity.getContent();
        int l;
        byte[] tmp = new byte[2048];
        while ((l = instream.read(tmp)) != -1) {
            String s = new String(tmp);
            System.out.println(s);
        }
    }
    System.out.println("**************************");
    Header[] elements = response.getAllHeaders();
    for (Header header : elements) {
        System.out.println(header.getName() + " : " + header.getValue());
    }
    System.out.println();
    System.out.println("**************************");
    httpclient.close();
}

public CloseableHttpResponse getResponse() {
    CloseableHttpResponse closeableHttpResponse = null;
    try {
        Setting setting = task.getSetting();
        HttpRequestBase httpMethod;
        httpMethod = HttpClientPool.getInstance().generateHttpMethod(request, task, null);
        HttpClientBuilder httpClientBuilder = HttpClientPool.getInstance().generateClient(setting, httpMethod);
        CloseableHttpClient closeableHttpClient = httpClientBuilder.build();
        closeableHttpResponse = closeableHttpClient.execute(httpMethod);
    } catch (IOException e) {
        e.printStackTrace();
        System.out.println(e);
    }
    return closeableHttpResponse;
}

/**
     * Get an HttpClient given a proxy config if any
     * @param proxyConfiguration configuration of proxy to use
     * @return org.apache.http.impl.client.CloseableHttpClient
     */
CloseableHttpClient getHttpClient(final ProxyConfiguration proxyConfiguration) {
    HttpClientBuilder httpClientBuilder = getHttpClientBuilder();
    if (proxyAuthenticationRequired(proxyConfiguration)) {
        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(new AuthScope(proxyConfiguration.getHost(), proxyConfiguration.getPort()), new UsernamePasswordCredentials(proxyConfiguration.getUsername(), proxyConfiguration.getPassword()));
        httpClientBuilder = httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
    }
    return httpClientBuilder.build();
}

public RestSearchResponse<C> search(String hostname, int port, String index, String type, String body, Class<?> clazz, CloseableHttpClient http) throws ElasticSearchException {
    try {
        HttpGetWithEntity get = new HttpGetWithEntity();
        get.setURI(new URI("http://" + hostname + ":" + port + "/" + index + "/" + type));
        get.setEntity(new StringEntity(body));
        log.fine(get.getURI().toString());
        try (CloseableHttpResponse response = http.execute(get)) {
            HttpEntity entity = response.getEntity();
            // EntityUtils.consume(entity);
            // for (final SearchHit hit : response.getHits()) {
            // final C result =
            // this.mapper.readValue(hit.getSourceAsString(),
            // getTargetClass());
            // results.add(result);
            // }
            log.fine(EntityUtils.toString(entity));
            return null;
        // return (RestGetResponse<C>)
        // mapper.readValue(entity.getContent(),
        // clazz);
        } catch (IOException e) {
            throw new ElasticSearchException(e);
        }
    } catch (URISyntaxException e) {
        throw new ElasticSearchException(e);
    } catch (UnsupportedEncodingException e) {
        throw new ElasticSearchException(e);
    }
}

public void afterPropertiesSet() throws UnsupportedEncodingException {
    Collection<Header> defaultHeaders = new ArrayList<Header>();
    Header header = new BasicHeader("Authorization", "Basic " + BaseEncoding.base64().encode("apollo:".getBytes("UTF-8")));
    defaultHeaders.add(header);
    BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("apollo", ""));
    CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultCredentialsProvider(credentialsProvider).setDefaultHeaders(defaultHeaders).build();
    restTemplate = new RestTemplate(httpMessageConverters.getConverters());
    HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
    requestFactory.setConnectTimeout(portalConfig.connectTimeout());
    requestFactory.setReadTimeout(portalConfig.readTimeout());
    restTemplate.setRequestFactory(requestFactory);
}

private void makeTest() {
    String url = httpsServerUrl + "6896a7fc35e24524a18d712de4936d62/pin/v0";
    HttpPut request = new HttpPut(url);
    request.setHeader("Connection", "keep-alive");
    HttpGet getRequest = new HttpGet(url);
    getRequest.setHeader("Connection", "keep-alive");
    CloseableHttpClient httpclient = HttpClients.custom().setConnectionReuseStrategy(( response,  context) -> true).setKeepAliveStrategy(( response,  context) -> 10000000).build();
    try {
        int i = 0;
        while (true) {
            request.setEntity(new StringEntity("[\"" + ++i + "\"]", ContentType.APPLICATION_JSON));
            try (CloseableHttpResponse response = httpclient.execute(request)) {
                assertEquals(200, response.getStatusLine().getStatusCode());
                EntityUtils.consume(response.getEntity());
            }
            try (CloseableHttpResponse response2 = httpclient.execute(getRequest)) {
                assertEquals(200, response2.getStatusLine().getStatusCode());
                List<String> values = consumeJsonPinValues(response2);
                assertEquals(1, values.size());
                assertEquals(String.valueOf(i), values.get(0));
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static <T> T get(String authToken, String url, Class<T> cls) {
    CloseableHttpClient httpclient = HttpClients.createDefault();
    try {
        HttpGet httpget = new HttpGet(url);
        httpget.setHeader("Authorization", "token " + authToken);
        ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

            public String handleResponse(final HttpResponse response) throws ClientProtocolException, IOException {
                HttpEntity entity = response.getEntity();
                return entity != null ? EntityUtils.toString(entity) : null;
            }
        };
        String responseBody = httpclient.execute(httpget, responseHandler);
        return JsonUtils.fromJson(responseBody, cls);
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            httpclient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return null;
}

private ResponseBody doRequestForSingleTask(CloseableHttpClient httpClient, HttpTask task) throws Exception {
    HttpPost post = new HttpPost(task.getRequestUrl());
    StringEntity stringEntity = new StringEntity(task.getJsonData(), Charset.forName("utf-8"));
    stringEntity.setContentType("application/json");
    post.setEntity(stringEntity);
    CloseableHttpResponse response = null;
    try {
        response = httpClient.execute(post);
        HttpEntity entity = response.getEntity();
        return new ResponseBody(EntityUtils.toString(entity));
    } finally {
        if (response != null) {
            response.close();
        }
    }
}

public static Document getXMLDocument(String url) throws HttpException, IOException, JDOMException {
    SAXBuilder builder = new SAXBuilder();
    CloseableHttpClient client = HttpClients.createDefault();
    HttpGet method = new HttpGet(url);
    RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(2000).setConnectTimeout(2000).setCookieSpec(CookieSpecs.IGNORE_COOKIES).build();
    method.setConfig(requestConfig);
    InputStream responseStream = null;
    Document document = null;
    try (CloseableHttpResponse response = client.execute(method)) {
        HttpEntity entity = response.getEntity();
        responseStream = entity.getContent();
        document = builder.build(responseStream);
    }
    return document;
}

@Override
public String makeCall(String callId) throws IOException {
    Assert.hasText(callId, "callId must not be empty");
    CloseableHttpClient httpClient = HttpClients.createDefault();
    try {
        HttpGet httpGet = new HttpGet(localhostUri + RouteConstants.HTTP_URI_PREFIX + DirectCallWsRoute.SERVLET_URL + "?" + DirectCallWsRoute.CALL_ID_HEADER + "=" + callId);
        // Create a custom response handler
        ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

            public String handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
                int status = response.getStatusLine().getStatusCode();
                if (status >= 200 && status < 300) {
                    // successful response
                    HttpEntity entity = response.getEntity();
                    return entity != null ? EntityUtils.toString(entity) : null;
                } else {
                    throw new IOException(EntityUtils.toString(response.getEntity()));
                }
            }
        };
        return httpClient.execute(httpGet, responseHandler);
    } finally {
        httpClient.close();
    }
}

@Test
public void testApple() throws Exception {
    for (int i = 0; i < 100; i++) {
        HttpRequestBase build = HttpBuilder.newBuilder().get().url("http://www.tiaobaoji.net/zlfx.php?zid=150900").build();
        HttpRequestBase build2 = HttpBuilder.newBuilder().post().url("http://www.tiaobaoji.net/getmon.php").param("action", "zlmon").param("SjTime", System.currentTimeMillis() + "").build();
        CloseableHttpClient client = HttpAccess.getClient();
        String rs = HttpAccess.execute(client, build);
        EntityHelper.print(rs);
        String rs2 = HttpAccess.execute(client, build2);
        EntityHelper.print(rs2);
        try {
            int i1 = Integer.parseInt(rs2);
            if (i1 <= 0) {
                break;
            }
        } catch (Exception e) {
        }
    }
}

public CloseableHttpResponse put(String table, String body) throws IOException {
    CloseableHttpClient httpClient = HttpClients.createDefault();
    String digest = Hex.encodeHexString(Blobs.digest(body));
    String url = Blobs.url(address, table + "/" + digest);
    HttpPut httpPut = new HttpPut(url);
    httpPut.setEntity(new StringEntity(body));
    return httpClient.execute(httpPut);
}

//@Test
public void test() throws InterruptedException {
    PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
    CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(cm).build();
    new IdleConnectionMonitorThread(cm).start();
    // URIs to perform GETs on
    String[] urisToGet = { "http://www.google.com/", "http://www.yahoo.com/", "http://www.facebook.com/" };
    // create a thread for each URI
    GetThread[] threads = new GetThread[urisToGet.length];
    for (int i = 0; i < threads.length; i++) {
        HttpGet httpget = new HttpGet(urisToGet[i]);
        threads[i] = new GetThread(httpClient, httpget);
    }
    // start the threads
    for (int j = 0; j < threads.length; j++) {
        threads[j].start();
    }
    // join the threads
    for (int j = 0; j < threads.length; j++) {
        threads[j].join();
    }
}

public static CloseableHttpClient getHttpClient(HasProxySettings proxySetting) {
    // http://hc.apache.org/httpcomponents-client-ga/tutorial/html/connmgmt.html#d5e475
    CloseableHttpClient httpclient = null;
    if (proxySetting != null && proxySetting.isActive()) {
        logger.info("Set the http proxy (" + proxySetting.getHost() + ":" + proxySetting.getPort() + ")");
        CredentialsProvider credsProvider = Preconditions.checkNotNull(proxySetting.getCredentialsProvider());
        HttpHost proxy = new HttpHost(proxySetting.getHost(), proxySetting.getPort());
        DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);
        httpclient = HttpClients.custom().setRoutePlanner(routePlanner).setDefaultCredentialsProvider(credsProvider).build();
    } else {
        httpclient = HttpClients.createDefault();
    }
    return httpclient;
}

@Test
public void invokeSayHello() {
    CloseableHttpClient httpclient = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost("http://localhost:8080/net.dubboclub.restful.api.FirstRestfulService1/sayHello/1.0.1/all");
    Map<String, String> requestEntity = new HashMap<String, String>();
    requestEntity.put("arg1", "Bieber");
    HttpEntity httpEntity = new ByteArrayEntity(JSON.toJSONBytes(requestEntity));
    httpPost.setEntity(httpEntity);
    try {
        CloseableHttpResponse response = httpclient.execute(httpPost);
        System.out.println(response.getStatusLine());
        HttpEntity entity2 = response.getEntity();
        // do something useful with the response body
        // and ensure it is fully consumed
        System.out.println(EntityUtils.toString(entity2));
        response.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

//    @Test
public void download() {
    String url = "http://103.7.29.197/vweixinp.tc.qq.com/1007_efd683683fdd41ea9a999ea9ad81f239.f10.mp4?vkey=E79319C2D663CACB3A26812DBE3DC05F33EE92DEA914480FB88A77EF92832D1EDA51FFD2B275A7E9&sha=0&save=1";
    RequestConfig config = RequestConfig.custom().setConnectionRequestTimeout(NetWorkCenter.CONNECT_TIMEOUT).setConnectTimeout(NetWorkCenter.CONNECT_TIMEOUT).setSocketTimeout(NetWorkCenter.CONNECT_TIMEOUT).build();
    CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
    HttpGet get = new HttpGet(url);
    try {
        CloseableHttpResponse r = client.execute(get);
        LOG.debug("Status code: " + r.getStatusLine().getStatusCode());
        if (HttpStatus.SC_OK == r.getStatusLine().getStatusCode()) {
            InputStream inputStream = r.getEntity().getContent();
            Header[] headers = r.getHeaders("Content-disposition");
            if (null != headers && 0 != headers.length) {
                Header length = r.getHeaders("Content-Length")[0];
            }
        }
    } catch (IOException e) {
        LOG.error("IO异常处�", e);
    }
}

public static void main(String[] args) {
    /*
       * This is out ot date - Just keeping
       * it in case it's helpful...
       */
    final String authUser = "username";
    final String authPassword = "password";
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(new AuthScope("10.10.10.10", 8080), new UsernamePasswordCredentials(authUser, authPassword));
    HttpHost myProxy = new HttpHost("10.10.10.10", 8080);
    HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    clientBuilder.setProxy(myProxy).setProxyAuthenticationStrategy(new ProxyAuthenticationStrategy()).setDefaultCredentialsProvider(credsProvider).disableCookieManagement();
    CloseableHttpClient httpClient = clientBuilder.build();
    FhirContext ctx = FhirContext.forDstu2();
    String serverBase = "http://spark.furore.com/fhir/";
    ctx.getRestfulClientFactory().setHttpClient(httpClient);
    IGenericClient client = ctx.newRestfulGenericClient(serverBase);
    IdDt id = new IdDt("Patient", "123");
    client.read(Patient.class, id);
}

@Override
public final void download(URI from, File to) throws IOException {
    checkArgument(from.isAbsolute());
    checkArgument(!from.isOpaque());
    HttpHost targetHost = new HttpHost(from.getHost(), from.getPort(), from.getScheme());
    HttpClientContext localContext = buildClientContextFor(targetHost);
    HttpGet httpGet = new HttpGet(from);
    @Cleanup CloseableHttpClient client = buildHttpClientFor(from);
    log.debug("Downloading from {}...", from);
    @Cleanup CloseableHttpResponse response = client.execute(targetHost, httpGet, localContext);
    int status = response.getStatusLine().getStatusCode();
    if (status == HttpStatus.SC_OK) {
        HttpEntity entity = response.getEntity();
        final long fileSize = entity.getContentLength();
        final String fileName = from.toURL().getFile();
        @Cleanup InputStream inputStream = entity.getContent();
        copyToLocal(to, fileName, inputStream, fileSize);
    } else if (status == HttpStatus.SC_UNAUTHORIZED) {
        client.close();
        log.info("authentication is required for {}", from);
        retry(from, to, response.getFirstHeader("WWW-Authenticate"));
    } else {
        throw new IllegalStateException(String.format("Unexpected status code (%d) from %s", status, from));
    }
}

public static void main(String[] args) {
    try {
        // create default HTTP Client
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // Create new getRequest with below mentioned URL
        HttpGet getRequest = new HttpGet("http://localhost:8080/v1/api/ctofservice/");
        // Add additional header to getRequest which accepts application/xml
        // data
        getRequest.addHeader("accept", "application/xml");
        // Execute your request and catch response
        CloseableHttpResponse response = httpClient.execute(getRequest);
        // Check for HTTP response code: 200 = success
        if (response.getStatusLine().getStatusCode() != 200) {
            throw new RuntimeException("Failed : HTTP error code : " + response.getStatusLine().getStatusCode());
        }
        // Get-Capture Complete application/xml body response
        BufferedReader br = new BufferedReader(new InputStreamReader((response.getEntity().getContent())));
        String output;
        System.out.println("============Output:============");
        // Simply iterate through XML response and show on console.
        while ((output = br.readLine()) != null) {
            System.out.println(output);
        }
        httpClient.close();
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public CloseableHttpClient getHttpClient() {
    CloseableHttpClient result = httpClient;
    if (result == null) {
        synchronized (DocumentLoader.class) {
            result = httpClient;
            if (result == null) {
                result = httpClient = JsonUtils.getDefaultHttpClient();
            }
        }
    }
    return result;
}

@Override
public CloseableHttpClient getHttpClient(SiteConfig siteConfig, Request request) {
    String host = getHttpClientCacheKey(siteConfig, request);
    CloseableHttpClient httpClient = httpClients.get(host);
    if (httpClient == null) {
        synchronized (this) {
            httpClient = httpClients.get(host);
            if (httpClient == null) {
                httpClient = factory.createHttpClient(siteConfig);
                httpClients.put(host, httpClient);
            }
        }
    }
    return httpClient;
}

@Override
protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException {
    String distributionURL = "http://eduvem.com";
    String uri = req.getRequestURI();
    StringBuilder log = new StringBuilder();
    CloseableHttpClient httpclient = HttpClients.createDefault();
    try {
        HttpGet httpget = new HttpGet(StringUtils.mkurl(distributionURL, uri));
        log.append("Requesting " + uri);
        // Create a custom response handler
        ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

            public String handleResponse(final HttpResponse response) throws ClientProtocolException, IOException {
                int status = response.getStatusLine().getStatusCode();
                if (status >= 200 && status < 300) {
                    HttpEntity entity = response.getEntity();
                    Header[] headers = response.getHeaders("Content-Type");
                    if (headers.length > 0) {
                        String ctype = headers[0].toString();
                        //TODO: Set Correct Content Type
                        resp.setHeader("Content-Type", ctype);
                    }
                    return entity != null ? EntityUtils.toString(entity) : null;
                } else {
                    throw new ClientProtocolException("Unexpected response status: " + status);
                }
            }
        };
        String responseBody = httpclient.execute(httpget, responseHandler);
        if (uri.endsWith("html")) {
            resp.setContentType("text/html");
        } else if (uri.endsWith("css")) {
            resp.setContentType("text/css");
        } else if (uri.endsWith("js")) {
            resp.setContentType("application/javascript");
        }
        resp.setCharacterEncoding("UTF-8");
        System.out.println(log);
        resp.getWriter().print(responseBody);
    } finally {
        httpclient.close();
    }
}

@Test
public void make_request_http_client() throws ClientProtocolException, IOException {
    CloseableHttpClient httpclient = HttpClients.createDefault();
    HttpGet httpget = new HttpGet("https://data.sparkfun.com/streams/dZ4EVmE8yGCRGx5XRX1W.json");
    CloseableHttpResponse response = httpclient.execute(httpget);
    try {
        HttpEntity entity = response.getEntity();
        if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) {
            String responseValue = EntityUtils.toString(entity);
            System.out.println(responseValue);
        } else {
        // log error
        }
    } finally {
        response.close();
    }
}

@Test
public void shouldUseDataServiceUriFromConfiguration() throws MalformedURLException, ServletException {
    LightblueClientConfiguration config = new LightblueClientConfiguration();
    config.setDataServiceURI("http://service.com/data");
    LightblueDataProxyServlet servlet = new LightblueDataProxyServlet(mock(CloseableHttpClient.class), new StubInstance<>(config));
    servlet.init(new FakeServletConfig());
    HttpServletRequest request = new StubHttpServletRequest("http://myapp.com/data/find/thing", "POST", "{\"test\":0}", "application/json", "/data/*");
    assertEquals("http://service.com/data/find/thing", servlet.serviceUriForRequest(request));
}

/**
     * �出post请求
     */
public String post(String postUrl, List<NameValuePair> params) {
    CloseableHttpClient httpclient = HttpClients.createDefault();
    HttpPost hp = new HttpPost(postUrl);
    CloseableHttpResponse response = null;
    String result = null;
    try {
        hp.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
        response = httpclient.execute(hp);
        result = EntityUtils.toString(response.getEntity());
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return result;
}

private void check() {
    try {
        RequestConfig globalConfig = RequestConfig.custom().setCircularRedirectsAllowed(true).build();
        CloseableHttpClient httpclient = HttpClientBuilder.create().build();
        logger.debug("Requesting: " + MANIFEST_URL);
        HttpGet httpGet = new HttpGet(MANIFEST_URL);
        httpGet.setConfig(globalConfig);
        CloseableHttpResponse response = httpclient.execute(httpGet);
        try {
            HttpEntity entity = response.getEntity();
            String htmlContent = EntityUtils.toString(entity);
            EntityUtils.consume(entity);
            Gson gson = new Gson();
            VersionInfo versionInfo = gson.fromJson(htmlContent, VersionInfo.class);
            if (versionInfo.isNewerVersionAvailable(BuildConfig.VERSION)) {
                logger.debug("Newer version available: {}" + versionInfo.version);
                getFacade().sendNotification(GameNotification.NEW_VERSION_AVAILABLE, versionInfo);
            } else {
                logger.debug("Version up-to-date");
            }
        } finally {
            response.close();
        }
    } catch (Exception e) {
        logger.warn("Auto updater version check failed: " + e.toString());
    }
}

public static HttpResponse simpleRESTGet(String requestUri) {
    Validate.notEmpty(requestUri, "Null or blank requestUri not allowed.");
    CloseableHttpClient httpclient = HttpClients.createDefault();
    HttpGet httpGet = new HttpGet(requestUri);
    try {
        return httpclient.execute(httpGet);
    } catch (Exception e) {
        throw new ContextedRuntimeException(e).addContextValue("requestUri", requestUri);
    }
}

public static <T> T getData(String path, HttpRespFormatter<T> formatter) {
    try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
        /*
            * Method: HttpGet
            */
        HttpGet httpget = new HttpGet(path);
        /*
            * HttpResponse
            */
        try (CloseableHttpResponse response = httpclient.execute(httpget)) {
            return formatter.format(response.getEntity());
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

public Properties getProperties() {
    if (properties == null) {
        final Properties props = new Properties();
        try {
            try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {
                final HttpGet request = new HttpGet(url);
                request.setHeader("X-Nanobot-UUID", Settings.instance().getUuid().toString());
                request.setHeader("X-Nanobot-User", Settings.instance().getUserMailAddress());
                try (CloseableHttpResponse response = httpClient.execute(request)) {
                    final StatusLine statusLine = response.getStatusLine();
                    if (statusLine.getStatusCode() != HttpStatus.SC_OK) {
                        throw new IOException(statusLine.getStatusCode() + " " + statusLine.getReasonPhrase());
                    }
                    try (InputStream in = response.getEntity().getContent()) {
                        props.load(in);
                    }
                }
            }
        } catch (final IOException e) {
            throw new ExceptionInInitializerError(e);
        }
        properties = props;
    }
    return properties;
}

@Test
public void shouldInitialiseWithCustomHttpClient() {
    PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
    connectionManager.setMaxTotal(1);
    connectionManager.setDefaultMaxPerRoute(1);
    CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(connectionManager).build();
    DriverManager.register(new HttpDriver(httpClient));
    assertNotNull(DriverManager.getDriver());
}

public static String post(String url, List<NameValuePair> params) {
    CloseableHttpClient httpClient = HttpClients.createDefault();
    String responseText = "";
    CloseableHttpResponse httpResponse = null;
    try {
        HttpPost httpPost = new HttpPost(url);
        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(5000).setConnectTimeout(5000).build();
        httpPost.setConfig(requestConfig);
        httpPost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
        httpResponse = httpClient.execute(httpPost);
        if (httpResponse.getStatusLine().getStatusCode() == 200) {
            responseText = EntityUtils.toString(httpResponse.getEntity());
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (httpResponse != null) {
                httpResponse.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return responseText;
}

@Override
public Object[] invoke(Map<String, Object> request) {
    CloseableHttpClient httpclient = HttpClients.createDefault();
    //		HttpGet httpget = new HttpGet("http://cn.bing.com/");
    HttpGet httpget = new HttpGet("http://www.apache.org/dist/httpcomponents/httpclient/RELEASE_NOTES-4.3.x.txt");
    CloseableHttpResponse response = null;
    try {
        response = httpclient.execute(httpget);
        InputStream in = response.getEntity().getContent();
        byte[] buf = new byte[1024];
        int c = 0;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        while ((c = in.read(buf)) > 0) {
            out.write(buf, 0, c);
        }
        in.close();
        Object[] resps = new Object[] { 200, ArrayMap.create(Constants.CONTENT_TYPE, "text/html"), new ByteArrayInputStream(out.toByteArray()) };
        return resps;
    } catch (IOException e) {
        throw new RuntimeException("ioexception", e);
    } finally {
        if (httpclient != null) {
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/*
	 * SSLContext sslContext = SSLContext.getInstance("SSL");
	 * 
	 * // set up a TrustManager that trusts everything
	 * sslContext.init(null, new TrustManager[] { new X509TrustManager()
	 * { public X509Certificate[] getAcceptedIssuers() { return null; }
	 * 
	 * public void checkClientTrusted(X509Certificate[] certs, String
	 * authType) { }
	 * 
	 * public void checkServerTrusted(X509Certificate[] certs, String
	 * authType) { } } }, new SecureRandom());
	 */
//new TrustSelfSignedStrategy
// SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
//信任所有�书的连接，�能作为正�使用
public static CloseableHttpClient createSSLInsecureClient() {
    try {
        SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {

            public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                return true;
            }
        }).build();
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);
        return HttpClients.custom().setSSLSocketFactory(sslsf).build();
    } catch (KeyManagementException e) {
        e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    } catch (KeyStoreException e) {
        e.printStackTrace();
    }
    return HttpClients.createDefault();
}

public static boolean testProxy(String proxy, String auth) {
    boolean valid = false;
    int sepIndex = proxy.indexOf(":");
    String ip = proxy.substring(0, sepIndex);
    int port = Integer.parseInt(proxy.substring(sepIndex + 1));
    CloseableHttpClient httpclient = HttpClients.createDefault();
    try {
        HttpHost proxyHost;
        if (auth.equals("IP")) {
            proxyHost = new HttpHost(ip, port, "http");
        } else {
            proxyHost = new HttpHost(auth + "@" + ip, port, "http");
        }
        RequestConfig config = RequestConfig.custom().setProxy(proxyHost).build();
        HttpPost request = new HttpPost(TEST_URL);
        request.setConfig(config);
        Log("Trying to connect to  " + TEST_URL + " via " + proxyHost);
        String responseLine;
        try (CloseableHttpResponse response = httpclient.execute(request)) {
            //                System.out.println("----------------------------------------");
            responseLine = response.getStatusLine().toString();
            //                System.out.println(responseLine);
            EntityUtils.consume(response.getEntity());
        } catch (HttpHostConnectException e) {
            Log("Failed to establish proxy connection");
            return false;
        }
        String respCode = responseLine.substring(9);
        if (respCode.contains("200 ")) {
            Log("Proxy " + proxy + " ok!");
            valid = true;
        } else if (respCode.contains("403 ")) {
            Log("Proxy " + proxy + " is banned, status code: " + respCode);
        } else {
            Log("Proxy " + proxy + " gave unexpected response, status code: " + respCode);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            httpclient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return valid;
}

public RfResponseDTO process(RfRequestDTO rfRequestDTO) throws IOException {
    RfResponseDTO response = null;
    CloseableHttpClient httpclient = HttpClients.createDefault();
    HttpPut httpPut = new HttpPut(rfRequestDTO.getEvaluatedApiUrl());
    httpPut.addHeader("Content-Type", "application/json");
    httpPut.setEntity(new StringEntity(rfRequestDTO.getApiBody()));
    try {
        response = processHttpRequest(httpPut, httpclient);
    } finally {
        httpclient.close();
    }
    return response;
}

public static <T extends Serializable> T sendPostRequest(T element, Class<T> elementClass, String url, String resource, String username, String password) throws RODAException {
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    String basicAuthToken = new String(Base64.encode((username + ":" + password).getBytes()));
    HttpPost httpPost = new HttpPost(url + resource);
    httpPost.setHeader("Authorization", "Basic " + basicAuthToken);
    httpPost.addHeader("content-type", "application/json");
    httpPost.addHeader("Accept", "application/json");
    try {
        httpPost.setEntity(new StringEntity(JsonUtils.getJsonFromObject(element)));
        HttpResponse response;
        response = httpClient.execute(httpPost);
        HttpEntity responseEntity = response.getEntity();
        int responseStatusCode = response.getStatusLine().getStatusCode();
        if (responseStatusCode == 201) {
            return JsonUtils.getObjectFromJson(responseEntity.getContent(), elementClass);
        } else {
            throw new RODAException("POST request response status code: " + responseStatusCode);
        }
    } catch (IOException e) {
        throw new RODAException("Error sending POST request", e);
    }
}

public String randomName() throws IOException {
    CloseableHttpClient httpclient = HttpClientBuilder.create().build();
    HttpGet httpGet = new HttpGet("http://uinames.com/api/");
    CloseableHttpResponse response = httpclient.execute(httpGet);
    try {
        HttpEntity entity = response.getEntity();
        InputStream inputStream = entity.getContent();
        ObjectMapper mapper = new ObjectMapper();
        Map<String, String> jsonMap = mapper.readValue(inputStream, Map.class);
        String name = jsonMap.get("name");
        EntityUtils.consume(entity);
        return name;
    } finally {
        response.close();
    }
}

public String execute() throws IOException {
    RequestConfig config = RequestConfig.custom().setConnectTimeout(3000).setConnectionRequestTimeout(3000).setSocketTimeout(3000).build();
    CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(config).build();
    try {
        HttpGet httpget = new HttpGet(queryUrl);
        httpget.addHeader("User-Agent", getUserAgent());
        httpget.addHeader("Connection", "Keep-Alive");
        ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

            public String handleResponse(final HttpResponse response) throws IOException {
                int status = response.getStatusLine().getStatusCode();
                if (status >= 200 && status < 300) {
                    HttpEntity entity = response.getEntity();
                    return entity != null ? EntityUtils.toString(entity) : null;
                } else {
                    throw new ClientProtocolException("Unexpected response status: " + status);
                }
            }
        };
        return httpclient.execute(httpget, responseHandler);
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } finally {
        httpclient.close();
    }
    return null;
}

public static void main(String[] args) throws Exception {
    CloseableHttpClient client = null;
    Server server = null;
    try {
        HTTPRestServiceTestApp test = new HTTPRestServiceTestApp();
        server = test.startServer();
        client = test.send();
    } finally {
        if (client != null) {
            client.close();
        }
        if (server != null) {
            server.stop();
        }
    }
}

public synchronized CloseableHttpClient pollHttpClient() {
    /*logger.debug("获�HttpClient");
        if(clientPool.size()==0){
            if(handler!=null){
                return handler.createDefault();
            }else {
                return HttpClientCreater.instance.getDefaultClient();
            }
        }
        return clientPool.poll();*/
    return HttpClientCreater.instance.getHttpClient();
}

public static String shorten(String url) {
    CloseableHttpClient httpclient;
    try {
        String api = "https://www.googleapis.com/urlshortener/v1/url?key=" + Config.getGoogleApiKey();
        httpclient = HttpClients.createDefault();
        HttpPost httpPost = new HttpPost(api);
        String jsonstring = "{\"longUrl\": \"" + url + "\"}";
        StringEntity params = new StringEntity(jsonstring);
        httpPost.addHeader("content-type", "application/json");
        httpPost.setEntity(params);
        CloseableHttpResponse response = httpclient.execute(httpPost);
        String jsonoutput = (EntityUtils.toString(response.getEntity()));
        EntityUtils.consume(response.getEntity());
        Gson gson = new GsonBuilder().create();
        JsonObject json = gson.fromJson(jsonoutput, JsonElement.class).getAsJsonObject();
        return json.get("id").getAsString();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

@Deprecated
private static Document downloadAndCreateDocument(@Nonnull CloseableHttpClient httpClient, int garminActivityId, @Nonnull GarminDataType garminDataType) throws IOException {
    try (CloseableHttpResponse response = garminDataType.executeGarminHttpRequest(httpClient, garminActivityId)) {
        Document output = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(response.getEntity().getContent());
        EntityUtils.consumeQuietly(response.getEntity());
        return output;
    } catch (HttpException he) {
        throw he;
    } catch (IOExceptionParserConfigurationException | SAXException | URISyntaxException |  e) {
        log.out(e);
        throw new IOException(GARMIN_ID_ERROR);
    }
}

@Override
public void clearWebhook() throws TelegramApiRequestException {
    try (CloseableHttpClient httpclient = HttpClientBuilder.create().setSSLHostnameVerifier(new NoopHostnameVerifier()).build()) {
        String url = ApiConstants.BASE_URL + getBotToken() + "/" + SetWebhook.PATH;
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(getOptions().getRequestConfig());
        try (CloseableHttpResponse response = httpclient.execute(httpGet)) {
            HttpEntity ht = response.getEntity();
            BufferedHttpEntity buf = new BufferedHttpEntity(ht);
            String responseContent = EntityUtils.toString(buf, StandardCharsets.UTF_8);
            JSONObject jsonObject = new JSONObject(responseContent);
            if (!jsonObject.getBoolean(ApiConstants.RESPONSE_FIELD_OK)) {
                throw new TelegramApiRequestException("Error removing old webhook", jsonObject);
            }
        }
    } catch (JSONException e) {
        throw new TelegramApiRequestException("Error deserializing setWebhook method response", e);
    } catch (IOException e) {
        throw new TelegramApiRequestException("Error executing setWebook method", e);
    }
}

@Override
public void clearWebhook() throws TelegramApiRequestException {
    try (CloseableHttpClient httpclient = HttpClientBuilder.create().setSSLHostnameVerifier(new NoopHostnameVerifier()).build()) {
        String url = ApiConstants.BASE_URL + getBotToken() + "/" + SetWebhook.PATH;
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(getOptions().getRequestConfig());
        try (CloseableHttpResponse response = httpclient.execute(httpGet)) {
            HttpEntity ht = response.getEntity();
            BufferedHttpEntity buf = new BufferedHttpEntity(ht);
            String responseContent = EntityUtils.toString(buf, StandardCharsets.UTF_8);
            JSONObject jsonObject = new JSONObject(responseContent);
            if (!jsonObject.getBoolean(ApiConstants.RESPONSE_FIELD_OK)) {
                throw new TelegramApiRequestException("Error removing old webhook", jsonObject);
            }
        }
    } catch (JSONException e) {
        throw new TelegramApiRequestException("Error deserializing setWebhook method response", e);
    } catch (IOException e) {
        throw new TelegramApiRequestException("Error executing setWebook method", e);
    }
}

@Test
public void simpleTest() throws IOException {
    String address = String.format("http://%s:%s", container.getContainerIpAddress(), container.getMappedPort(80));
    CloseableHttpClient httpClient = HttpClientBuilder.create().build();
    HttpGet get = new HttpGet(address);
    Unreliables.retryUntilSuccess(5, TimeUnit.SECONDS, () -> {
        try (CloseableHttpResponse response = httpClient.execute(get)) {
            assertEquals("A container built from a dockerfile can run nginx as expected, and returns a good status code", 200, response.getStatusLine().getStatusCode());
            assertTrue("A container built from a dockerfile can run nginx as expected, and returns an expected Server header", response.getHeaders("Server")[0].getValue().contains("nginx"));
        }
        return true;
    });
}

/**
	 * Creates a CloseableHttpClient object with the proxy settings if they are configured
	 * 
	 * @param useProxyIfAvailable
	 * if the proxy settings are available, this connection will be initiated using the configured
	 * proxy
	 * @param trustSelfSignedCertificates
	 * whether or not self signed certificates should be trusted
	 * @return a CloseableHttpClient
	 */
public static CloseableHttpClient createClient(final boolean useProxyIfAvailable, final boolean trustSelfSignedCertificates) {
    if (useProxyIfAvailable) {
        String proxyHost = SdkAppConfig.getInstance().getTcProxyHost();
        Integer proxyPort = SdkAppConfig.getInstance().getTcProxyPort();
        String proxyUserName = SdkAppConfig.getInstance().getTcProxyUsername();
        String proxyPassword = SdkAppConfig.getInstance().getTcProxyPassword();
        return ConnectionUtil.createClient(proxyHost, proxyPort, proxyUserName, proxyPassword, trustSelfSignedCertificates);
    } else {
        return ConnectionUtil.createClient(trustSelfSignedCertificates);
    }
}

@Test
public void benchmark() throws Exception {
    Tomcat tomcat = getTomcatInstance();
    tomcat.start();
    CloseableHttpClient httpclient = HttpClients.createDefault();
    int[] iterationsArray = { 100 };
    long total = 0;
    for (int iterations : iterationsArray) {
        for (int i = 0; i < iterations; i++) {
            HttpUriRequest post = PostGenerator.gen(tomcat.getConnector().getLocalPort());
            long start = System.currentTimeMillis();
            httpclient.execute(post).close();
            total += System.currentTimeMillis() - start;
        }
        sb.append(iterations + " iterations using MongoAccessLogValve took " + total + "ms").append("\n");
    }
}

// Build up URL and copy over query parameters:		
public static Result passthrough(String url) throws ClientProtocolException, IOException {
    // Build up the wayback query:
    String urlBuilder = url;
    String q = ctx()._requestHeader().rawQueryString();
    if (q != null && q.length() > 0) {
        Logger.info("Passing through raw Query String: " + q);
        urlBuilder += "?" + q;
    }
    final String nurl = urlBuilder;
    Logger.info("Proxing " + nurl);
    // Set up the GET:
    CloseableHttpClient httpclient = HttpClientBuilder.create().disableRedirectHandling().build();
    HttpGet httpGet = new HttpGet(nurl);
    CloseableHttpResponse response = httpclient.execute(httpGet);
    // If this looks like a redirect, return that:
    if (response.getFirstHeader(LOCATION) != null) {
        String location = response.getFirstHeader(LOCATION).getValue();
        response.close();
        Logger.info("Got LOCATION: " + location);
        // Issue the redirect directly...
        return redirect(location);
    }
    // Pass the content type over:
    String contentType = response.getFirstHeader(CONTENT_TYPE).getValue();
    Logger.debug("Response content type: " + contentType);
    HttpEntity entity = response.getEntity();
    return status(response.getStatusLine().getStatusCode(), entity.getContent()).as(contentType);
}

public WxMpMaterialVideoInfoResult execute(CloseableHttpClient httpclient, HttpHost httpProxy, String uri, String materialId) throws WxErrorException, ClientProtocolException, IOException {
    HttpPost httpPost = new HttpPost(uri);
    if (httpProxy != null) {
        RequestConfig config = RequestConfig.custom().setProxy(httpProxy).build();
        httpPost.setConfig(config);
    }
    Map<String, String> params = new HashMap<>();
    params.put("media_id", materialId);
    httpPost.setEntity(new StringEntity(WxGsonBuilder.create().toJson(params)));
    CloseableHttpResponse response = httpclient.execute(httpPost);
    String responseContent = Utf8ResponseHandler.INSTANCE.handleResponse(response);
    WxError error = WxError.fromJson(responseContent);
    if (error.getErrorCode() != 0) {
        throw new WxErrorException(error);
    } else {
        return WxMpMaterialVideoInfoResult.fromJson(responseContent);
    }
}

@Test
public void testNonBlockingHandler() throws Exception {
    try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
        HttpGet httpget = new HttpGet(url.toExternalForm());
        HttpResponse response = httpClient.execute(httpget);
        HttpEntity entity = response.getEntity();
        StatusLine statusLine = response.getStatusLine();
        assertEquals(200, statusLine.getStatusCode());
        String result = EntityUtils.toString(entity);
        Assert.assertEquals(SimpleUndertowExtension.THIS_IS_NOT_A_SERVLET, result);
    }
}

@Test
public void testJolokia() throws Exception {
    HttpClientBuilder builder = HttpClientBuilder.create();
    CloseableHttpClient client = builder.build();
    HttpUriRequest request = new HttpGet("http://localhost:8080/jolokia");
    CloseableHttpResponse response = client.execute(request);
    assertThat(response.getStatusLine().getStatusCode()).isEqualTo(403);
}

@Override
protected CloseableHttpClient performLoginIfNecessary(HttpClientBuilder clientBuilder, List<Header> requestHeaders) throws Exception {
    SettingsUtil.Settings settings = SettingsUtil.loadSettings();
    if (loggedInClient == null || (connectionParameterHashCode != null && !connectionParameterHashCode.equals(settings.getConnectionParametersHashCode()))) {
        LOGGER.debug("New connection or connection parameters changed. Performing login");
        String loginUrl = buildYoutrackApiUrl("user/login");
        HttpPost request = new HttpPost(loginUrl);
        List<NameValuePair> requestParameters = new ArrayList<>();
        requestParameters.add(new BasicNameValuePair("login", settings.getYoutrackUsername()));
        requestParameters.add(new BasicNameValuePair("password", settings.getYoutrackPassword()));
        request.setEntity(new UrlEncodedFormEntity(requestParameters, "utf-8"));
        CloseableHttpClient loginClient = clientBuilder.setDefaultHeaders(requestHeaders).build();
        CloseableHttpResponse response = loginClient.execute(request);
        try {
            EntityUtils.consumeQuietly(response.getEntity());
        } finally {
            response.close();
        }
        if (!HttpClientUtil.isValidResponseCode(response.getStatusLine())) {
            throw ExceptionUtil.getIllegalStateException("exceptions.main.worker.login", response.getStatusLine().getReasonPhrase(), response.getStatusLine().getStatusCode());
        }
        // connection successfull with these settings, headers have been set
        // hence store the parameters hash and the client
        connectionParameterHashCode = settings.getConnectionParametersHashCode();
        loggedInClient = loginClient;
    }
    return loggedInClient;
}

public static void checkUrl(String url, String containingText, long timeout) {
    log.info("Checking url {}", url);
    long before = System.currentTimeMillis();
    CloseableHttpClient httpClient = HttpClients.custom().build();
    while (true) {
        try {
            HttpGet httpGet = new HttpGet(url);
            CloseableHttpResponse response = httpClient.execute(httpGet);
            try {
                if (log.isDebugEnabled()) {
                    log.debug("Status code " + response.getStatusLine().getStatusCode());
                }
                if (response.getStatusLine().getStatusCode() < 200 || response.getStatusLine().getStatusCode() >= 300) {
                    log.info("Received error status code " + response.getStatusLine().getStatusCode());
                    sleepWhenErrorHappen(before, timeout);
                    continue;
                }
                String responseText = EntityUtils.toString(response.getEntity());
                if (log.isDebugEnabled()) {
                    log.debug(responseText);
                }
                if (StringUtils.isNotBlank(containingText)) {
                    if (!responseText.contains(containingText)) {
                        log.info("Expect to receive \n {} but received \n {}", containingText, responseText);
                        sleepWhenErrorHappen(before, timeout);
                        continue;
                    }
                }
                return;
            } finally {
                response.close();
            }
        } catch (IOException e) {
            sleepWhenErrorHappen(before, timeout);
        }
    }
}

@Test
public void testRedirect() throws Exception {
    HttpGet get = new HttpGet("http://localhost:" + portNum + "/users/homer");
    // do not follow redirects
    RequestConfig requestconfig = RequestConfig.custom().setRedirectsEnabled(false).build();
    CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(requestconfig).build();
    try {
        HttpResponse response = client.execute(get);
        for (Header header : response.getAllHeaders()) {
            log.info("Header {}", header);
        }
        assertEquals(302, response.getStatusLine().getStatusCode());
        assertTrue("Should have location header", response.containsHeader("Location"));
        assertEquals("http://somewhere.com", response.getFirstHeader("Location").getValue());
        assertEquals("bar", response.getFirstHeader("Foo").getValue());
    } finally {
        client.close();
    }
}

protected JsonNode loadCatalog(CloseableHttpClient client) throws IOException {
    final HttpUriRequest catalogRequest = RequestBuilder.get().setUri("http://localhost:8080" + Constants.CATALOG_URI).build();
    final CloseableHttpResponse response = client.execute(catalogRequest);
    assertEquals(response.getStatusLine().getStatusCode(), 200);
    final String body = StreamUtils.copyToString(response.getEntity().getContent(), Charset.defaultCharset());
    final ObjectMapper mapper = new ObjectMapper();
    return mapper.readTree(body);
}

private void disableSSLCheck() {
    try {
        SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(null, new TrustSelfSignedStrategy()).build();
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext);
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        Unirest.setHttpClient(httpclient);
    } catch (NoSuchAlgorithmExceptionKeyManagementException | KeyStoreException |  e) {
        throw new RuntimeException("can't create ssl settings");
    }
}

@Override
public void send(@NotNull String url, @NotNull String content) throws StatServiceException {
    //HttpConfigurable.getInstance().prepareURL(url);
    try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
        HttpPost post = new HttpPost(url);
        List<NameValuePair> pairs = new ArrayList<>(2);
        pairs.add(new BasicNameValuePair("content", content));
        pairs.add(new BasicNameValuePair("uuid", PermanentInstallationID.get()));
        post.setEntity(new UrlEncodedFormEntity(pairs));
        httpClient.execute(post, new ResponseHandler<Object>() {

            @Override
            public Object handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
                int statusCode = response.getStatusLine().getStatusCode();
                if (statusCode != HttpStatus.SC_OK) {
                    throw new StatServiceException("Error during data sending... Code: " + statusCode);
                }
                final Header errors = response.getFirstHeader("errors");
                if (errors != null) {
                    final String value = errors.getValue();
                    throw new StatServiceException("Error during updating statistics " + (!StringUtil.isEmptyOrSpaces(value) ? " : " + value : ""));
                }
                return null;
            }
        });
    } catch (Exception e) {
        throw new StatServiceException("Error during data sending...", e);
    }
}

public HTTPClient build() {
    StopWatch watch = new StopWatch();
    try {
        HttpClientBuilder builder = HttpClients.custom();
        builder.setUserAgent(userAgent);
        builder.setKeepAliveStrategy(( response,  context) -> keepAliveTimeout.toMillis());
        builder.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE).setSSLContext(new SSLContextBuilder().loadTrustMaterial(TrustSelfSignedStrategy.INSTANCE).build());
        // builder use PoolingHttpClientConnectionManager by default, and connTimeToLive will be set by keepAlive value
        builder.setDefaultSocketConfig(SocketConfig.custom().setSoKeepAlive(true).build());
        builder.setDefaultRequestConfig(RequestConfig.custom().setSocketTimeout((int) timeout.toMillis()).setConnectionRequestTimeout((int) timeout.toMillis()).setConnectTimeout((int) timeout.toMillis()).build());
        builder.setMaxConnPerRoute(maxConnections).setMaxConnTotal(maxConnections);
        builder.disableAuthCaching();
        builder.disableConnectionState();
        // retry should be handled in framework level with better trace log
        builder.disableAutomaticRetries();
        if (!enableRedirect)
            builder.disableRedirectHandling();
        if (!enableCookie)
            builder.disableCookieManagement();
        CloseableHttpClient httpClient = builder.build();
        return new HTTPClient(httpClient, userAgent, slowOperationThreshold);
    } catch (NoSuchAlgorithmExceptionKeyManagementException | KeyStoreException |  e) {
        throw new Error(e);
    } finally {
        logger.info("create http client, elapsedTime={}", watch.elapsedTime());
    }
}

@Override
public CloseableHttpClient createHttpClient() throws CacheException {
    try {
        KeyManager[] keyManagers;
        if (privateKey != null & chain != null) {
            KeyAndCertCredential credential = new KeyAndCertCredential(privateKey, chain);
            keyManagers = new KeyManager[] { credential.getKeyManager() };
        } else {
            keyManagers = new KeyManager[0];
        }
        SSLContext context = SSLContext.getInstance("TLS");
        context.init(keyManagers, new TrustManager[] { trustManager }, secureRandom);
        return HttpClients.custom().setUserAgent(USER_AGENT).setSSLContext(context).build();
    } catch (NoSuchAlgorithmExceptionKeyStoreException | KeyManagementException |  e) {
        throw new CacheException("failed to build http client: " + e.getMessage(), e);
    }
}

/**
     * �始化httpclient对象
     */
private static void buildHttpClient() {
    RequestConfig globalConfig = RequestConfig.custom().setConnectTimeout(5000).setSocketTimeout(5000).build();
    CloseableHttpClient httpclient = HttpClients.custom().setKeepAliveStrategy(new HttpClientKeepAliveStrategy()).setDefaultRequestConfig(globalConfig).build();
    HttpClientUtil.httpclient = httpclient;
}

private static HttpResponseResult makeRequest(HttpUriRequest request, Credentials credentials) throws IOException {
    HttpClientBuilder clientBuilder = HttpClients.custom();
    if (credentials != null) {
        CredentialsProvider credsProvider = prepareCredenitalsProvider(request.getURI(), credentials);
        clientBuilder.setDefaultCredentialsProvider(credsProvider);
    }
    CloseableHttpClient httpclient = clientBuilder.build();
    HttpResponseResult result = null;
    try {
        logger.debug("Executing request {}", request.getRequestLine());
        CloseableHttpResponse response = httpclient.execute(request);
        try {
            StatusLine statusLine = response.getStatusLine();
            result = new HttpResponseResult(statusLine);
            HttpEntity entity = response.getEntity();
            result.resultContent = EntityUtils.toString(entity);
            EntityUtils.consume(entity);
        } finally {
            response.close();
        }
    } finally {
        httpclient.close();
    }
    return result;
}

@Override
public boolean isUpdateAvaliable(String selectedProvider, String uuid, String bbid) throws UpdateException {
    try (CloseableHttpClient hc = HttpClients.createDefault()) {
        HttpPost r = new HttpPost(UPDATE_CHECK_URI);
        r.setEntity(generateEntity(selectedProvider, uuid, bbid));
        CloseableHttpResponse response = hc.execute(r);
        UpdateLogger.LOGGER.error("{}", response.getStatusLine());
        UpdateLogger.LOGGER.error("{}", CharStreams.toString(new InputStreamReader(response.getEntity().getContent(), Charsets.UTF_8)));
        Header updateNeeded = response.getLastHeader(UPDATE_REQUIRED_HEADER);
        if (updateNeeded != null) {
            boolean value = parseBooleanSafe(updateNeeded.getValue(), false);
            return value;
        } else {
            UpdateLogger.LOGGER.error("No update header. Headders follow");
            for (Header header : response.getAllHeaders()) {
                UpdateLogger.LOGGER.error("H > {}", header);
            }
            return false;
        }
    } catch (IOException e) {
        throw new UpdateException(e);
    }
}

public static void main(String[] args) throws IOException {
    // Step1 代�策略,确定那些请求将会被代�池代�
    WhiteListProxyStrategy whiteListProxyStrategy = new WhiteListProxyStrategy();
    whiteListProxyStrategy.addAllHost("58.com");
    //确定缓存文件�置,如果没有预热,�以�指定
    JSONFileAvProxyDumper jsonFileAvProxyDumper = new JSONFileAvProxyDumper();
    jsonFileAvProxyDumper.setDumpFileName("你的IP文件�置");
    // Step2 创建并定制代�规则
    DungProxyContext dungProxyContext = DungProxyContext.create().setNeedProxyStrategy(whiteListProxyStrategy).setAvProxyDumper(jsonFileAvProxyDumper);
    dungProxyContext.getGroupBindRouter().buildCombinationRule("58.com:.*58.com");
    // Step3 使用代�规则�始化默认IP池
    IpPoolHolder.init(DungProxyContext.create().setPoolEnabled(true));
    // step 4 将代�池注册到httpclient(两个为httpclient�的适��件)
    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
    httpClientBuilder.setRetryHandler(new DunProxyHttpRequestRetryHandler(null)).setRoutePlanner(new ProxyBindRoutPlanner());
    CloseableHttpClient closeableHttpClient = httpClientBuilder.build();
    HttpGet httpGet = new HttpGet("http://www.baidu.com");
    CloseableHttpResponse response = closeableHttpClient.execute(httpGet);
    String string = IOUtils.toString(response.getEntity().getContent());
    System.out.println(string);
}

// TODO: probably a better way to test, but we don't want to really
// define a fake rest spec or anything?
public void test() throws Exception {
    TestCluster cluster = cluster();
    assumeTrue("this test will not work from an IDE unless you pass tests.cluster pointing to a running instance", cluster instanceof ExternalTestCluster);
    ExternalTestCluster externalCluster = (ExternalTestCluster) cluster;
    try (CloseableHttpClient httpClient = HttpClients.createMinimal(new PoolingHttpClientConnectionManager(15, TimeUnit.SECONDS))) {
        for (InetSocketAddress address : externalCluster.httpAddresses()) {
            RestResponse restResponse = new RestResponse(new HttpRequestBuilder(httpClient).host(NetworkAddress.format(address.getAddress())).port(address.getPort()).path("/_plugin/site-example/").method("GET").execute());
            assertEquals(200, restResponse.getStatusCode());
            String body = restResponse.getBodyAsString();
            assertTrue("unexpected body contents: " + body, body.contains("<body>Page body</body>"));
        }
    }
}

@Override
public void run() {
    try {
        // Prepare get parameters
        final String version = Version.getVersionName().replaceAll("\\s+", "");
        final String lang = I18N.getCurrentLanguage();
        final String url = String.format(URL, Eln.playerUUID, version, lang);
        // Send HTTP get request
        CloseableHttpClient client = HttpClientBuilder.create().build();
        CloseableHttpResponse response = client.execute(new HttpGet(url));
        final int repCode = response.getStatusLine().getStatusCode();
        if (repCode != HttpStatus.SC_OK)
            throw new IOException("HTTP error " + repCode);
        // Utils.println("URL: " + url);
        response.close();
        client.close();
    } catch (Exception e) {
        String error = "Unable to send analytics data: " + e.getMessage() + ".";
        System.err.println(error);
    }
    AnalyticsHandler.getInstance().ready = true;
}

public String getDataPage(final String address) throws IOException {
    final HttpClientBuilder clientBuilder = HttpClientBuilder.create();
    final CloseableHttpClient httpclient = clientBuilder.build();
    final HttpGet request = new HttpGet(address);
    String result = null;
    try {
        request.setHeader("User-Agent", userAgent);
        final HttpResponse response = httpclient.execute(request);
        final StatusLine statusLine = response.getStatusLine();
        final int status = statusLine.getStatusCode();
        if ((status >= HttpStatus.SC_OK) && (status < HttpStatus.SC_MULTIPLE_CHOICES)) {
            final HttpEntity entity = response.getEntity();
            if (entity != null) {
                result = EntityUtils.toString(entity);
            }
        } else {
            if (LOGGER.isWarnEnabled()) {
                LOGGER.warn("Got " + status + " for the query " + address);
            }
        }
    } finally {
        request.reset();
        httpclient.close();
    }
    return result;
}

/**
	 * Send a rollback message to a Solr API endpoint.
	 *
	 * @return The response details from Solr.
	 */
private UpdateResponse rollbackSolr() {
    try (final CloseableHttpClient httpClient = PinnedHttpClientBuilder.createWithDefaults().setVerifyHostname(options.get("verifyHost").value().orElse(null)).pinCertificate(options.get("serverCertificate").value().orElse(null)).build();
        final SolrClient client = new HttpSolrClient.Builder(options.get("address").value().orElse("http://127.0.0.1:8983/solr/")).withHttpClient(httpClient).build()) {
        return client.rollback();
    } catch (SolrServerException e) {
        throw new RuntimeException("Unable to roll back uncommitted documents.", e);
    } catch (IOException e) {
        throw new RuntimeException("There was an error while communicating with Solr.", e);
    }
}

public static final void main(String[] args) throws Exception {
    CloseableHttpClient httpclient = HttpClients.createDefault();
    try {
        HttpGet httpget = new HttpGet("http://localhost/");
        System.out.println("Executing request " + httpget.getRequestLine());
        // Create a custom response handler
        ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

            public String handleResponse(final HttpResponse response) throws ClientProtocolException, IOException {
                int status = response.getStatusLine().getStatusCode();
                if (status >= 200 && status < 300) {
                    HttpEntity entity = response.getEntity();
                    return entity != null ? EntityUtils.toString(entity) : null;
                } else {
                    throw new ClientProtocolException("Unexpected response status: " + status);
                }
            }
        };
        String responseBody = httpclient.execute(httpget, responseHandler);
        System.out.println("----------------------------------------");
        System.out.println(responseBody);
    } finally {
        httpclient.close();
    }
}

@Override
public void executeApp() throws Exception {
    int port = getAvailablePort();
    HttpServer httpServer = Vertx.vertx().createHttpServer().requestHandler( req -> req.response().end("Hello World!")).listen(port);
    CloseableHttpClient httpClient = HttpClients.createDefault();
    HttpGet httpGet = new HttpGet("http://localhost:" + port + "/abc?xyz=123");
    int statusCode = httpClient.execute(httpGet).getStatusLine().getStatusCode();
    if (statusCode != 200) {
        throw new IllegalStateException("Unexpected status code: " + statusCode);
    }
    httpServer.close();
}

/**
	 * post request
	 */
public static byte[] postRequest(String reqURL, byte[] date) throws Exception {
    byte[] responseBytes = null;
    HttpPost httpPost = new HttpPost(reqURL);
    CloseableHttpClient httpClient = HttpClients.createDefault();
    try {
        // init post
        /*if (params != null && !params.isEmpty()) {
				List<NameValuePair> formParams = new ArrayList<NameValuePair>();
				for (Map.Entry<String, String> entry : params.entrySet()) {
					formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
				}
				httpPost.setEntity(new UrlEncodedFormEntity(formParams, "UTF-8"));
			}*/
        // timeout
        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(10000).setSocketTimeout(10000).setConnectTimeout(10000).build();
        httpPost.setConfig(requestConfig);
        // data
        if (date != null) {
            httpPost.setEntity(new ByteArrayEntity(date, ContentType.DEFAULT_BINARY));
        }
        // do post
        HttpResponse response = httpClient.execute(httpPost);
        HttpEntity entity = response.getEntity();
        if (null != entity) {
            responseBytes = EntityUtils.toByteArray(entity);
            EntityUtils.consume(entity);
        }
    } catch (Exception e) {
        logger.error("", e);
        throw e;
    } finally {
        httpPost.releaseConnection();
        try {
            httpClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return responseBytes;
}

public CloseableHttpClient build() throws Exception {
    HttpClientBuilder builder = HttpClients.custom();
    builder.setDefaultSocketConfig(SocketConfig.custom().setTcpNoDelay(true).setSoKeepAlive(true).build()).setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE);
    HostnameVerifier hostnameVerifier = sslVerificationMode.verifier();
    TrustStrategy trustStrategy = sslVerificationMode.trustStrategy();
    KeyStore trustStore = agentTruststore();
    SSLContextBuilder sslContextBuilder = SSLContextBuilder.create().useProtocol(systemEnvironment.get(SystemEnvironment.GO_SSL_TRANSPORT_PROTOCOL_TO_BE_USED_BY_AGENT));
    if (trustStore != null || trustStrategy != null) {
        sslContextBuilder.loadTrustMaterial(trustStore, trustStrategy);
    }
    sslContextBuilder.loadKeyMaterial(agentKeystore(), keystorePassword().toCharArray());
    SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContextBuilder.build(), hostnameVerifier);
    builder.setSSLSocketFactory(sslConnectionSocketFactory);
    return builder.build();
}

protected SimplifiedResponse post(String path, Map<String, String> formParameters) {
    List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
    for (Entry<String, String> entry : formParameters.entrySet()) {
        nameValuePairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
    }
    SimplifiedResponse responseToReturn = null;
    HttpClientBuilder clientBuilder = HttpClients.custom();
    try (CloseableHttpClient httpClient = clientBuilder.build()) {
        HttpPost request = new HttpPost("http://localhost:4204" + path);
        HttpEntity entity = new UrlEncodedFormEntity(nameValuePairs);
        request.setEntity(entity);
        try (CloseableHttpResponse response = httpClient.execute(request)) {
            responseToReturn = new SimplifiedResponse(response.getStatusLine().getStatusCode(), EntityUtils.toString(response.getEntity()));
        }
    } catch (IOException e) {
        new RuntimeException(e);
    }
    return responseToReturn;
}

public CloseableHttpClient configure(HttpClientBuilder builder, ResolverConfiguration configuration) {
    builder.disableAuthCaching();
    ConnectionConfiguration config = configuration.getConnectionConfiguration();
    builder.setConnectionManager(configurationManager(config));
    SocketConfig.Builder socketConfig = SocketConfig.copy(SocketConfig.DEFAULT);
    if (config.getSocketTimeout().isPresent()) {
        socketConfig.setSoTimeout(config.getSocketTimeout().get());
    }
    builder.setDefaultSocketConfig(socketConfig.build());
    ProxyAuthenticator proxyAuthenticator = configuration.getProxyAuthenticator();
    HTTPHost proxyHost = proxyAuthenticator.getConfiguration().getHost();
    RequestConfig requestC = requestConfig(proxyHost, config);
    builder.setDefaultRequestConfig(requestC);
    builder.setHttpProcessor(httpProcessor(configuration));
    return builder.build();
}

/*
	 * Path for method:
	 * "<server address>/TelcoReadyAppMFP/adapters/CloudantGeoAdapter/users/{user_id}/wifi"
	 */
@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("/{user_id}/wifi")
public Response getWifiLocations(@PathParam("user_id") String name, @QueryParam(value = "lat") double latitude, @QueryParam(value = "lon") double longitude) {
    GeoJsonPoint userLocation = new GeoJsonPoint(latitude, longitude);
    try {
        HttpGet httpget = new HttpGet(GeoRadiusURI.build(DEMO_LOCATION));
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpResponse httpResponse = httpClient.execute(httpget);
        if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.OK.getCode()) {
            String jsonString = EntityUtils.toString(httpResponse.getEntity());
            List<WifiHotspotFlat> hotspots = WifiHotspotUtils.parseAndOffsetHotspots(jsonString, userLocation);
            return Response.ok(new Gson().toJson(hotspots), MediaType.APPLICATION_JSON).build();
        }
        httpClient.close();
        return Response.serverError().entity(httpResponse.getStatusLine()).build();
    } catch (URISyntaxExceptionParseException | IOException |  e) {
        e.printStackTrace();
        return Response.serverError().entity("Error").build();
    }
}

private static String httpPost(String url, Message msg) throws Exception {
    CloseableHttpClient httpclient = HttpClients.createDefault();
    HttpPost httpPost = new HttpPost(url);
    List<NameValuePair> nvps = new ArrayList<NameValuePair>();
    nvps.add(new BasicNameValuePair("mid", msg.getMid()));
    nvps.add(new BasicNameValuePair("type", msg.getType()));
    nvps.add(new BasicNameValuePair("title", msg.getTitle()));
    nvps.add(new BasicNameValuePair("content", msg.getContent()));
    nvps.add(new BasicNameValuePair("sender", msg.getSender()));
    nvps.add(new BasicNameValuePair("receiver", msg.getReceiver()));
    nvps.add(new BasicNameValuePair("file", msg.getFile()));
    nvps.add(new BasicNameValuePair("fileType", msg.getFileType()));
    nvps.add(new BasicNameValuePair("timestamp", String.valueOf(msg.getTimestamp())));
    httpPost.setEntity(new UrlEncodedFormEntity(nvps));
    CloseableHttpResponse response2 = httpclient.execute(httpPost);
    String data = null;
    try {
        System.out.println(response2.getStatusLine());
        HttpEntity entity2 = response2.getEntity();
        data = EntityUtils.toString(entity2);
    } finally {
        response2.close();
    }
    return data;
}

public HttpClient build() {
    Registry<ConnectionSocketFactory> r = null;
    if (insecure) {
        RegistryBuilder rbuilder = RegistryBuilder.<ConnectionSocketFactory>create();
        rbuilder = rbuilder.register("https", insecureSocketFactory());
        r = rbuilder.build();
    }
    HttpClientConnectionManager cm;
    if (pooled) {
        if (r != null)
            cm = new PoolingHttpClientConnectionManager(r);
        else
            cm = new PoolingHttpClientConnectionManager();
    } else {
        if (r != null)
            cm = new BasicHttpClientConnectionManager(r);
        else
            cm = new BasicHttpClientConnectionManager();
    }
    CloseableHttpClient apacheHttpClient = HttpClients.custom().setConnectionManager(cm).build();
    return apacheHttpClient;
}

/**
   * Makes a simple HTTP Get request to the Price microservice
   * @return The price of the product
   */
@Override
public String getPrice() {
    String response = null;
    try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
        HttpGet httpGet = new HttpGet("http://localhost:50006/price");
        try (CloseableHttpResponse httpResponse = httpClient.execute(httpGet)) {
            response = EntityUtils.toString(httpResponse.getEntity());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return response;
}

private CloseableHttpClient buildClient(Config config) {
    HttpClientBuilder cb = HttpClientBuilder.create().setUserAgent(USER_AGENT);
    if (config.getProxy() != null) {
        try {
            URL url = new URL(config.getProxy().getHost());
            HttpHost proxy = new HttpHost(url.getHost(), config.getProxy().getPort(), url.getProtocol());
            cb.setProxy(proxy);
        } catch (MalformedURLException e) {
            LOG.error(e.getMessage(), e);
        }
    }
    if (config.isIgnoreSSLVerification()) {
        cb.setSslcontext(UntrustedSSL.getSSLContext());
        cb.setHostnameVerifier(new AllowAllHostnameVerifier());
    }
    if (config.getSslContext() != null)
        cb.setSslcontext(config.getSslContext());
    if (config.getMaxConnections() > 0) {
        cb.setMaxConnTotal(config.getMaxConnections());
    }
    if (config.getMaxConnectionsPerRoute() > 0) {
        cb.setMaxConnPerRoute(config.getMaxConnectionsPerRoute());
    }
    RequestConfig.Builder rcb = RequestConfig.custom();
    if (config.getConnectTimeout() > 0)
        rcb.setConnectTimeout(config.getConnectTimeout());
    if (config.getReadTimeout() > 0)
        rcb.setSocketTimeout(config.getReadTimeout());
    if (INTERCEPTOR != null) {
        INTERCEPTOR.onClientCreate(cb, rcb, config);
    }
    return cb.setDefaultRequestConfig(rcb.build()).build();
}

public String downloadFile(String url) {
    String filePath = null;
    // 1.生�httpclient对象，并设置�数
    CloseableHttpClient httpClient = HttpClients.createDefault();
    HttpGet httpget = new HttpGet(url);
    HttpResponse response;
    // 执行http get请求
    try {
        response = httpClient.execute(httpget);
        // 得到访问的状��
        int statusCode = response.getStatusLine().getStatusCode();
        // 判断访问的状��
        if (statusCode != HttpStatus.SC_OK) {
            System.err.println("Method faild: " + response.getStatusLine());
        }
        HttpEntity entity = response.getEntity();
        // 得到相应内容
        byte[] responseBody = EntityUtils.toByteArray(entity);
        // æ ¹æ?®ç½‘页url生æˆ?ä¿?存时的文件å??
        filePath = "d:\\temp\\" + getFileNameByUrl(url, response.getFirstHeader("Content-Type").getValue());
        saveToLocal(responseBody, filePath);
    } catch (IOException e) {
        e.printStackTrace();
    }
    return filePath;
}

@RequestMapping(method = RequestMethod.GET)
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
    String url = ServletRequestUtils.getRequiredStringParameter(request, "url");
    RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(15000).setSocketTimeout(15000).build();
    HttpGet method = new HttpGet(url);
    method.setConfig(requestConfig);
    InputStream in = null;
    try (CloseableHttpClient client = HttpClients.createDefault()) {
        try (CloseableHttpResponse resp = client.execute(method)) {
            int statusCode = resp.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {
                response.sendError(statusCode);
            } else {
                in = resp.getEntity().getContent();
                IOUtils.copy(in, response.getOutputStream());
            }
        }
    } finally {
        IOUtils.closeQuietly(in);
    }
    return null;
}

@Test
public void testServerInfo() throws Exception {
    String url = "http://localhost:8080/server/info";
    CloseableHttpClient client = HttpClients.createDefault();
    HttpGet httpGet = new HttpGet(url);
    try {
        CloseableHttpResponse response = client.execute(httpGet);
        int statusCode = response.getStatusLine().getStatusCode();
        Assert.assertEquals(200, statusCode);
        if (statusCode == 200) {
            String s = IOUtils.toString(response.getEntity().getContent(), "utf8");
            Assert.assertNotNull(s);
            logger.debug(s);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void testSolrException() throws Throwable {
    // test a connection to a solr server that probably doesn't exist
    // this is a very simple test and most of the test should be considered verified 
    // if the compiler won't let you by without the try/catch
    boolean gotExpectedError = false;
    CloseableHttpClient httpClient = null;
    try {
        // switched to a local address to avoid going out on the net, ns lookup issues, etc.
        // set a 1ms timeout to let the connection fail faster.
        httpClient = HttpClientUtil.createClient(null);
        try (HttpSolrClient client = getHttpSolrClient("http://[ff01::114]:11235/solr/", httpClient)) {
            client.setConnectionTimeout(1);
            SolrQuery query = new SolrQuery("test123");
            client.query(query);
        }
        httpClient.close();
    } catch (SolrServerException sse) {
        gotExpectedError = true;
    } finally {
        if (httpClient != null)
            HttpClientUtil.close(httpClient);
    }
    assertTrue(gotExpectedError);
}

public String getResponse() throws IOException, URISyntaxException {
    String response = "";
    // HttpClient httpclient = HttpClients.createDefault();
    HttpPost httppost = new HttpPost(url.toURI());
    RequestConfig config = RequestConfig.custom().setConnectTimeout(TIMEOUT_VALUE / 2).setConnectionRequestTimeout(TIMEOUT_VALUE).setSocketTimeout(4 * TIMEOUT_VALUE).build();
    CloseableHttpClient httpclient = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
    try {
        httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    /*
		 * Execute the HTTP Request
		 */
    try {
        HttpResponse httpresponse = httpclient.execute(httppost);
        HttpEntity respEntity = httpresponse.getEntity();
        if (respEntity != null) {
            // EntityUtils to get the response content
            response += EntityUtils.toString(respEntity);
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    httpclient.close();
    return response;
}

public static void main(String[] args) throws Exception {
    Configuration configuration = new Configuration();
    OAuthConsumer oAuthConsumer = new CommonsHttpOAuthConsumer(configuration.getProperty(ConfigurationProperty.CONSUMER_KEY), configuration.getProperty(ConfigurationProperty.CONSUMER_SECRET));
    oAuthConsumer.setTokenWithSecret(configuration.getProperty(ConfigurationProperty.TOKEN_VALUE), configuration.getProperty(ConfigurationProperty.TOKEN_SECRET));
    SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(null, new TrustAllStrategy()).build();
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null, SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
    CloseableHttpClient client = HttpClients.custom().setSSLSocketFactory(sslsf).build();
    try {
        HttpGet request = new HttpGet(BASE_URL + "/orders/1234567");
        oAuthConsumer.sign(request);
        CloseableHttpResponse httpResponse = client.execute(request);
        try {
            System.out.println("Code: " + httpResponse.getStatusLine().getStatusCode() + ',' + httpResponse.getStatusLine().getReasonPhrase());
            InputStream stream = httpResponse.getEntity().getContent();
            ObjectMapper mapper = new ObjectMapper();
            ResponseDT<List<OrderDT>> response = mapper.readValue(stream, new TypeReference<ResponseDT<OrderDT>>() {
            });
            System.out.println(response);
        } finally {
            httpResponse.close();
        }
    } finally {
        client.close();
    }
}

public static Boolean webhookCall(String url, String payload) throws Exception {
    String signature = "38c6cbd28bf165070d070980dd1fb595";
    CloseableHttpClient client = HttpClients.createDefault();
    try {
        HttpPost httpPost = new HttpPost(url);
        try {
            StringEntity dataEntity = new StringEntity(payload);
            try {
                httpPost.addHeader("X-Pyramus-Signature", signature);
                httpPost.setEntity(dataEntity);
                client.execute(httpPost);
                return true;
            } finally {
                EntityUtils.consume(dataEntity);
            }
        } finally {
            httpPost.releaseConnection();
        }
    } finally {
        client.close();
    }
}

private CloseableHttpClient buildClient(Config config) {
    HttpClientBuilder cb = HttpClientBuilder.create().setUserAgent(USER_AGENT);
    if (config.getProxy() != null) {
        try {
            URL url = new URL(config.getProxy().getHost());
            HttpHost proxy = new HttpHost(url.getHost(), config.getProxy().getPort(), url.getProtocol());
            cb.setProxy(proxy);
        } catch (MalformedURLException e) {
            LOG.error(e.getMessage(), e);
        }
    }
    if (config.isIgnoreSSLVerification()) {
        cb.setSslcontext(UntrustedSSL.getSSLContext());
        cb.setHostnameVerifier(new AllowAllHostnameVerifier());
    }
    if (config.getSslContext() != null)
        cb.setSslcontext(config.getSslContext());
    if (config.getMaxConnections() > 0) {
        cb.setMaxConnTotal(config.getMaxConnections());
    }
    if (config.getMaxConnectionsPerRoute() > 0) {
        cb.setMaxConnPerRoute(config.getMaxConnectionsPerRoute());
    }
    RequestConfig.Builder rcb = RequestConfig.custom();
    if (config.getConnectTimeout() > 0)
        rcb.setConnectTimeout(config.getConnectTimeout());
    if (config.getReadTimeout() > 0)
        rcb.setSocketTimeout(config.getReadTimeout());
    if (INTERCEPTOR != null) {
        INTERCEPTOR.onClientCreate(cb, rcb, config);
    }
    return cb.setDefaultRequestConfig(rcb.build()).build();
}

public static String get(String url) throws IOException {
    CloseableHttpClient client = HttpClients.createDefault();
    HttpGet httpget = new HttpGet(url);
    try (CloseableHttpResponse response = client.execute(httpget)) {
        HttpEntity entity = response.getEntity();
        return entity != null ? EntityUtils.toString(entity) : null;
    }
}

private CloseableHttpClient buildClient(Config config) {
    HttpClientBuilder cb = HttpClientBuilder.create().setUserAgent(USER_AGENT);
    if (config.getProxy() != null) {
        try {
            URL url = new URL(config.getProxy().getHost());
            HttpHost proxy = new HttpHost(url.getHost(), config.getProxy().getPort(), url.getProtocol());
            cb.setProxy(proxy);
        } catch (MalformedURLException e) {
            LOG.error(e.getMessage(), e);
        }
    }
    if (config.isIgnoreSSLVerification()) {
        cb.setSslcontext(UntrustedSSL.getSSLContext());
        cb.setHostnameVerifier(new AllowAllHostnameVerifier());
    }
    if (config.getSslContext() != null)
        cb.setSslcontext(config.getSslContext());
    if (config.getMaxConnections() > 0) {
        cb.setMaxConnTotal(config.getMaxConnections());
    }
    if (config.getMaxConnectionsPerRoute() > 0) {
        cb.setMaxConnPerRoute(config.getMaxConnectionsPerRoute());
    }
    RequestConfig.Builder rcb = RequestConfig.custom();
    if (config.getConnectTimeout() > 0)
        rcb.setConnectTimeout(config.getConnectTimeout());
    if (config.getReadTimeout() > 0)
        rcb.setSocketTimeout(config.getReadTimeout());
    if (INTERCEPTOR != null) {
        INTERCEPTOR.onClientCreate(cb, rcb, config);
    }
    return cb.setDefaultRequestConfig(rcb.build()).build();
}

@Test
public void doesCorrectRespondToARequestUsingDeleteMethod() throws IOException {
    CloseableHttpClient client = HttpClients.createDefault();
    HttpDelete method = new HttpDelete("http://localhost:8080/acceptance/delete/delete?id=1");
    HttpResponse response = client.execute(method);
    BufferedReader br = new BufferedReader(new InputStreamReader((response.getEntity().getContent())));
    String output;
    StringBuilder sb = new StringBuilder();
    while ((output = br.readLine()) != null) {
        sb.append(output);
    }
    assertTrue(sb.toString().contains("DELETE - delete/delete - id:1"));
    client.close();
}