构建方便安全的HttpClient工具类

前言

在Java开发中经常遇见需要调用第三方接口的情况，这种情况下往往需要一个接口调用工具,常用的有hutool restTemplate httpClient。但是不管哪一种,在使用便捷性方面都不太方便。不如自己再去封装。
常见的二进制提交,formdata提交等需要做不少的代码转换。

开始

引入核心依赖

    <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpmime</artifactId>
      <version>4.5.3</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.73</version>
    </dependency>

其它依赖

    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>28.1-jre</version>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.10</version>
      <scope>provided</scope>
    </dependency>
    <!-- log start -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.25</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.25</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-nop</artifactId>
      <version>1.7.25</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-simple</artifactId>
      <version>1.7.5</version>
    </dependency>
    <!-- log end -->

封装工具类

1.UrlEntity

    import java.util.HashMap;
    import java.util.Map;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * url对象
     *
     * @author LiTing
     * @date 2021/2/26 11:18
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class UrlEntity {
      /** 基础url */
      public String baseUrl;
      /** url参数 */
      public Map<String, Object> params = new HashMap<>();
    
      public String toUrl() {
        int i = 0;
        StringBuilder text = new StringBuilder(baseUrl);
        for (Map.Entry<String, Object> entry : params.entrySet()) {
          if (i == 0) {
            text = text.append("?" + entry.getKey() + "=" + entry.getValue());
          } else {
            text = text.append("&" + entry.getKey() + "=" + entry.getValue());
          }
          i++;
        }
        return text.toString();
      }
    
      public UrlEntity addParam(Map<String, Object> map) {
        if (map != null) {
          params.putAll(map);
        }
        return this;
      }
    }

2.HttpClientException

    import lombok.Data;

    /**
     * 第三方服务调用异常
     *
     * @author LiTing
     * @date 2021/6/8 10:43
     */
    @Data
    public class HttpClientException extends Exception {
    
      public HttpClientException(String message) {
        super(message);
      }
    }   

3.IoUtil

    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    /**
     * 统一的io处理工具类
     *
     * @author liting
     */
    public class IoUtil {
      /** 默认的字节读取大小 */
      private static final int SIZE = 4 * 1024;
    
      public static File inputStream2File(
          InputStream inputStream, String targetFile, boolean closeStream) throws   IOException {
        File file = new File(targetFile);
        OutputStream outStream = null;
        try {
          outStream = new FileOutputStream(file);
          File parentFile = file.getParentFile();
          if (!parentFile.exists()) {
            parentFile.mkdirs();
          }
          byte[] buffer = new byte[SIZE];
          int bytesRead;
          while ((bytesRead = inputStream.read(buffer)) != -1) {
            outStream.write(buffer, 0, bytesRead);
          }
          outStream.flush();
        } finally {
          if (outStream != null) {
            outStream.close();
          }
          if (closeStream && inputStream != null) {
            inputStream.close();
          }
        }
        return file;
      }
    
      /** 目的是检查目录存不存在，不存在则创建. */
      public static void checkPath(String path) {
        File file = new File(path);
        if (file != null && file.isDirectory() && !file.exists()) {
          file.mkdirs();
        }
        if (file == null || !file.exists()) {
          file.mkdirs();
        }
      }
      
    
      /** byte数组转文件 */
      public static byte[] file2Byte(File file) throws IOException {
        byte[] buffer;
        FileInputStream fis = null;
        ByteArrayOutputStream bos = null;
        try {
          checkPath(file.getParent());
          fis = new FileInputStream(file);
          bos = new ByteArrayOutputStream();
          byte[] b = new byte[SIZE];
          int n;
          while ((n = fis.read(b)) != -1) {
            bos.write(b, 0, n);
          }
        } finally {
          if (fis != null) {
            fis.close();
          }
          if (bos != null) {
            bos.close();
          }
        }
        buffer = bos.toByteArray();
        return buffer;
      }
    }

