封裝一個HttpUtil和將List切分爲指定大小n個

引入依賴：

 <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.2</version>
        </dependency>

工具類：

package com.t3.ts.driver.resume.utils;

import com.t3.ts.utils.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
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.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.ByteArrayBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLEncoder;
import java.security.cert.X509Certificate;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @class_name: HttpUtil
 * @description: http請求封裝
 * @author: wm_yu
 * @create: 2019/08/05
 **/
@Component
public class HttpUtil implements InitializingBean, ApplicationListener<ContextClosedEvent> {
        private static final Logger logger = LoggerFactory.getLogger(HttpUtil.class);

        private CloseableHttpClient httpclient;
        //最大連接數
        private final static int maxTotal = 500;
        //路由最大連接數
        private final static int maxPerRoute = 200;

        private final String json = "application/json;charset=UTF-8";
        private final String form = "application/x-www-form-urlencoded";

        /**
         * 獲取連接
         *
         * @return
         */
        private CloseableHttpClient getClient () {
        try {
            //https config
            TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;
            SSLContext sslContext = org.apache.http.ssl.SSLContexts.custom()
                    .loadTrustMaterial(null, acceptingTrustStrategy)
                    .build();
            SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, null, null, NoopHostnameVerifier.INSTANCE);
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", csf)
                    .build();

            PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(registry);
            //最大連接數500
            connectionManager.setMaxTotal(maxTotal);
            //路由鏈接數100
            connectionManager.setDefaultMaxPerRoute(maxPerRoute);
            RequestConfig requestConfig = RequestConfig.custom()
                    .setSocketTimeout(60000)
                    .setConnectTimeout(60000)
                    .setConnectionRequestTimeout(10000)
                    .build();

            CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(requestConfig)
                    .setConnectionManager(connectionManager)
                    .evictExpiredConnections()
                    .evictIdleConnections(30, TimeUnit.SECONDS)
                    .build();
            return httpClient;
        } catch (Exception e) {
            logger.error("獲取HttpClient 失敗", e);
            throw new RuntimeException("獲取HttpClient 失敗");
        }
    }


        /**
         * GET請求，返回字符串
         *
         * @param url
         * @param headers
         * @param param
         * @return
         */
        public String get (String url, Map < String, String > headers, Map < String, String > param){
        CloseableHttpResponse response = execGet(url, headers, param);
        if (response == null) {
            return null;
        }
        if (response.getStatusLine().getStatusCode() != 200) {
            logger.error("Http 請求失敗，Url:{},失敗碼：{}", url, response.getStatusLine().getStatusCode());
            return null;
        }
        try {
            return EntityUtils.toString(response.getEntity());
        } catch (IOException e) {
            logger.error("Http 請求失敗，Url:{},失敗原因：{}", url, e.getMessage());
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                }
            }
        }
        return null;
    }

        /**
         * 返回字節數組，下載使用
         *
         * @param url
         * @param headers
         * @param param
         * @return
         */
        public byte[] getByteArray (String url, Map < String, String > headers, Map < String, String > param){
        CloseableHttpResponse response = execGet(url, headers, param);
        if (response == null) {
            return null;
        }
        if (response.getStatusLine().getStatusCode() != 200) {
            logger.error("Http 請求失敗，Url:{},失敗碼：{}", url, response.getStatusLine().getStatusCode());
            return null;
        }
        try {
            return EntityUtils.toByteArray(response.getEntity());
        } catch (IOException e) {
            logger.error("Http 請求失敗，Url:{},失敗原因：{}", url, e.getMessage());
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                }
            }
        }

        return null;
    }

        private CloseableHttpResponse execGet (String url, Map < String, String > headers, Map < String, String > param)
        {
            HttpGet httpGet = new HttpGet();
            CloseableHttpResponse response = null;
            try {
                //設置請求頭
                if (!CollectionUtils.isEmpty(headers)) {
                    headers.forEach((k, v) -> {
                        httpGet.addHeader(k, v);
                    });
                }
                //設置請求參數
                StringBuilder paramStr = new StringBuilder("");
                if (!CollectionUtils.isEmpty(param)) {
                    param.forEach((k, v) -> {
                        try {
                            paramStr.append(k).append("=").append(URLEncoder.encode(v, "UTF-8")).append("&");
                        } catch (UnsupportedEncodingException e) {
                            logger.error("URLEncoder 失敗，參數：{},原因：{}", v, e.getMessage());
                        }
                    });
                }
                if (url.indexOf("?") > 0) {
                    url = url + "&" + paramStr;
                } else {
                    if (StringUtils.isNotEmpty(paramStr.toString())) {
                        url = url + "?" + paramStr;
                    }
                }
                httpGet.setURI(URI.create(url));
                response = httpclient.execute(httpGet);
                return response;
            } catch (Exception e) {
                logger.error("Http 請求失敗，Url:{},失敗原因：{}", url, e.getMessage());
            }
            return null;
        }

        /**
         * POST 請求僅支持application/json
         *
         * @return
         */
        public String post (String url, Map < String, String > headers, String jsonData, String contextType){
        HttpPost httpPost = new HttpPost();
        CloseableHttpResponse response = null;
        try {
            //設置請求頭
            if (!CollectionUtils.isEmpty(headers)) {
                headers.forEach((k, v) -> {
                    httpPost.addHeader(k, v);
                });
            }
            httpPost.addHeader("Content-Type", json);
            httpPost.setURI(URI.create(url));
            StringEntity se = new StringEntity(jsonData);
            se.setContentEncoding("UTF-8");
            se.setContentType(json);
            httpPost.setEntity(se);
            response = httpclient.execute(httpPost);
            if (response.getStatusLine().getStatusCode() != 200) {
                logger.error("Http 請求失敗，Url:{},失敗碼：{}", url, response.getStatusLine().getStatusCode());
                return null;
            }
            return EntityUtils.toString(response.getEntity());
        } catch (Exception e) {
            logger.error("Http 請求失敗，Url:{},失敗原因：{}", url, e.getMessage());
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                }
            }
        }
        return null;
    }

        public String postFile (String url, Map < String, String > headers,byte[] file, String fileNmae){
            HttpPost httpPost = new HttpPost();
            CloseableHttpResponse response = null;
            try {
                //設置請求頭
                if (!CollectionUtils.isEmpty(headers)) {
                    headers.forEach((k, v) -> {
                        httpPost.setHeader(k, v);
                    });
                }
                httpPost.setURI(URI.create(url));
                MultipartEntityBuilder builder = MultipartEntityBuilder.create();
                builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
                builder.addPart("file", new ByteArrayBody(file, fileNmae));
                HttpEntity httpEntity = builder.build();
                httpPost.setEntity(httpEntity);
                response = httpclient.execute(httpPost);
                if (response.getStatusLine().getStatusCode() == 200) {
                    return EntityUtils.toString(response.getEntity());
                }
                logger.error("Http 請求失敗，Url:{},失敗碼：{}", url, response.getStatusLine().getStatusCode());
            } catch (IOException e) {
                logger.error("Http 請求失敗，Url:{},失敗原因：{}", url, e.getMessage());
            } finally {
                if (response != null) {
                    try {
                        response.close();
                    } catch (IOException e) {
                    }
                }
            }
            return null;
        }


        /**
         * 關閉連接
         */
        private void close () {
        if (httpclient != null) {
            try {
                httpclient.close();
            } catch (IOException e) {
                logger.error("關閉Http連接失敗", e);
            }
        }
    }

        @Override
        public void afterPropertiesSet () throws Exception {
        System.out.println("-----------------HttpUtil.afterPropertiesSet---------------------------------");
        if (this.httpclient == null) {
            this.httpclient = getClient();
        }
    }

        @Override
        public void onApplicationEvent (ContextClosedEvent contextClosedEvent){
        System.out.println("-----------------HttpUtil.destroy---------------------------------");
        close();
    }
    }

 

切分工具類：

 /**
     * 按指定大小,分隔集合，將集合按規定個數分爲n個部分
     *
     * @param list
     * @param len
     * @return
     */
    public static <T> List<List<T>> splitList(List<T> list, int len) {
        if (list == null || list.size() == 0 || len < 1) {
            return null;
        }
        //返回結果
        List<List<T>> result = new ArrayList<>();
        //傳入集合長度
        int size = list.size();
        //分隔後的集合個數
        int count = (size + len - 1) / len;
        for (int i = 0; i < count; i++) {
            List<T> subList = list.subList(i * len, ((i + 1) * len > size ? size : len * (i + 1)));
            result.add(subList);
        }
        return result;
    }