HttpClient处理类

package **.tool;

import cn.hutool.http.ssl.TrustAnyHostnameVerifier;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
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.URIBuilder;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
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.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.ClassPathResource;

import javax.net.ssl.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.KeyStore;
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;

/**
 * HttpClient发送GET、POST请求
 *
 * @Author libin
 * @CreateDate 2018.5.28 16:56
 */
public class HttpClientService {

    private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientService.class);
    /**
     * 返回成功状态码
     */
    private static final int SUCCESS_CODE = 200;

    /**
     * 发送GET请求
     *
     * @param url               请求url
     * @param nameValuePairList 请求参数
     * @return JSON或者字符串
     * @throws Exception
     */
    public static Object sendGet(String url, List<NameValuePair> nameValuePairList) throws Exception {
        JSONObject jsonObject = null;
        CloseableHttpClient client = null;
        CloseableHttpResponse response = null;
        try {
            HttpClientBuilder httpClientBuilder = HttpClients.custom();
            //添加SSL证书
            SSLConnectionSocketFactory scsf = getSSLConnectionSocketFactory("/172.18.3.30(12345678).pfx", "12345678");
            httpClientBuilder = httpClientBuilder.setSSLSocketFactory(scsf);

            /**
             * 创建HttpClient对象
             */
            client = httpClientBuilder.build();
            //client = HttpClients.createDefault();
            /**
             * 创建URIBuilder
             */
            URIBuilder uriBuilder = new URIBuilder(url);
            /**
             * 设置参数
             */
            uriBuilder.addParameters(nameValuePairList);
            /**
             * 创建HttpGet
             */
            HttpGet httpGet = new HttpGet(uriBuilder.build());
            /**
             * 设置请求头部编码
             */
            httpGet.setHeader(new BasicHeader("Content-Type", "application/x-www-form-urlencoded; charset=utf-8"));
            /**
             * 设置返回编码
             */
            httpGet.setHeader(new BasicHeader("Accept", "text/plain;charset=utf-8"));
            /**
             * 请求服务
             */
            response = client.execute(httpGet);
            /**
             * 获取响应吗
             */
            int statusCode = response.getStatusLine().getStatusCode();

            if (SUCCESS_CODE == statusCode) {
                /**
                 * 获取返回对象
                 */
                HttpEntity entity = response.getEntity();
                /**
                 * 通过EntityUitls获取返回内容
                 */
                String result = EntityUtils.toString(entity, "UTF-8");
                /**
                 * 转换成json,根据合法性返回json或者字符串
                 */
                try {
                    jsonObject = JSONObject.parseObject(result);
                    return jsonObject;
                } catch (Exception e) {
                    return result;
                }
            } else {
                LOGGER.error("HttpClientService-line: {}, errorMsg{}", 97, "GET请求失败！");
            }
        } catch (Exception e) {
            LOGGER.error("HttpClientService-line: {}, Exception: {}", 100, e);
        } finally {
            response.close();
            client.close();
        }
        return null;
    }

    /**
     * 发送POST请求
     *
     * @param url
     * @param nameValuePairList
     * @return JSON或者字符串
     * @throws Exception
     */
    public static Object sendPost(String url, List<NameValuePair> nameValuePairList,String path,String passWord) throws Exception {
        JSONObject jsonObject = null;
        CloseableHttpClient client = null;
        new HttpClientService();
        CloseableHttpResponse response = null;
        try {
            HttpClientBuilder httpClientBuilder = HttpClients.custom();
            //添加SSL证书
            SSLConnectionSocketFactory scsf = getSSLConnectionSocketFactory(path, passWord);
            httpClientBuilder = httpClientBuilder.setSSLSocketFactory(scsf);

            /**
             * 创建HttpClient对象
             */
            client = httpClientBuilder.build();
            //client = HttpClients.createDefault();
            /**
             * 创建一个post对象
             */
            HttpPost post = new HttpPost(url);
            /**
             * 包装成一个Entity对象
             */
            StringEntity entity = new UrlEncodedFormEntity(nameValuePairList, "UTF-8");
            /**
             * 设置请求的内容
             */
            post.setEntity(entity);
            /**
             * 设置请求的报文头部的编码
             */
            post.setHeader(new BasicHeader("Content-Type", "application/x-www-form-urlencoded; charset=utf-8"));
            /**
             * 设置请求的报文头部的编码
             */
            //  post.setHeader(new BasicHeader("Accept", "text/plain;charset=utf-8"));
            /**
             * 执行post请求
             */
            response = client.execute(post);
            /**
             * 获取响应码
             */
            int statusCode = response.getStatusLine().getStatusCode();
            if (SUCCESS_CODE == statusCode) {
                /**
                 * 通过EntityUitls获取返回内容
                 */
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                /**
                 * 转换成json,根据合法性返回json或者字符串
                 */
                try {
                    jsonObject = JSONObject.parseObject(result);
                    return jsonObject;
                } catch (Exception e) {
                    return result;
                }
            } else {
                LOGGER.error("HttpClientService-line: {}, errorMsg：{}", 146, "POST请求失败！");
            }
        } catch (Exception e) {
            LOGGER.error("HttpClientService-line: {}, Exception：{}", 149, e);
        } finally {
            response.close();
            client.close();
        }
        return null;
    }

    /**
     * 组织请求参数{参数名和参数值下标保持一致}
     *
     * @param params 参数名数组
     * @param values 参数值数组
     * @return 参数对象
     */
    public static List<NameValuePair> getParams(Object[] params, Object[] values) {
        /**
         * 校验参数合法性
         */
        boolean flag = params.length > 0 && values.length > 0 && params.length == values.length;
        if (flag) {
            List<NameValuePair> nameValuePairList = new ArrayList<>();
            for (int i = 0; i < params.length; i++) {
                nameValuePairList.add(new BasicNameValuePair(params[i].toString(), values[i].toString()));
            }
            return nameValuePairList;
        } else {
            LOGGER.error("HttpClientService-line: {}, errorMsg：{}", 197, "请求参数为空且参数长度不一致");
        }
        return null;
    }


    /**
     * 获取SSLConnectionSocketFactory
     *
     * @param caPath
     * @param caPassword
     * @return
     */
    private static Map<String, SSLConnectionSocketFactory> crtMap = new HashMap<String, SSLConnectionSocketFactory>();

    private static SSLConnectionSocketFactory getSSLConnectionSocketFactory(String caPath, String caPassword) {
        SSLConnectionSocketFactory scsf = null;
        try {
            if (crtMap.containsKey(caPath)) {
                return crtMap.get(caPath);
            }
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            org.springframework.core.io.Resource resource = new ClassPathResource(caPath);
            InputStream fontInputStream = resource.getInputStream();
            keyStore.load(fontInputStream, caPassword.toCharArray());
            SSLContext sslContext = SSLContexts.custom()
                    //忽略掉对服务器端证书的校验
                    .loadTrustMaterial(new TrustStrategy() {
                        @Override
                        public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                            return true;
                        }
                    })
                    .loadKeyMaterial(keyStore, caPassword.toCharArray())
                    .build();
            scsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
            if (scsf != null && !crtMap.containsKey(caPath)) {
                crtMap.put(caPath, scsf);
            }
        } catch (Exception ex) {
            System.out.println(String.format("%s  初始化证书异常：caPath=%s，caPassword=%s，异常信息：%s",
                    DateTimeUtil.getDateTimeString2(), caPath, caPassword, ex.getMessage()));
        }
        return scsf;
    }


    public static String doPost(String url, String params) {
        try {
            HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
            conn.setRequestMethod("POST");
            conn.addRequestProperty("Content-Type", "application/json;charset=utf-8");
            conn.setDoOutput(true);
            conn.setDoInput(true);
            // 超时时间30秒
            int timeout = 30 * 1000;
            conn.setConnectTimeout(timeout);
            conn.setReadTimeout(timeout);

            conn.connect();
            if (params != null) {
                OutputStreamWriter out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
                out.write(params);
                out.flush();
                out.close();
            }
            InputStreamReader r = new InputStreamReader(conn.getInputStream(), "UTF-8");
            BufferedReader reader = new BufferedReader(r);
            String line;
            StringBuffer sb = new StringBuffer();
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            return sb.toString();
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("调用远端服务出错", e);
        }
    }

}

