HttpClient对外部网络的操作

包结构

|---src
    |---commons-logging-1.1.1.jar
    |---httpclient-4.5.jar
    |---httpcore-4.4.1.jar
    |---httpmime-4.5.jar
    |---log4j-1.2.17.jar
    |---slf4j-api-1.7.5.jar
|---lib
    |---\com\zy\httpclient
        |---HttpClientUtils.java
        |---NetUtils.java

代码

HttpClientUtils.java

package com.zy.httpclient;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.SocketTimeoutException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

import javax.net.ssl.SSLContext;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.ConnectionPoolTimeoutException;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

/**
 * 
 * @author louiseliu
 *
 */
public class HttpClientUtils{

    private static final Logger logger = Logger.getLogger(HttpClientUtils.class);

    //表示请求器是否已经做了初始化工作
    private boolean hasInit = false;

    //连接超时时间，默认10秒
    private int socketTimeout = 10000;

    //传输超时时间，默认30秒
    private int connectTimeout = 30000;

    //请求器的配置
    private RequestConfig requestConfig;

    //HTTP请求器
    private CloseableHttpClient httpClient;
    
    //本地的证书地址
    private String certLocalPath;
    
    //本地的证书密码
    private String certPassword;
    
    private static boolean useCert=false;
    /**
     *使用证书文件
     * @throws IOException
     * @throws KeyStoreException
     * @throws UnrecoverableKeyException
     * @throws NoSuchAlgorithmException
     * @throws KeyManagementException
     */
    private void init() throws IOException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyManagementException {
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        FileInputStream instream = new FileInputStream(new File(certLocalPath));//加载本地的证书进行https加密传输
        try {
            keyStore.load(instream, certPassword.toCharArray());//设置证书密码
        } catch (CertificateException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } finally {
            instream.close();
        }       
        

        SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, certPassword.toCharArray()).build();
        @SuppressWarnings("deprecation")
      //指定TLS版本
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[]{"TLSv1"},null,SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
      //设置httpclient的SSLSocketFactory
        httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        
        requestConfig = RequestConfig.custom().setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout).build();

        hasInit = true;
    }
    /**
     * 通过Https往API post xml数据
     * @param url    API地址
     * @param xmlObj 要提交的XML数据对象
     * @return API回包的实际数据
     * @throws IOException
     * @throws KeyStoreException
     * @throws UnrecoverableKeyException
     * @throws NoSuchAlgorithmException
     * @throws KeyManagementException
     */

    public String sendPost(String url, String postDataXML) throws IOException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyManagementException {
        if (useCert) {
            if (!hasInit) {
                init();
            }
        }
        String result = null;
        HttpPost httpPost = new HttpPost(url);
        StringEntity postEntity = new StringEntity(postDataXML, "UTF-8");
        httpPost.addHeader("Content-Type", "text/xml");
        httpPost.setEntity(postEntity);
        httpPost.setConfig(requestConfig);
        try {           
            HttpResponse response = httpClient.execute(httpPost);
            HttpEntity entity = response.getEntity();
            result = EntityUtils.toString(entity, "UTF-8");
        } catch (ConnectionPoolTimeoutException e) {
            logger.info("http get throw ConnectionPoolTimeoutException(wait time out)");

        } catch (ConnectTimeoutException e) {
            logger.info("http get throw ConnectTimeoutException");

        } catch (SocketTimeoutException e) {
            logger.info("http get throw SocketTimeoutException");

        } catch (Exception e) {
            logger.info("http get throw Exception");

        } finally {
            httpPost.abort();
        }
        return result;
    }
    /**
     * 设置连接超时时间
     *
     * @param socketTimeout 连接时长，默认10秒
     */
    public void setSocketTimeout(int socketTimeout) {
        this.socketTimeout = socketTimeout;
        resetRequestConfig();
    }

    /**
     * 设置传输超时时间
     *
     * @param connectTimeout 传输时长，默认30秒
     */
    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
        resetRequestConfig();
    }
    //连接超时时间，默认10秒
    private void resetRequestConfig(){
        requestConfig = RequestConfig.custom()
                .setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout).build();
    }

    /**
     * 允许商户自己做更高级更复杂的请求器配置
     *
     * @param requestConfig 设置HttpsRequest的请求器配置
     */
    public void setRequestConfig(RequestConfig requestConfig) {
        this.requestConfig = requestConfig;
    }    
    /**
     * 是否使用安全证书
    *
    * @param b 设置是否使用安全证书  默认为否
    */
    public void setUsCert(boolean b){
        useCert=b;
    }
}