4.UrlUtil

    import java.util.HashMap;
    import org.hhdbb.hhpclient.entity.UrlEntity;
    
    /**
     * url解析工具
     *
     * @author LiTing
     * @date 2021/2/26 11:12
     */
    public class UrlUtil {
    
      /**
       * 解析url
       *
       * @param url
       * @return
       */
      public static UrlEntity parse(String url) {
        UrlEntity entity = new UrlEntity();
        if (url == null) {
          return entity;
        }
        url = url.trim();
        if ("".equals(url)) {
          return entity;
        }
        String[] urlParts = url.split("\\?");
        entity.baseUrl = urlParts[0];
        // 没有参数
        if (urlParts.length == 1) {
          return entity;
        }
        // 有参数
        String[] params = urlParts[1].split("&");
        entity.params = new HashMap<>(8);
        for (String param : params) {
          String[] keyValue = param.split("=");
          entity.params.put(keyValue[0], keyValue[1]);
        }
    
        return entity;
      }
    }

5.SingletonUtil

    import com.google.common.util.concurrent.ThreadFactoryBuilder;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadFactory;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    import org.apache.http.client.config.CookieSpecs;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.impl.client.HttpClientBuilder;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    
    /**
     * 单例工具类
     *
     * @author LiTing
     * @date 2021/3/26 18:22
     */
    public class SingletonUtil {
      private static volatile PoolingHttpClientConnectionManager   poolingHttpClientConnectionManager;
      private static volatile HttpClientBuilder httpClientBuilder;
      private static RequestConfig globalConfig =
          RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD).build();
      private static Lock lock1 = new ReentrantLock();
      private static Lock lock2 = new ReentrantLock();
      public static ThreadFactory namedThreadFactory =
          new ThreadFactoryBuilder().setNameFormat("thread-call-runner-%d").build();
      public static ExecutorService executorService =
          new ThreadPoolExecutor(
              5, 100, 200L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(),   namedThreadFactory);
      /** 保证全局只使用提个连接池管理对象 */
      public static PoolingHttpClientConnectionManager
          getSingletonPoolingHttpClientConnectionManager() {
        if (poolingHttpClientConnectionManager == null) {
          lock1.lock();
          try {
            PoolingHttpClientConnectionManager cm = new     PoolingHttpClientConnectionManager();
            cm.setDefaultMaxPerRoute(800);
            cm.setMaxTotal(1000);
            poolingHttpClientConnectionManager = cm;
          } finally {
            lock1.unlock();
          }
        }
        return poolingHttpClientConnectionManager;
      }
    
      /** 保证全局只通过一个builder去创建client */
      public static HttpClientBuilder getSingletonHttpClientBuilder() {
        if (httpClientBuilder == null) {
          lock2.lock();
          try {
            httpClientBuilder =
                HttpClients.custom()
                    .setConnectionManager(
                        SingletonUtil.getSingletonPoolingHttpClientConnectionManager    ())
                    .setDefaultRequestConfig(globalConfig);
          } finally {
            lock2.unlock();
          }
        }
        return httpClientBuilder;
      }
    }   

开始构建