public static String request(String url, String method, String paramType, HashMap<String, String> bodyParams, HashMap<String, String> headerParams) {
        OkHttpClient client = new OkHttpClient();
        MediaType mediaType = MediaType.parse("application/json");
        switch (paramType) {
            case "json":
                mediaType = MediaType.parse("application/json");
                break;
            case "form":
                mediaType = MediaType.parse("application/x-www-form-urlencoded");
                break;
            default:
                break;
        }
        String s1 = JSONObject.toJSONString(bodyParams);
        RequestBody body = RequestBody.create(mediaType, s1);
        Request.Builder requestBuilder = new Request.Builder()
                .url(url)
                .method(method, body);
        if (headerParams.size() > 0) {
            for (String s : headerParams.keySet()) {
                requestBuilder.addHeader(s, headerParams.get(s));
            }
        }
        Request request = requestBuilder.build();
        Response response = null;
        String string = "";
        try {
            response = client.newCall(request).execute();
            string = response.body().string();
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException(url + "请求返回异常!" + response.code());
        }
        if (response.code() != 200) {
            throw new RuntimeException(url + "请求返回异常!" + response.code());
        }
        return string;
    }

    public static String setRequestbyHttps( JSONObject bodyParams, String url, JSONObject header) {
        //采用绕过验证的方式处理https请求
        SSLContext sslcontext = createIgnoreVerifySSL();
        // 设置协议http和https对应的处理socket链接工厂的对象
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                .register("https", new SSLConnectionSocketFactory(sslcontext, NoopHostnameVerifier.INSTANCE))
                .build();
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        HttpClients.custom().setConnectionManager(connManager);
        //创建自定义的httpclient对象
        CloseableHttpClient client = HttpClients.custom().setConnectionManager(connManager).build();
        //创建post方式请求对象
        HttpPost post = new HttpPost(url);

//        JSONObject jsonObject = JSONObject.parseObject(attach);
        List<NameValuePair> list = new ArrayList<>();
        Iterator<Map.Entry<String, Object>> iterator = bodyParams.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = (Map.Entry) iterator.next();
            String s = entry.getKey().toString();
            String s1 = entry.getValue().toString();
            list.add(new BasicNameValuePair(s, s1));
        }
        // POST请求方式
        HttpEntity entity = new UrlEncodedFormEntity(list, Charsets.UTF_8);
        if (header != null && header.size() > 0) {
            Set<Map.Entry<String, Object>> entrySet = header.entrySet();
            for (Map.Entry<String, Object> entry : entrySet) {
                post.setHeader(entry.getKey(), entry.getValue().toString());
            }
        }
        post.setHeader("Content-Type", "application/x-www-form-urlencoded");
        post.setEntity(entity);
        try {
            CloseableHttpResponse response = client.execute(post);
            return EntityUtils.toString(response.getEntity());
        } catch (Exception e) {
            throw new RuntimeException(e.toString());
        } finally {
            post.releaseConnection();
        }
    }

    public static SSLContext createIgnoreVerifySSL() {
        SSLContext sslContext = null;
        try {
            sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {//信任所有
                    return true;
                }
            }).build();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        }

        return sslContext;
    }

