Java实现Http客户端工具类

绝地灬酷狼 2021-07-24 16:41 400阅读 0赞

# 一 点睛 #

Http客户端工具类是我们常见工具类，在此提供一个。

# 二 代码 #

package com.imooc.demo.common.util;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.io.UnsupportedEncodingException;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.security.KeyManagementException;
    import java.security.KeyStore;
    import java.security.NoSuchAlgorithmException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLException;
    import javax.net.ssl.SSLSession;
    import javax.net.ssl.SSLSocket;
    import javax.net.ssl.TrustManager;
    import javax.net.ssl.X509TrustManager;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.apache.http.Consts;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpResponse;
    import org.apache.http.HttpStatus;
    import org.apache.http.NameValuePair;
    import org.apache.http.ParseException;
    import org.apache.http.client.ClientProtocolException;
    import org.apache.http.client.HttpClient;
    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.utils.URLEncodedUtils;
    import org.apache.http.conn.scheme.Scheme;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.conn.ssl.SSLContexts;
    import org.apache.http.conn.ssl.SSLSocketFactory;
    import org.apache.http.conn.ssl.X509HostnameVerifier;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.protocol.HTTP;
    import org.apache.http.util.EntityUtils;
    
    
    /**
     * @className: HttpClientUtils
     * @description: 封装了一些采用HttpClient发送HTTP请求的方法
     * @date: 2020/8/20
     * @author: cakin
     */
    public class HttpClientUtils {
    
        private static Log logger = LogFactory.getLog(HttpClientUtils.class);
    
        private HttpClientUtils() {
        }
    
    
        /**
         * 发送HTTP_GET请求
         *
         * @param reqURL        请求地址(含参数)
         * @param decodeCharset 解码字符集,解析响应数据时用到,为null时默认采用UTF-8解码
         * @return 远程主机响应正文
         * @description 该方法会自动关闭连接, 释放资源
         */
        public static String sendGetRequest(String reqURL, String decodeCharset) {
            long responseLength = 0;       // 响应长度
            String responseContent = null; // 响应内容
            HttpClient httpClient = new DefaultHttpClient(); // 创建默认的httpClient实例
            HttpGet httpGet = new HttpGet(reqURL);           // 创建org.apache.http.client.methods.HttpGet
            try {
                HttpResponse response = httpClient.execute(httpGet); // 执行GET请求
                HttpEntity entity = response.getEntity();            // 获取响应实体
                if (null != entity) {
                    responseLength = entity.getContentLength();
                    responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
                    EntityUtils.consume(entity); // Consume response content
                }
                System.out.println("请求地址: " + httpGet.getURI());
                System.out.println("响应状态: " + response.getStatusLine());
                System.out.println("响应长度: " + responseLength);
                System.out.println("响应内容: " + responseContent);
            } catch (ClientProtocolException e) {
                logger.debug("该异常通常是协议错误导致,比如构造HttpGet对象时传入的协议不对(将'http'写成'htp')或者服务器端返回的内容不符合HTTP协议要求等,堆栈信息如下", e);
            } catch (ParseException e) {
                logger.debug(e.getMessage(), e);
            } catch (IOException e) {
                logger.debug("该异常通常是网络原因引起的,如HTTP服务器未启动等,堆栈信息如下", e);
            } finally {
                httpClient.getConnectionManager().shutdown(); //关闭连接,释放资源
            }
            return responseContent;
        }
    
    
        /**
         * @see 当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][ ]等特殊字符进行<code>URLEncoder.encode(string,"UTF-8")</code>
         */
        /**
         * 功能描述：发送HTTP_POST请求
         *
         * @param reqURL    请求地址
         * @param sendData  请求数据
         * @param isEncoder 用于指明请求数据是否需要UTF-8编码,true为需要
         * @return String 远程主机响应正文
         * @author cakin
         * @date 2020/8/20
         * @description: 该方法为 public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder, String encodeCharset, String decodeCharset)的简化方法
         * 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
         * 当isEncoder=true时,其会自动对sendData中的[中文][|][ ]等特殊字符进行URLEncoder.encode(string,"UTF-8")
         */
        public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder) {
            return sendPostRequest(reqURL, sendData, isEncoder, null, null);
        }
    
        /**
         * 发送HTTP_POST请求
         *
         * @param reqURL        请求地址
         * @param sendData      请求参数,若有多个参数则应拼接成param1=value1&param2=value2&param3=value3的形式后,传入该参数中
         * @param isEncoder     请求数据是否需要encodeCharset编码,true为需要
         * @param encodeCharset 编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
         * @param decodeCharset 解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
         * @return 远程主机响应正文
         * @description 该方法会自动关闭连接, 释放资源
         * 当 isEncoder=true 时,其会自动对 sendData 中的[中文][|][ ]等特殊字符进行 URLEncoder.encode(string,encodeCharset)
         */
        public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder, String encodeCharset, String decodeCharset) {
            String responseContent = null;
            HttpClient httpClient = new DefaultHttpClient();
    
            HttpPost httpPost = new HttpPost(reqURL);
            //httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded; charset=UTF-8");
            httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");
            try {
                if (isEncoder) {
                    List<NameValuePair> formParams = new ArrayList<NameValuePair>();
                    for (String str : sendData.split("&")) {
                        formParams.add(new BasicNameValuePair(str.substring(0, str.indexOf("=")), str.substring(str.indexOf("=") + 1)));
                    }
                    httpPost.setEntity(new StringEntity(URLEncodedUtils.format(formParams, encodeCharset == null ? "UTF-8" : encodeCharset)));
                } else {
                    httpPost.setEntity(new StringEntity(sendData));
                }
    
                HttpResponse response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
                    EntityUtils.consume(entity);
                }
            } catch (Exception e) {
                logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下", e);
            } finally {
                httpClient.getConnectionManager().shutdown();
            }
            return responseContent;
        }
    
    
        /**
         * 发送HTTP_POST请求
         *
         * @param reqURL        请求地址
         * @param params        请求参数
         * @param encodeCharset 编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
         * @param decodeCharset 解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
         * @return 远程主机响应正文
         * @description 该方法会自动关闭连接, 释放资源
         * 当 isEncoder=true 时,其会自动对 sendData 中的[中文][|][ ]等特殊字符进行 URLEncoder.encode(string,encodeCharset)
         */
        public static String sendPostRequest(String reqURL, Map<String, String> params, String encodeCharset, String decodeCharset) {
            String responseContent = null;
            HttpClient httpClient = new DefaultHttpClient();
    
            HttpPost httpPost = new HttpPost(reqURL);
            List<NameValuePair> formParams = new ArrayList<NameValuePair>(); //创建参数队列
            for (Map.Entry<String, String> entry : params.entrySet()) {
                formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            try {
                httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset == null ? "UTF-8" : encodeCharset));
    
                HttpResponse response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
                    EntityUtils.consume(entity);
                }
            } catch (Exception e) {
                logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下", e);
            } finally {
                httpClient.getConnectionManager().shutdown();
            }
            return responseContent;
        }
    
        /**
         * 功能描述：发送HTTPS_POST请求
         *
         * @param reqURL 请求地址
         * @param params 请求参数
         * @return 远程主机响应正文
         * @author cakin
         * @date 2020/8/20
         * @description: 该方法为 sendPostSSLRequest(String,Map<String,String>,String,String) 方法的简化方法
         * 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
         * 该方法会自动对 params 中的[中文][|][ ]等特殊字符进行 URLEncoder.encode(string,"UTF-8")
         */
        public static String sendPostSSLRequest(String reqURL, Map<String, String> params) {
            return sendPostSSLRequest(reqURL, params, null, null);
        }
    
        /**
         * 发送HTTPS_POST请求
         *
         * @param reqURL        请求地址
         * @param params        请求参数
         * @param encodeCharset 编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
         * @param decodeCharset 解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
         * @return 远程主机响应正文
         * @description 该方法会自动关闭连接, 释放资源
         * 该方法会自动对 params 中的[中文][|][ ]等特殊字符进行 URLEncoder.encode(string,"UTF-8")
         */
        public static String sendPostSSLRequest(String reqURL, Map<String, String> params, String encodeCharset, String decodeCharset) {
            String responseContent = "";
            HttpClient httpClient = new DefaultHttpClient();
            X509TrustManager xtm = new X509TrustManager() {
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }
    
                public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }
    
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            };
            try {
                SSLContext ctx = SSLContext.getInstance("TLS");
                ctx.init(null, new TrustManager[]{xtm}, null);
                SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
                httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 443, socketFactory));
    
                HttpPost httpPost = new HttpPost(reqURL);
                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, encodeCharset == null ? "UTF-8" : encodeCharset));
    
                HttpResponse response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
                    EntityUtils.consume(entity);
                }
            } catch (Exception e) {
                logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息为", e);
            } finally {
                httpClient.getConnectionManager().shutdown();
            }
            return responseContent;
        }
    
    
        /**
         * 发送HTTP_POST请求
         *
         * @param reqURL 请求地址
         * @param params 发送到远程主机的正文数据
         * @return 远程主机响应正文`HTTP状态码
         * "SUCCESS`200"：
         * 若通信过程中发生异常则返回 "Failed`HTTP状态码"
         * "Failed`500"
         * @description 若发送的 params 中含有中文,记得按照双方约定的字符集将中文 URLEncoder.encode(string,encodeCharset)
         * 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
         */
        public static String sendPostRequestByJava(String reqURL, Map<String, String> params) {
            StringBuilder sendData = new StringBuilder();
            for (Map.Entry<String, String> entry : params.entrySet()) {
                sendData.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
            }
            if (sendData.length() > 0) {
                sendData.setLength(sendData.length() - 1); // 删除最后一个&符号
            }
            return sendPostRequestByJava(reqURL, sendData.toString());
        }
    
    
        /**
         * 发送HTTP_POST请求
         *
         * @param reqURL   请求地址
         * @param sendData 发送到远程主机的正文数据
         * @return 远程主机响应正文`HTTP状态码
         * "SUCCESS`200"：
         * 若通信过程中发生异常则返回 "Failed`HTTP状态码"
         * "Failed`500"
         * @description 若发送的 sendData 中含有中文,记得按照双方约定的字符集将中文 URLEncoder.encode(string,encodeCharset)
         * 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
         */
        public static String sendPostRequestByJava(String reqURL, String sendData) {
            HttpURLConnection httpURLConnection = null;
            OutputStream out = null; // 写
            InputStream in = null;   // 读
            int httpStatusCode = 0;  // 远程主机响应的HTTP状态码
            try {
                URL sendUrl = new URL(reqURL);
                httpURLConnection = (HttpURLConnection) sendUrl.openConnection();
                httpURLConnection.setRequestMethod("POST");
                httpURLConnection.setDoOutput(true);        // 指示应用程序要将数据写入URL连接,其值默认为false
                httpURLConnection.setUseCaches(false);
                httpURLConnection.setConnectTimeout(30000); // 30秒连接超时
                httpURLConnection.setReadTimeout(30000);    // 30秒读取超时
    
                out = httpURLConnection.getOutputStream();
                out.write(sendData.toString().getBytes());
    
                //清空缓冲区,发送数据
                out.flush();
    
                //获取HTTP状态码
                httpStatusCode = httpURLConnection.getResponseCode();
    
                in = httpURLConnection.getInputStream();
                byte[] byteDatas = new byte[in.available()];
                in.read(byteDatas);
                return new String(byteDatas) + "`" + httpStatusCode;
            } catch (Exception e) {
                logger.debug(e.getMessage());
                return "Failed`" + httpStatusCode;
            } finally {
                if (out != null) {
                    try {
                        out.close();
                    } catch (Exception e) {
                        logger.debug("关闭输出流时发生异常,堆栈信息如下", e);
                    }
                }
                if (in != null) {
                    try {
                        in.close();
                    } catch (Exception e) {
                        logger.debug("关闭输入流时发生异常,堆栈信息如下", e);
                    }
                }
                if (httpURLConnection != null) {
                    httpURLConnection.disconnect();
                    httpURLConnection = null;
                }
            }
        }
    
        /**
         * https post请求，可以绕过证书校验
         *
         * @param url    请求地址
         * @param params 参数
         * @return String
         */
        public static final String sendHttpsRequestByPost(String url, Map<String, String> params) {
            String responseContent = null;
            HttpClient httpClient = new DefaultHttpClient();
            // 创建TrustManager
            X509TrustManager xtm = new X509TrustManager() {
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }
    
                public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }
    
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            };
            // 这个好像是HOST验证
            X509HostnameVerifier hostnameVerifier = new X509HostnameVerifier() {
                public boolean verify(String arg0, SSLSession arg1) {
                    return true;
                }
    
                public void verify(String arg0, SSLSocket arg1) throws IOException {
                }
    
                public void verify(String arg0, String[] arg1, String[] arg2) throws SSLException {
                }
    
                public void verify(String arg0, X509Certificate arg1) throws SSLException {
                }
            };
            try {
                // TLS1.0与SSL3.0基本上没有太大的差别，可粗略理解为TLS是SSL的继承者，但它们使用的是相同的SSLContext
                SSLContext ctx = SSLContext.getInstance("TLS");
                // 使用TrustManager来初始化该上下文，TrustManager只是被SSL的Socket所使用
                ctx.init(null, new TrustManager[]{xtm}, null);
                // 创建SSLSocketFactory
                SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
                socketFactory.setHostnameVerifier(hostnameVerifier);
                // 通过SchemeRegistry将SSLSocketFactory注册到我们的HttpClient上
                httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", socketFactory, 443));
                HttpPost httpPost = new HttpPost(url);
                List<NameValuePair> formParams = new ArrayList<NameValuePair>(); // 构建POST请求的表单参数
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
                }
                httpPost.setEntity(new UrlEncodedFormEntity(formParams, "UTF-8"));
                HttpResponse response = httpClient.execute(httpPost);
                HttpEntity entity = response.getEntity(); // 获取响应实体
                if (entity != null) {
                    responseContent = EntityUtils.toString(entity, "UTF-8");
                }
            } catch (KeyManagementException e) {
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (ClientProtocolException e) {
                e.printStackTrace();
            } catch (ParseException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 关闭连接,释放资源
                httpClient.getConnectionManager().shutdown();
            }
            return responseContent;
        }
    
    
        /**
         * 发送HTTP_POST请求,json格式数据
         *
         * @param url  请求
         * @param body json格式数据
         * @return 主机返回数据
         * @throws Exception 异常
         */
        public static String sendPostByJson(String url, String body) throws Exception {
            CloseableHttpClient httpclient = HttpClients.custom().build();
            HttpPost post = null;
            String resData = null;
            CloseableHttpResponse result = null;
            try {
                post = new HttpPost(url);
                HttpEntity entity2 = new StringEntity(body, Consts.UTF_8);
                post.setConfig(RequestConfig.custom().setConnectTimeout(30000).setSocketTimeout(30000).build());
                post.setHeader("Content-Type", "application/json");
                post.setEntity(entity2);
                result = httpclient.execute(post);
                if (HttpStatus.SC_OK == result.getStatusLine().getStatusCode()) {
                    resData = EntityUtils.toString(result.getEntity());
                }
            } finally {
                if (result != null) {
                    result.close();
                }
                if (post != null) {
                    post.releaseConnection();
                }
                httpclient.close();
            }
            return resData;
        }
    
        /**
         * https 通过证书post发送
         *
         * @param url 请求地址
         * @param data 请求数据
         * @param ca 证书
         * @param caPwd 证书密码
         * @return String 主机返回数据
         * @throws Exception
         */
        public static String httpsPostByCa(String url, String data, String ca, String caPwd) throws Exception {
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            FileInputStream is = new FileInputStream(new File(ca));
            try {
                keyStore.load(is, caPwd.toCharArray());// 这里写密码..默认是你的MCHID
            } finally {
                is.close();
            }
            // Trust own CA and all self-signed certs
            SSLContext sslcontext = SSLContexts.custom()
                    .loadKeyMaterial(keyStore, caPwd.toCharArray())// 这里也是写密码的
                    .build();
            // Allow TLSv1 protocol only
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                    sslcontext, new String[]{"TLSv1"}, null,
                    SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
            CloseableHttpClient httpclient = HttpClients.custom()
                    .setSSLSocketFactory(sslsf).build();
            try {
                HttpPost httpost = new HttpPost(url); // 设置响应头信息
                httpost.addHeader("Connection", "keep-alive");
                httpost.addHeader("Accept", "*/*");
                httpost.addHeader("Content-Type",
                        "application/x-www-form-urlencoded; charset=UTF-8");
                httpost.addHeader("Host", "api.mch.weixin.qq.com");
                httpost.addHeader("X-Requested-With", "XMLHttpRequest");
                httpost.addHeader("Cache-Control", "max-age=0");
                httpost.addHeader("User-Agent",
                        "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0) ");
                httpost.setEntity(new StringEntity(data, "UTF-8"));
                CloseableHttpResponse response = httpclient.execute(httpost);
                try {
                    HttpEntity entity = response.getEntity();
                    String jsonStr = EntityUtils.toString(response.getEntity(),
                            "UTF-8");
                    EntityUtils.consume(entity);
                    return jsonStr;
                } finally {
                    response.close();
                }
            } finally {
                httpclient.close();
            }
        }
    }