HttpClientPool 发请求的池子，感觉快不了多少，谁知道为什么？

谁践踏了优雅 2023-06-26 10:55 22阅读 0赞

import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.net.URLEncoder;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
 import org.apache.http.HttpEntity;
 import org.apache.http.HttpStatus;
 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.conn.HttpClientConnectionManager;
 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.impl.conn.PoolingHttpClientConnectionManager;
 import org.apache.http.message.BasicNameValuePair;
 import org.apache.http.pool.PoolStats;
 import org.apache.http.util.EntityUtils;
 
 public class HttpClientPool {
 	private static final int DEFAULT_POOL_MAX_TOTAL = 200;
 	private static final int DEFAULT_POOL_MAX_PER_ROUTE = 100;
 
 	private static final int DEFAULT_CONNECT_TIMEOUT = 500;
 	private static final int DEFAULT_CONNECT_REQUEST_TIMEOUT = 500;
 	private static final int DEFAULT_SOCKET_TIMEOUT = 2000;
 
 	private PoolingHttpClientConnectionManager gcm = null;
 
 	private CloseableHttpClient httpClient = null;
 
 	private IdleConnectionMonitorThread idleThread = null;
 
 	// 连接池的最大连接数
 	private final int maxTotal;
 	// 连接池按route配置的最大连接数
 	private final int maxPerRoute;
 
 	// tcp connect的超时时间
 	private final int connectTimeout;
 	// 从连接池获取连接的超时时间
 	private final int connectRequestTimeout;
 	// tcp io的读写超时时间
 	private final int socketTimeout;
 	
 	private static class HolderClass {
 		private static final HttpClientPool CLAZZ = new HttpClientPool();
 	}
 	
 	public static HttpClientPool getInstance() {
 		return HolderClass.CLAZZ;
 	}
 	
 	private HttpClientPool() {
 		this(HttpClientPool.DEFAULT_POOL_MAX_TOTAL, 
 				HttpClientPool.DEFAULT_POOL_MAX_PER_ROUTE,
 				HttpClientPool.DEFAULT_CONNECT_TIMEOUT,
 				HttpClientPool.DEFAULT_CONNECT_REQUEST_TIMEOUT,
 				HttpClientPool.DEFAULT_SOCKET_TIMEOUT);
 	}
 
 	private HttpClientPool(int maxTotal, int maxPerRoute, 
 			int connectTimeout, int connectRequestTimeout, int socketTimeout) {
 		this.maxTotal = maxTotal;
 		this.maxPerRoute = maxPerRoute;
 		this.connectTimeout = connectTimeout;
 		this.connectRequestTimeout = connectRequestTimeout;
 		this.socketTimeout = socketTimeout;
 
 //		Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
 //				.register("http", PlainConnectionSocketFactory.getSocketFactory())
 //				.register("https", SSLConnectionSocketFactory.getSocketFactory()).build();
 //		this.gcm = new PoolingHttpClientConnectionManager(registry);
 		// default ok
 		this.gcm = new PoolingHttpClientConnectionManager();
 		this.gcm.setMaxTotal(this.maxTotal);
 		this.gcm.setDefaultMaxPerRoute(this.maxPerRoute);
 
 		RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(this.connectTimeout) // 设置连接超时
 				.setSocketTimeout(this.socketTimeout) // 设置读取超时
 				.setConnectionRequestTimeout(this.connectRequestTimeout) // 设置从连接池获取连接实例的超时
 				.build();
 
 		HttpClientBuilder httpClientBuilder = HttpClients.custom();
 		httpClient = httpClientBuilder.setConnectionManager(this.gcm).setDefaultRequestConfig(requestConfig).build();
 
 		idleThread = new IdleConnectionMonitorThread(this.gcm);
 		idleThread.start();
 	}
 	
 	public String getPoolStats() {
 		PoolStats totalStats = this.gcm.getTotalStats();
 		return totalStats.toString();
 	}
 	
 	public void getAsync() {
 		
 	}
 
 	@SuppressWarnings("unchecked")
 	public String doGet(String url) {
 		return this.doGet(url, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
 	}
 	
 	@SuppressWarnings("unchecked")
 	public String doGet(String url, Map<String, Object> params) {
 		return this.doGet(url, Collections.EMPTY_MAP, params);
 	}
 
 	public String doGet(String url, Map<String, String> headers, Map<String, Object> params) {
 		// *) 构建GET请求头
 		String apiUrl = getUrlWithParams(url, params);
 		HttpGet httpGet = new HttpGet(apiUrl);
 
 		// *) 设置header信息
 		if (headers != null && headers.size() > 0) {
 			for (Map.Entry<String, String> entry : headers.entrySet()) {
 				httpGet.addHeader(entry.getKey(), entry.getValue());
 			}
 		}
 
 		CloseableHttpResponse response = null;
 		try {
 			response = httpClient.execute(httpGet);
 			if (response == null || response.getStatusLine() == null) {
 				return null;
 			}
 
 			int statusCode = response.getStatusLine().getStatusCode();
 			if (statusCode == HttpStatus.SC_OK) {
 				HttpEntity entityRes = response.getEntity();
 				if (entityRes != null) {
 					return EntityUtils.toString(entityRes, "UTF-8");
 				}
 			}
 			return null;
 		} catch (IOException e) {
 		} finally {
 			if (response != null) {
 				try {
 					response.close();
 				} catch (IOException e) {
 				}
 			}
 		}
 		return null;
 	}
 	
 	
 	@SuppressWarnings("unchecked")
 	public int doGetStatus(String url) {
 		System.out.println("douzi:" + getPoolStats());
 		return this.doGetStatus(url, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
 	}
 	
 	@SuppressWarnings("unchecked")
 	public int doGetStatus(String url, Map<String, Object> params) {
 		return this.doGetStatus(url, Collections.EMPTY_MAP, params);
 	}
 	/**
 	 * Title: doGetStatus
 	 * Description: 特殊场景使用，只需要知道请求的结果是否是200
 	 * @author douzi
 	 * @param url
 	 * @return
 	 */
 	public int doGetStatus(String url, Map<String, String> headers, Map<String, Object> params) {
 		// *) 构建GET请求头
 		String apiUrl = getUrlWithParams(url, params);
 		HttpGet httpGet = new HttpGet(apiUrl);
 
 		// *) 设置header信息
 		if (headers != null && headers.size() > 0) {
 			for (Map.Entry<String, String> entry : headers.entrySet()) {
 				httpGet.addHeader(entry.getKey(), entry.getValue());
 			}
 		}
 
 		CloseableHttpResponse response = null;
 		try {
 			response = httpClient.execute(httpGet);
 			if (response == null || response.getStatusLine() == null) {
 				return 0;
 			}
 
 			int statusCode = response.getStatusLine().getStatusCode();
 			if (statusCode == HttpStatus.SC_OK) {
 				return 1;
 			}
 			return 0;
 		} catch (IOException e) {
 		} finally {
 			if (response != null) {
 				try {
 					response.close();
 				} catch (IOException e) {
 				}
 			}
 		}
 		return 0;
 	}
 
 	@SuppressWarnings("unchecked")
 	public String doPost(String apiUrl, Map<String, Object> params) {
 		return this.doPost(apiUrl, Collections.EMPTY_MAP, params);
 	}
 
 	public String doPost(String apiUrl, Map<String, String> headers, Map<String, Object> params) {
 		HttpPost httpPost = new HttpPost(apiUrl);
 		// *) 配置请求headers
 		if (headers != null && headers.size() > 0) {
 			for (Map.Entry<String, String> entry : headers.entrySet()) {
 				httpPost.addHeader(entry.getKey(), entry.getValue());
 			}
 		}
 
 		// *) 配置请求参数
 		if (params != null && params.size() > 0) {
 			HttpEntity entityReq = getUrlEncodedFormEntity(params);
 			httpPost.setEntity(entityReq);
 		}
 
 		CloseableHttpResponse response = null;
 		try {
 			response = httpClient.execute(httpPost);
 			if (response == null || response.getStatusLine() == null) {
 				return null;
 			}
 
 			int statusCode = response.getStatusLine().getStatusCode();
 			if (statusCode == HttpStatus.SC_OK) {
 				HttpEntity entityRes = response.getEntity();
 				if (entityRes != null) {
 					return EntityUtils.toString(entityRes, "UTF-8");
 				}
 			}
 			return null;
 		} catch (IOException e) {
 		} finally {
 			if (response != null) {
 				try {
 					response.close();
 				} catch (IOException e) {
 				}
 			}
 		}
 		return null;
 
 	}
 
 	private HttpEntity getUrlEncodedFormEntity(Map<String, Object> params) {
 		List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
 		for (Map.Entry<String, Object> entry : params.entrySet()) {
 			NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue().toString());
 			pairList.add(pair);
 		}
 		return new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8"));
 	}
 
 	private String getUrlWithParams(String url, Map<String, Object> params) {
 		boolean first = true;
 		StringBuilder sb = new StringBuilder(url);
 		for (String key : params.keySet()) {
 			char ch = '&';
 			if (first == true) {
 				ch = '?';
 				first = false;
 			}
 			String value = params.get(key).toString();
 			try {
 				String sval = URLEncoder.encode(value, "UTF-8");
 				sb.append(ch).append(key).append("=").append(sval);
 			} catch (UnsupportedEncodingException e) {
 			}
 		}
 		return sb.toString();
 	}
 
 	public void shutdown() {
 		idleThread.shutdown();
 	}
 
 	// 监控有异常的链接
 	private class IdleConnectionMonitorThread extends Thread {
 		private final HttpClientConnectionManager connMgr;
 		private volatile boolean exitFlag = false;
 
 		public IdleConnectionMonitorThread(HttpClientConnectionManager connMgr) {
 			this.connMgr = connMgr;
 			setDaemon(true);
 		}
 
 		@Override
 		public void run() {
 			while (!this.exitFlag) {
 				synchronized (this) {
 					try {
 						this.wait(2000);
 					} catch (InterruptedException e) {
 						e.printStackTrace();
 					}
 				}
 				// 关闭失效的连接
 				connMgr.closeExpiredConnections();
 				// 可选的, 关闭30秒内不活动的连接
 				connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
 			}
 		}
 
 		public void shutdown() {
 			this.exitFlag = true;
 			synchronized (this) {
 				notify();
 			}
 		}
 
 	}
 }