apache httpclient 4 范例

下面是一个通过apache httpclient 4 实现http/https的普通访问和BasicAuth认证访问的例子。依赖的第三方库为：
下面是具体实现：
package test;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.security.KeyManagementException;

import java.security.KeyStore;

import java.security.KeyStoreException;

import java.security.NoSuchAlgorithmException;

import java.security.cert.CertificateException;

import java.security.cert.X509Certificate;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import javax.net.ssl.SSLContext;

import org.apache.commons.io.IOUtils;

import org.apache.http.HttpEntity;

import org.apache.http.HttpStatus;

import org.apache.http.NameValuePair;

import org.apache.http.auth.AuthScope;

import org.apache.http.auth.UsernamePasswordCredentials;

import org.apache.http.client.CredentialsProvider;

import org.apache.http.client.config.RequestConfig;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.client.methods.HttpRequestBase;

import org.apache.http.config.Registry;

import org.apache.http.config.RegistryBuilder;

import org.apache.http.conn.socket.ConnectionSocketFactory;

import org.apache.http.conn.socket.LayeredConnectionSocketFactory;

import org.apache.http.conn.socket.PlainConnectionSocketFactory;

import org.apache.http.conn.ssl.SSLConnectionSocketFactory;

import org.apache.http.conn.ssl.SSLContexts;

import org.apache.http.conn.ssl.TrustStrategy;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.client.BasicCredentialsProvider;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClientBuilder;

import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;

import org.apache.http.message.BasicNameValuePair;  

/**

 * HttpClient的包装类，支持http/https的普通访问和basic Auth认证访问

 * @author needle

 *

 */

public class HttpUtilDemo {

    //默认超时时间

    private static final int DEFAULT_TIMEOUT = 5000;

    public static class HttpResult{

        public final int STATUS;

        public String CONTENT;

        public HttpResult(int status, String content){

            this.STATUS = status;

            this.CONTENT = content;

        }

    }

    private static void setTimeout(HttpRequestBase post) {

        RequestConfig requestConfig = RequestConfig.custom()

                .setConnectTimeout(DEFAULT_TIMEOUT).setConnectionRequestTimeout(DEFAULT_TIMEOUT)

                .setSocketTimeout(DEFAULT_TIMEOUT).build(); 

        post.setConfig(requestConfig);

    }

    //这里是同时支持http/https的关键

    private static CloseableHttpClient getHttpClient(HttpClientBuilder httpClientBuilder) {

        RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.<ConnectionSocketFactory>create();

        ConnectionSocketFactory plainSF = new PlainConnectionSocketFactory();

        registryBuilder.register("http", plainSF);

        //指定信任密钥存储对象和连接套接字工厂

        try {

            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());

            //信任任何链接

            TrustStrategy anyTrustStrategy = new TrustStrategy() {

                @Override

                public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

                    return true;

                }

            };

            SSLContext sslContext = SSLContexts.custom().useTLS().loadTrustMaterial(trustStore, anyTrustStrategy).build();

            LayeredConnectionSocketFactory sslSF = new SSLConnectionSocketFactory(sslContext, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

            registryBuilder.register("https", sslSF);

        } catch (KeyStoreException e) {

            throw new RuntimeException(e);

        } catch (KeyManagementException e) {

            throw new RuntimeException(e);

        } catch (NoSuchAlgorithmException e) {

            throw new RuntimeException(e);

        }

        Registry<ConnectionSocketFactory> registry = registryBuilder.build();

        //设置连接管理器

        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(registry); 

        //构建客户端

