httpClient 4.5.2 实现连接池

来源：互联网发布：软件著作权的申请编辑：程序博客网时间：2024/05/17 23:10

如下代码

[java] view plain copy
public class PoolHttpsClientService {  
  
  
    // 日志  
    private static final SimpleLogger LOGGER = SimpleLogger.getLogger(PoolHttpsClientService.class);  
  
  
    private static final String CHAR_SET = "UTF-8";  
  
  
    // 代理IP  
    @Value("${InetAddressStr}")  
    private String InetAddressStr;  
  
  
    // 代理端口  
    @Value("${InetPort}")  
    private int InetPort;  
  
  
    /** 
     * 最大连接数400 
     */  
    private static int MAX_CONNECTION_NUM = 400;  
  
  
    /** 
     * 单路由最大连接数80 
     */  
    private static int MAX_PER_ROUTE = 80;  
  
  
    /** 
     * 向服务端请求超时时间设置(单位:毫秒) 
     */  
    private static int SERVER_REQUEST_TIME_OUT = 2000;  
  
  
    /** 
     * 服务端响应超时时间设置(单位:毫秒) 
     */  
    private static int SERVER_RESPONSE_TIME_OUT = 2000;  
  
  
    /** 
     * 构造函数 
     */  
    private PoolHttpsClientService() {  
    }  
  
  
    private static Object LOCAL_LOCK = new Object();  
      
    /** 
     * 连接池管理对象 
     */  
    PoolingHttpClientConnectionManager cm = null;  
  
  
    /** 
     *  
     * 功能描述: <br> 
     * 初始化连接池管理对象 
     * 
     * @see [相关类/方法](可选) 
     * @since [产品/模块版本](可选) 
     */  
    private PoolingHttpClientConnectionManager getPoolManager() {  
        final String methodName = "getPoolManager";  
        LOGGER.enter(methodName, "initPoolManager");  
        if (null == cm) {  
            synchronized (LOCAL_LOCK) {  
                if (null == cm) {  
                    SSLContextBuilder sslContextBuilder = new SSLContextBuilder();  
                    try {  
                        sslContextBuilder.loadTrustMaterial(null, new TrustSelfSignedStrategy());  
                        SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(  
                                sslContextBuilder.build());  
                        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create()  
                                .register("https", socketFactory)  
                                .register("http", new PlainConnectionSocketFactory())  
                                .build();  
                        cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);  
                        cm.setMaxTotal(MAX_CONNECTION_NUM);  
                        cm.setDefaultMaxPerRoute(MAX_PER_ROUTE);  
                    } catch (Exception e) {  
                        LOGGER.error(methodName, "init PoolingHttpClientConnectionManager Error" + e);  
                    }  
  
  
                }  
            }  
        }  
        LOGGER.exit(methodName, "initPoolManager");  
        return cm;  
    }  
  
  
    /** 
     * 创建线程安全的HttpClient 
     *  
     * @param config 客户端超时设置 
     *  
     * @return 
     */  
    public CloseableHttpClient getHttpsClient(RequestConfig config) {  
        final String methodName = "getHttpsClient";  
        LOGGER.enter(methodName, "initHttpsClient");  
        CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(config)  
                .setConnectionManager(this.getPoolManager())  
                .build();  
        LOGGER.exit(methodName, "initHttpsClient");  
        return httpClient;  
    }  
  
  
    /** 
     * Https post请求 
     *  
     * @param url 请求地址 
     * @param json 请求参数(如果为null,则表示不请求参数) return 返回结果 
     */  
    public String poolHttpsPost(String url, JSONObject json) {  
        final String methodName = "poolHttpsPost";  
        LOGGER.enter(methodName, json);  
        CloseableHttpResponse response = null;  

[java] view plain copy
            HttpPost post = null;  
        try {  
            // 设置代理  
            HttpHost proxy = new HttpHost(InetAddressStr, InetPort);  
            // connectTimeout设置服务器请求超时时间  
            // socketTimeout设置服务器响应超时时间  
            RequestConfig requestConfig = RequestConfig.custom().setProxy(proxy)  
                    .setSocketTimeout(SERVER_REQUEST_TIME_OUT).setConnectTimeout(SERVER_RESPONSE_TIME_OUT).build();  
            post = new HttpPost(url);  
            post.setConfig(requestConfig);  
  
  
            if (json != null) {  
                StringEntity se = new StringEntity(json.toString(), CHAR_SET);  
                se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json;"));  
                post.setEntity(se);  
            }  
  
  
            LOGGER.info(methodName, "start post to weixin");  
            response = getHttpsClient(requestConfig).execute(post);  
            LOGGER.info(methodName, "end post to weixin");  
            int status = response.getStatusLine().getStatusCode();  
            LOGGER.info(methodName, "return status:" + status);  
  
  
            String result = null;  
            if (status == 200) {  
                result = EntityUtils.toString(response.getEntity(), CHAR_SET);  
            }  
            EntityUtils.consume(response.getEntity());  
            response.close();  
            LOGGER.exit(methodName);  
            return result;  
        } catch (Exception e) {  
            if (e instanceof SocketTimeoutException) {  
                // 服务器请求超时  
                LOGGER.error(methodName, "server request time out");  
            } else if (e instanceof ConnectTimeoutException) {  
                // 服务器响应超时(已经请求了)  
                LOGGER.error(methodName, "server response time out");  
            }  
            LOGGER.error(methodName, e.getMessage());  
        } finally {  

[java] view plain copy
                  post.releaseConnection();  
            if (response != null) {  
                try {  
                    EntityUtils.consume(response.getEntity());  
                    response.close();  
                } catch (IOException e) {  
                    LOGGER.error(methodName, e.getMessage());  
                }  
            }  
        }  
        LOGGER.exit(methodName);  
        // 超时或者网络不通时返回值  
        return null;  
    }  

0 0