6.HttpClientUtil

    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.UnsupportedEncodingException;
    import java.nio.charset.StandardCharsets;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.List;
    import java.util.Map;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpHost;
    import org.apache.http.NameValuePair;
    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.entity.ByteArrayEntity;
    import org.apache.http.entity.ContentType;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.entity.mime.HttpMultipartMode;
    import org.apache.http.entity.mime.MultipartEntityBuilder;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    import org.hhdbb.hhpclient.entity.UrlEntity;
    import org.hhdbb.hhpclient.exception.HttpClientException;
    
    /**
     * http请求工具类
     *
     * @author LiTing
     * @date 2021/3/26 16:39
     */
    @Slf4j
    public class HttpClientUtil {
    
      private static final String DEFAULT_CHARSET = "UTF-8";
    
      private static class HttpClientUtilHolder {
        private static HttpClientUtil httpClientUtil = new HttpClientUtil();
      }
    
      public static final HttpClientUtil getSingleInstance() {
        return HttpClientUtilHolder.httpClientUtil;
      }
    
      public static void httpResponseToFile(CloseableHttpResponse httpResponse,   String path)
          throws IOException {
        HttpEntity httpEntity = httpResponse.getEntity();
        InputStream inStream = httpEntity.getContent();
        IoUtil.inputStream2File(inStream, path, true);
      }
    
      /**
       * 发送Get请求
       *
       * @param url
       * @param header
       * @param tClass
       * @return T
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:06
       */
      public static <T> T doGet(String url, Map<String, String> header, Class<T>   tClass)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpGet get = new HttpGet(url);
        setHeader(get, header);
        return getResult(httpClient, get, tClass);
      }
    
      /**
       * 发送Get请求
       *
       * @param url
       * @param header
       * @param tClass
       * @return T
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:06
       */
      public static <T> T doGetWithProxy(
          String url, Map<String, String> header, Class<T> tClass, String ip, int   port)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpGet get = new HttpGet(url);
        RequestConfig c = get.getConfig();
        if (c == null) {
          c = RequestConfig.DEFAULT;
        }
        RequestConfig requestConfig = RequestConfig.copy(c).setProxy(new     HttpHost(ip, port)).build();
        get.setConfig(requestConfig);
        setHeader(get, header);
        return getResult(httpClient, get, tClass);
      }
    
      /**
       * 发送get请求 带参
       *
       * @param url
       * @param params
       * @param header
       * @param tClass
       * @return T
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:06
       */
      public static <T> T doGet(
          String url, Map<String, Object> params, Map<String, String> header,   Class<T> tClass)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpGet get = new HttpGet(dealUrl(url, params));
        setHeader(get, header);
        return getResult(httpClient, get, tClass);
      }
    
      /**
       * 下载文件
       *
       * @param url
       * @param header
       * @param filePath
       * @return void
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:06
       */
      public static void doGetFile(String url, Map<String, String> header, String   filePath)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpGet get = new HttpGet(url);
        setHeader(get, header);
        try (CloseableHttpResponse res = doExecute(httpClient, get)) {
          httpResponseToFile(res, filePath);
        } catch (IOException e) {
          e.printStackTrace();
          // 换成自己的统一异常处理方法，省得到处抛HttpClientException
          throw new HttpClientException("HTTP工具类IO异常");
        }
      }
    
      /**
       * 获取文件输入流
       *
       * @param url
       * @param header
       * @return java.io.InputStream
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:05
       */
      public static InputStream doGetFileInputStream(String url, Map<String, String>   header)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpGet get = new HttpGet(url);
        setHeader(get, header);
        try (CloseableHttpResponse res = doExecute(httpClient, get)) {
          return res.getEntity().getContent();
        } catch (IOException e) {
          e.printStackTrace();
          // aa//换成自己的统一异常处理方法，省得到处抛HttpClientException
          throw new HttpClientException("HTTP工具类IO异常");
        }
      }
    
      /**
       * 发送 application/x-www-form-urlencoded请求
       *
       * @param url
       * @param param
       * @param header
       * @param tClass
       * @return T
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:05
       */
      public static <T> T doPost(
          String url, Map<String, Object> param, Map<String, String> header,   Class<T> tClass)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpPost httpPost = new HttpPost(url);
        setHeader(httpPost, header);
        try {
          setUrlFormEntity(httpPost, param);
          return getResult(httpClient, httpPost, tClass);
        } catch (IOException e) {
          e.printStackTrace();
          // 换成自己的统一异常处理方法，省得到处抛HttpClientException
          throw new HttpClientException("HTTP工具类IO异常");
        }
      }
    
      /**
       * 发送application/json请求
       *
       * @param url
       * @param json
       * @param header
       * @param t
       * @return T
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:04
       */
      public static <T> T doPostJson(String url, String json, Map<String, String>   header, Class<T> t)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpPost httpPost = new HttpPost(url);
        setHeader(httpPost, header);
        setJsonEntity(httpPost, json);
        return getResult(httpClient, httpPost, t);
      }
    
      /**
       * form表单文件上传
       *
       * @param url
       * @param params
       * @param headers
       * @param t
       * @return T
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:23
       */
      public static <T> T doPostFormData(
          String url, Map<String, Object> params, Map<String, String> headers,   Class<T> t)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpPost httpPost = new HttpPost(url);
        setHeader(httpPost, headers);
        setFormDataEntity(httpPost, params);
        return getResult(httpClient, httpPost, t);
      }
    
      /**
       * 仅上传文件
       *
       * @param url
       * @param file
       * @param headers
       * @param tClass
       * @return T
       * @throws
       * @version V1.0.0
       * @date 2021/3/26 17:30
       */
      public static <T> T doPostFile(
          String url, File file, Map<String, String> headers, Class<T> tClass)
          throws HttpClientException {
        CloseableHttpClient httpClient = getHttpClient();
        HttpPost httpPost = new HttpPost(url);
        setHeader(httpPost, headers);
        ByteArrayEntity byteArrayEntity = null;
        try {
          if (file != null) {
            byteArrayEntity = new ByteArrayEntity(IoUtil.file2Byte(file));
          }
          httpPost.setEntity(byteArrayEntity);
          return getResult(httpClient, httpPost, tClass);
        } catch (IOException e) {
          e.printStackTrace();
          // 换成自己的统一异常处理方法，省得到处抛HttpClientException
          throw new HttpClientException("HTTP工具类IO异常");
        }
      }
    
      public static CloseableHttpClient getHttpClient() {
        return SingletonUtil.getSingletonHttpClientBuilder().build();
      }
    
      public static void setHeader(HttpRequestBase hb, Map<String, String> headers)   {
        if (headers != null) {
          for (String key : headers.keySet()) {
            hb.setHeader(key, headers.get(key));
          }
        }
      }
    
      private static CloseableHttpResponse doExecute(CloseableHttpClient hc,   HttpRequestBase hb)
          throws IOException {
        CloseableHttpResponse ch = hc.execute(hb);
        return ch;
      }
    
      private static String dealUrl(String url, Map<String, Object> params) {
        UrlEntity urlEntity = UrlUtil.parse(url);
        urlEntity.addParam(params);
        return urlEntity.toUrl();
      }
    
      public static void setUrlFormEntity(HttpPost httpPost, Map<String, Object>   param)
          throws UnsupportedEncodingException {
        if (param != null) {
          List<NameValuePair> paramList = new ArrayList<>();
          for (String key : param.keySet()) {
            paramList.add(new BasicNameValuePair(key,     String.valueOf(param.get(key))));
          }
          UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
          httpPost.setEntity(entity);
        }
      }
    
      public static void setJsonEntity(HttpPost httpPost, String json) {
        StringEntity entity = new StringEntity(json, StandardCharsets.UTF_8);
        entity.setContentType("application/json;charset=utf-8");
        httpPost.setEntity(entity);
      }
    
      public static void setFormDataEntity(HttpPost httpPost, Map<String, Object>   params) {
        MultipartEntityBuilder mEntityBuilder = MultipartEntityBuilder.create();
        mEntityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
        mEntityBuilder.setCharset(StandardCharsets.UTF_8);
        ContentType textContent = ContentType.create("text/plain",     StandardCharsets.UTF_8);
        params.forEach(
            (k, v) -> {
              if (v instanceof File) {
                File file = (File) v;
                mEntityBuilder.addBinaryBody(k, file);
              } else if (v instanceof Collection) {
                Collection cl = (Collection) v;
                cl.stream()
                    .forEach(
                        c -> {
                          File f = (File) c;
                          mEntityBuilder.addBinaryBody(k, f);
                        });
              } else {
                mEntityBuilder.addTextBody(k, v.toString(), textContent);
              }
            });
        httpPost.setEntity(mEntityBuilder.build());
      }
    
      public static <T> boolean checkStringResult(Class<T> t) {
        if (String.class.isAssignableFrom(t)) {
          return true;
        }
        return false;
      }
    
      public static <T> boolean checkJsonObjectResult(Class<T> t) {
        return JSONObject.class.isAssignableFrom(t);
      }
    
      public static <T> boolean checkJsonArrayResult(Class<T> t) {
        return JSONArray.class.isAssignableFrom(t);
      }
    
      public static <T> T getResult(CloseableHttpClient hc, HttpRequestBase hb,   Class<T> t)
          throws HttpClientException {
        String s;
        try (CloseableHttpResponse res = doExecute(hc, hb)) {
          s = EntityUtils.toString(res.getEntity(), DEFAULT_CHARSET);
          log.info("URI:{}", hb.getURI().toString());
          log.info("RESULT:{}", s);
          if (checkStringResult(t)) {
            return (T) s;
          } else if (checkJsonObjectResult(t)) {
            return (T) JSONObject.parse(s);
          } else if (checkJsonArrayResult(t)) {
            return (T) JSONArray.parse(s);
          }
        } catch (IOException e) {
          e.printStackTrace();
          // 换成自己的统一异常处理方法，省得到处抛HttpClientException
          throw new HttpClientException("HTTP工具类IO异常");
        }
        return JSON.parseObject(s, t);
      }
    }