NetUtils.java

package com.zy.httpclient;

import java.io.File;
import java.io.FileInputStream;
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.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.net.ssl.SSLContext;

import org.apache.http.HttpEntity;
import org.apache.http.ParseException;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
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.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;
import org.junit.Test;

public class NetUtils {

    private static final Logger logger = Logger.getLogger(NetUtils.class);

    // 表示请求器是否已经做了初始化工作
    private static boolean hasInit = false;

    // 连接超时时间，默认10秒
    private int socketTimeout = 10000;

    // 传输超时时间，默认30秒
    private int connectTimeout = 30000;

    // 请求器的配置
    private RequestConfig requestConfig= RequestConfig.custom().setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout).build();

    // HTTP请求器
    private static CloseableHttpClient httpClient;

    // 本地的证书地址
    private static String certLocalPath;

    // 本地的证书密码
    private static String certPassword;

    @Test
    public void jUnitTest() {
        String sendGet = sendGet("http://www.baidu.com/",false);
        System.out.println(sendGet);
    }
    /**
     * 使用证书文件
     * 
     * @throws IOException
     * @throws KeyStoreException
     * @throws UnrecoverableKeyException
     * @throws NoSuchAlgorithmException
     * @throws KeyManagementException
     */
    private static void init() throws IOException, KeyStoreException,
            UnrecoverableKeyException, NoSuchAlgorithmException,
            KeyManagementException {
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        FileInputStream instream = new FileInputStream(new File(certLocalPath));// 加载本地的证书进行https加密传输
        try {
            keyStore.load(instream, certPassword.toCharArray());// 设置证书密码
        } catch (CertificateException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } finally {
            instream.close();
        }
        SSLContext sslcontext = SSLContexts.custom()
                .loadKeyMaterial(keyStore, certPassword.toCharArray()).build();
        @SuppressWarnings("deprecation")
        // 指定TLS版本
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslcontext, new String[] { "TLSv1" }, null,
                SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
        // 设置httpclient的SSLSocketFactory
        httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        hasInit = true;
    }
    /**
     * 发送post请求
     * @param url       请求地址
     * @param params        请求参数
     * @param useCert   是否使用证书
     * @return
     */
    public String sendPost(String url,Map<String, String>params, boolean useCert) {
        String result=null;
        CloseableHttpClient httpclient = null;
        if (useCert) {//如果使用证书就初始化
                if (hasInit) {
                    try {
                        init();
                    } catch (Exception e) {
                        e.printStackTrace();
                        logger.error("httpClient======init错误");
                    }
                }
            httpclient=httpClient;
        }else {//不适用证书
            // 创建默认的httpClient实例.
            httpclient = HttpClients.createDefault();
        }
        // 创建httppost
        HttpPost httppost = new HttpPost(url);
        // 创建参数队列
        List<BasicNameValuePair> formparams =getFormParams(params);
        UrlEncodedFormEntity uefEntity;
        try {
            uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");
            httppost.setEntity(uefEntity);
            httppost.setConfig(requestConfig);//填写请求配置
            // System.out.println("executing request " + httppost.getURI());
            CloseableHttpResponse response = httpclient.execute(httppost);
            try {
                // 获取响应实体
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    StatusLine statusLine = response.getStatusLine();
                    int statusCode = statusLine.getStatusCode();
                    if (statusCode == 200) {
                        if (entity != null) {
                            // 打印响应内容长度
                            // entity.getContentLength());
                            // 打印响应内容
                            result = EntityUtils.toString(entity);
                        }
                    }
                }
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e1) {
            e1.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭连接,释放资源
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }
    /**
     * // 创建参数队列
     * @param params        参数的map
     * @return
     */
    private List<BasicNameValuePair> getFormParams(Map<String, String> params) {
        List<BasicNameValuePair> formparams = new ArrayList<BasicNameValuePair>();
        Set<String> keySet = params.keySet();
        for (Iterator<String> it = keySet.iterator(); it.hasNext();) {
            String name = it.next();
            String value = params.get(name);
            formparams.add(new BasicNameValuePair(name, value));
        }       
        return formparams;
    }
    /**
     * get发出网络请求 get请求
     * 
     * @param url
     *            功能和操作
     * @param map
     *            请求的map
     * @return 请求返回的数据
     */
    public static String sendGet(String netPath, Map<String, String> map,boolean useCert) {
        String body = changeMapToBody(map);
        netPath = netPath + "?" + body;
        String result = sendGet(netPath,useCert);
        return result;
    }

    /**
     * get发出网络请求 get请求
     * 
     * @param url
     *            功能和操作
     * @param body
     *            要get的数据 String body = "accountSid=" + ACCOUNT_SID + "&to=" +
     *            tel + "&templateid=" + templateid + "&param=" + param+
     *            createCommonParam();
     * @return 请求返回的数据
     */
    public static String sendGet(String netPath, String body,boolean useCert) {
        netPath = netPath + "?" + body;
        String result = sendGet(netPath,useCert);
        return result;
    }

    /**
     * 发送 get请求
     * 
     * @param url
     *            请求的地址
     * @return
     */
    public static String sendGet(String url,boolean useCert) {
        String result=null;
        CloseableHttpClient httpclient = null;
        if (useCert) {//如果使用证书就初始化
            if (hasInit) {
                try {
                    init();
                } catch (Exception e) {
                    e.printStackTrace();
                    logger.error("httpClient======init错误");
                }
            }
            httpclient=httpClient;
        }else {//不适用证书
            // 创建默认的httpClient实例.
            httpclient = HttpClients.createDefault();
        }
        try {
            // 创建httpget.
            HttpGet httpget = new HttpGet(url);
            // System.out.println("executing request " + httpget.getURI());
            // 执行get请求.
            CloseableHttpResponse response = httpclient.execute(httpget);
            try {
                // 获取响应实体
                HttpEntity entity = response.getEntity();
                // System.out.println("--------------------------------------");
                // 响应状态
                StatusLine statusLine = response.getStatusLine();
                int statusCode = statusLine.getStatusCode();
                if (statusCode == 200) {
                    if (entity != null) {
                        // 打印响应内容长度
                        // System.out.println("Response content length: " +
                        // entity.getContentLength());
                        // 打印响应内容
                        result = EntityUtils.toString(entity);
                        // System.out.println("Response content:789 " + result);
                    }
                }
                // System.out.println("------------------------------------");
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭连接,释放资源
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 上传文件
     * @return 
     */
    public static String upload(String postUrl,String fileUrl,boolean useCert) {
        String result=null;
        CloseableHttpClient httpclient = null;
        if (useCert) {//如果使用证书就初始化
            if (hasInit) {
                try {
                    init();
                } catch (Exception e) {
                    e.printStackTrace();
                    logger.error("httpClient======init错误");
                }
            }
            httpclient=httpClient;
        }else {//不适用证书
            // 创建默认的httpClient实例.
            httpclient = HttpClients.createDefault();
        }
        try {
            HttpPost httppost = new HttpPost(postUrl);

            FileBody bin = new FileBody(new File(fileUrl));
            StringBody comment = new StringBody("A binary file of some kind",
                    ContentType.TEXT_PLAIN);

            HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("bin", bin).addPart("comment", comment).build();

            httppost.setEntity(reqEntity);

            CloseableHttpResponse response = httpclient.execute(httppost);
            try {
                System.out.println(response.getStatusLine());
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    StatusLine statusLine = response.getStatusLine();
                    int statusCode = statusLine.getStatusCode();
                    if (statusCode == 200) {
                        if (resEntity != null) {
                            // 打印响应内容长度
                            // entity.getContentLength());
                            // 打印响应内容
                            result = EntityUtils.toString(resEntity);
                        }
                    }
                }
                EntityUtils.consume(resEntity);
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
            logger.error("upload======"+e);
        } catch (IOException e) {
            e.printStackTrace();
            logger.error("upload======"+e);
        } finally {
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
                logger.error("upload======"+e);
            }
        }
        return result;
    }

    /**
     * 将map请求参数格式化
     * 
     * @param ParamsMap
     *            请求的参数
     * @return 格式化后的参数
     */
    public static String changeMapToBody(Map<String, String> ParamsMap) {
        StringBuffer params = new StringBuffer();
        // 组织请求参数
        Iterator<?> it = ParamsMap.entrySet().iterator();
        while (it.hasNext()) {
            @SuppressWarnings("rawtypes")
            Map.Entry element = (Map.Entry) it.next();
            params.append(element.getKey());
            params.append("=");
            params.append(element.getValue());
            params.append("&");
        }
        if (params.length() > 0) {
            params.deleteCharAt(params.length() - 1);
        }
        return params.toString();
    }
}