/**
     * @param url         访问Url
     * @param param       访问参数
     * @param contentType json,form
     * @return
     */
    public static String returnJson(String url, String param, String contentType) {
        StringBuilder sb = new StringBuilder();
        HttpURLConnection httpConnection = null;
        try {
            URL restServiceURL = new URL(url);
            httpConnection = (HttpURLConnection) restServiceURL.openConnection();

            if (param == null) {
                httpConnection.connect();
            } else {
                // 打开输出开关
                httpConnection.setRequestMethod("POST");
                httpConnection.setConnectTimeout(60 * 1000);
                httpConnection.setReadTimeout(60 * 1000);
                if ("json".equals(contentType)) {
                    httpConnection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                } else if ("form".equals(contentType)) {
                    httpConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
                }
                httpConnection.setRequestProperty("Accept", "application/json, text/plain, */*");
                httpConnection.setDoOutput(true);
                httpConnection.setDoInput(true);
                httpConnection.connect();

                // 传递参数，获取HttpURLConnection对象的输出流
                OutputStream outputStream = httpConnection.getOutputStream();

                //请求参数发送
                outputStream.write(param.getBytes("UTF-8"));
                // flush输出流的缓冲
                outputStream.flush();
            }

            if (httpConnection.getResponseCode() != 200) {
                throw new RuntimeException("HTTP GET Request Failed with Error code : " + httpConnection.getResponseCode());
            }

            //定义BufferedReader输入流来读取URL的响应
            BufferedReader responseBuffer = new BufferedReader(new InputStreamReader(httpConnection.getInputStream(), "utf-8"));
            String output;
            while ((output = responseBuffer.readLine()) != null) {
                sb.append(output);
            }
            httpConnection.disconnect();
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println(String.format("%s  Rest服务调用异常：Url=%s，param=%s，异常信息：%s",
                    DateTimeUtil.getDateTimeString2(), url, param, ex.getMessage()));
            throw new RuntimeException(ex.getMessage());
        } finally {
            if (httpConnection != null) {
                httpConnection.disconnect();
            }
        }
        return sb.toString();
    }


    /**
     * 获取SSLConnectionSocketFactory
     *
     * @param caPath
     * @param caPassword
     * @return
     */
    private static Map<String, SSLConnectionSocketFactory> crtMap = new HashMap<String, SSLConnectionSocketFactory>();

    private static SSLConnectionSocketFactory getSSLConnectionSocketFactory(String caPath, String caPassword) {
        SSLConnectionSocketFactory scsf = null;
        try {
            if (crtMap.containsKey(caPath)) {
                return crtMap.get(caPath);
            }
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            org.springframework.core.io.Resource resource = new ClassPathResource(caPath);
            InputStream fontInputStream = resource.getInputStream();
            keyStore.load(fontInputStream, caPassword.toCharArray());
            SSLContext sslContext = SSLContexts.custom()
                    //忽略掉对服务器端证书的校验
                    .loadTrustMaterial(new TrustStrategy() {
                        @Override
                        public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                            return true;
                        }
                    })
                    .loadKeyMaterial(keyStore, caPassword.toCharArray())
                    .build();
            scsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
            if (scsf != null && !crtMap.containsKey(caPath)) {
                crtMap.put(caPath, scsf);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println(String.format("%s  初始化证书异常：caPath=%s，caPassword=%s，异常信息：%s",
                    DateTimeUtil.getDateTimeString2(), caPath, caPassword, ex.getMessage()));
        }
        return scsf;
    }

    /**
     * @param isHttps     是否Https
     * @param url         访问Url
     * @param param       访问参数
     * @param contentType json,form
     * @return
     */
    public static String returnJson(String url, String param, String contentType, boolean isHttps, String caPath, String caPassword) {
        StringBuilder sb = new StringBuilder();
        CloseableHttpClient httpClient = null;
        try {
            HttpClientBuilder httpClientBuilder = HttpClients.custom();
            //添加SSL证书
            if (isHttps) {
                SSLConnectionSocketFactory scsf = getSSLConnectionSocketFactory(caPath, caPassword);
                httpClientBuilder = httpClientBuilder.setSSLSocketFactory(scsf);
            }
            httpClient = httpClientBuilder.build();
            StringEntity entity = new StringEntity(param, ContentType.APPLICATION_FORM_URLENCODED);
            HttpPost httpPost = new HttpPost(url);
            httpPost.setEntity(entity);
            HttpResponse response = httpClient.execute(httpPost);

            BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent(), "UTF-8"), 65728);
            String line = null;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println(String.format("%s  Rest服务调用异常：Url=%s，param=%s，异常信息：%s",
                    DateTimeUtil.getDateTimeString2(), url, param, ex.getMessage()));
        } finally {
            if (httpClient != null) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }

   public static String postJsonRequestByCrt(String url, String param, String contentType, boolean isHttps, String caPath, String caPassword){
       StringBuilder sb = new StringBuilder();
       CloseableHttpClient httpClient = null;
       try {
           HttpClientBuilder httpClientBuilder = HttpClients.custom();
           //添加SSL证书
           if (isHttps) {
               SSLConnectionSocketFactory scsf = getSSLConnectionSocketFactory(caPath, caPassword);
               httpClientBuilder = httpClientBuilder.setSSLSocketFactory(scsf);
           }
           httpClient = httpClientBuilder.build();
           StringEntity entity = new StringEntity(param, ContentType.APPLICATION_JSON);
           HttpPost httpPost = new HttpPost(url);
           httpPost.setEntity(entity);
           HttpResponse response = httpClient.execute(httpPost);

           BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent(), "UTF-8"), 65728);
           String line = null;
           while ((line = reader.readLine()) != null) {
               sb.append(line);
           }
       } catch (Exception ex) {
           ex.printStackTrace();
           System.out.println(String.format("%s  Rest服务调用异常：Url=%s，param=%s，异常信息：%s",
           DateTimeUtil.getDateTimeString2(), url, param, ex.getMessage()));
       } finally {
           if (httpClient != null) {
               try {
                   httpClient.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
       return sb.toString();
   }

    /**
     * 调用网关格式请求
     *
     * @param url
     * @param interfaceName
     * @param methodName
     * @param param
     * @return
     */
    public static String PostForGateWay(String url, String interfaceName, String methodName, Object... param) {
        StringBuilder sb = new StringBuilder();
        OkHttpClient client = new OkHttpClient().newBuilder()
                .build();
        MediaType mediaType = MediaType.parse("text/plain");
        MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM)
                .addFormDataPart("interfaceName", interfaceName)
                .addFormDataPart("methodName", methodName);
        if (param.length > 0) {
            for (int i = 0; i < param.length; i++) {
                Object arg = param[i];
                builder.addFormDataPart("args[]", arg.toString());
            }
        }
        RequestBody body = builder.build();
        Request request = new Request.Builder()
                .url(url)
                .method("POST", body)
                .build();
        Response response;
        try {
            response = client.newCall(request).execute();
            BufferedReader responseBuffer = new BufferedReader(new InputStreamReader(response.body().byteStream(), "utf-8"));
            String output;
            while ((output = responseBuffer.readLine()) != null) {
                sb.append(output);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    /**
     * 发送http get请求
     *
     * @param
     * @return
     */
    public static String sendGet(String url) {
        String result = "";
        FileOutputStream fs = null;
        FileInputStream fi = null;
        InputStream inStream = null;
        try {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection connection = realUrl.openConnection();
            // 设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 建立实际的连接
            connection.connect();
            // 获取所有响应头字段
            Map<String, List<String>> map = connection.getHeaderFields();
            // 遍历所有的响应头字段
            for (String key : map.keySet()) {
                System.out.println(key + "--->" + map.get(key));
            }
            inStream = connection.getInputStream();
            //1.
//            fs = new FileOutputStream("C:\\Users\\xk\\Desktop\\test.7z");
//            byte[] buffer = new byte[1204];
//            while ((byteread = inStream.read(buffer)) != -1) {
//                bytesum += byteread;
//                System.out.println(bytesum);
//                fs.write(buffer, 0, byteread);
//            }
            //2.
            File file = new File("C:\\Users\\xk\\Desktop\\test.7z");
            fi = new FileInputStream(file);
            byte[] bytes = new byte[fi.available()];
            fi.read(bytes);
            result = new BASE64Encoder().encode(bytes).replaceAll("\r", "").replaceAll("\n", "");
            //3.
//            byte[] bytes = new byte[inStream.available()];
//            inStream.read(bytes);
//            result = new BASE64Encoder().encode(bytes).replaceAll("\r", "").replaceAll("\n", "");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        // 使用finally块来关闭输入流
        finally {
            try {
                if (fs != null) {
                    fs.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
            try {
                if (inStream != null) {
                    inStream.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return result;
    }