        return httpClientBuilder.setConnectionManager(connManager).build();

    }  

    //获取普通访问的HttpClient

    private static CloseableHttpClient getHttpClient() {

        return getHttpClient(HttpClientBuilder.create());

    }

    //获取支持basic Auth认证的HttpClient

    private static CloseableHttpClient getHttpClientWithBasicAuth(String username, String password){

        return getHttpClient(credential(username, password));

    }

    //配置basic Auth 认证

    private static HttpClientBuilder credential(String username, String password) {

        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

        CredentialsProvider provider = new BasicCredentialsProvider();

        AuthScope scope = new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT, AuthScope.ANY_REALM);

        UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(username, password);

        provider.setCredentials(scope, credentials);

        httpClientBuilder.setDefaultCredentialsProvider(provider);

        return httpClientBuilder;

    }

    //设置头信息，e.g. content-type 等

    private static void setHeaders(HttpRequestBase req, Map<String, String> headers){

        if(headers == null) return;

        for(Entry<String, String> header : headers.entrySet()){

            req.setHeader(header.getKey(), header.getValue());

        }

    }

    /**

     * get基础类，支持普通访问和Basic Auth认证

     * @param uri

     * @param headers

     * @param client 不同的方式不同的HttpClient

     * @param isTimeout 是否超时

     * @return

     */

    private static HttpResult get(String uri, Map<String, String> headers, CloseableHttpClient client, boolean isTimeout){

        try(CloseableHttpClient httpClient = client){

            HttpGet get = new HttpGet(uri);

            setHeaders(get, headers);

            if(isTimeout){

                setTimeout(get);

            }

            try(CloseableHttpResponse httpResponse = httpClient.execute(get)){

                int status = httpResponse.getStatusLine().getStatusCode();

                if(status != HttpStatus.SC_NOT_FOUND){

                    return new HttpResult(status, IOUtils.toString(httpResponse.getEntity().getContent(), "utf-8"));

                }else{

                    return new HttpResult(status, "404");

                }

            }

        } catch (IOException e) {

            throw new RuntimeException(e);

        }

    }

    public static HttpResult get(String uri, Map<String, String> headers, boolean isTimeout){

        return get(uri, headers, getHttpClient(), isTimeout);

    }

    public static HttpResult getWithBaiscAuth(String uri, Map<String, String> headers, String username, String password, boolean isTimeout){

        return get(uri, headers, getHttpClientWithBasicAuth(username, password), isTimeout);

    }

    public static HttpEntity createUrlEncodedFormEntity(Map<String, String> params){

        List<NameValuePair> data = new ArrayList<>();

        for(Map.Entry<String, String> entry : params.entrySet()){

            data.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));

        }

        try {

            return new UrlEncodedFormEntity(data, "UTF-8");

        } catch (UnsupportedEncodingException e) {

            throw new RuntimeException(e);

        }

    }

    public static HttpEntity createStringEntity(String body){

        try {

            return  new StringEntity(body);

        } catch (UnsupportedEncodingException e) {

            throw new RuntimeException(e);

        }

    }

    private static HttpResult post(CloseableHttpClient client, String uri, Map<String, String> headers, HttpEntity entity, boolean isTimeout){

        try(CloseableHttpClient httpClient = client){

            HttpPost post = new HttpPost(uri);

            setHeaders(post, headers);

            if(isTimeout){

                setTimeout(post);

            }

            post.setEntity(entity);

            try(CloseableHttpResponse httpResponse = httpClient.execute(post)){

                int status = httpResponse.getStatusLine().getStatusCode();

                if(status != HttpStatus.SC_NOT_FOUND){

                    return new HttpResult(status, IOUtils.toString(httpResponse.getEntity().getContent(), "utf-8"));

                }else{

                    return new HttpResult(status, "404");

                }

            }

        } catch (IOException e) {

            throw new RuntimeException(e);

        }

    }

    public static HttpResult post(String uri, Map<String, String> headers, HttpEntity entity, boolean isTimeout){

        return post(getHttpClient(), uri,headers, entity, isTimeout);

    }

    public static HttpResult postWithBasicAuth(String uri, Map<String, String> headers, String username, String password, HttpEntity entity, boolean isTimeout){

        return post(getHttpClientWithBasicAuth(username, password), uri, headers,  entity, isTimeout);

    }

    public static void main(String[] args) throws UnsupportedEncodingException {

        Map<String, String> headers = new HashMap<String, String>();

        headers.put("isClient","true");

        headers.put("content-type", "application/xml");

        headers.put("content-encoding", "UTF-8");

        String body = "<action><status></status><fault><reason></reason><detail></detail></fault></action>";

        //测试操作Ovirt 虚拟机

        HttpResult result = postWithBasicAuth("https://192.168.104.71/api/vms/41feaa71-4cb9-4c22-9380-ee530143eb0d/stop", headers, "sysadmin@internal", "admin==1", new StringEntity(body), false);

        System.out.println(result.STATUS);

        System.out.println(result.CONTENT);

    }

}