com.github.javaclub.monitor.util.HttpClientUtils Maven / Gradle / Ivy
/*
* @(#)HttpClientUtils.java 2018年12月29日
*
* Copyright (c) 2018. All Rights Reserved.
*
*/
package com.github.javaclub.monitor.util;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.SSLContext;
import org.apache.http.HttpEntity;
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.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.HttpClientConnectionManager;
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.entity.ContentType;
import org.apache.http.entity.StringEntity;
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.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* HttpClientUtils
*
* @author Gerald Chen
* @version $Id: HttpClientUtils.java 2018年12月29日 14:58:28 Exp $
*/
public class HttpClientUtils {
static final Logger log = LoggerFactory.getLogger(HttpClientUtils.class);
private final static int CONN_TIMEOUT = 3;
private final static int SOCK_TIMEOUT = 5;
private static final int HTTP_SUCCESS = 200;
private final static RequestConfig config = RequestConfig.custom().setSocketTimeout(SOCK_TIMEOUT * 1000).setConnectTimeout(CONN_TIMEOUT * 1000).build();
private static HttpClientConnectionManager connectionManager = createHttpClientConnectionManager(100, 100, SOCK_TIMEOUT * 1000);
public static String get(String url) {
HttpGet method = new HttpGet(url);
return executeMethod(method, HttpClients.custom().setConnectionManager(connectionManager).build());
}
public static String get(String url, Map paramsMap) {
if (null != paramsMap && paramsMap.size() > 0) {
Set keySet = paramsMap.keySet();
StringBuilder sb = new StringBuilder(keySet.size() * 8);
sb.append("?");
for (String key : keySet) {
try {
String value = URLEncoder.encode(String.valueOf(paramsMap.get(key)), "UTF-8");
sb.append(key).append("=").append(value).append("&");
} catch (UnsupportedEncodingException e) {
log.error(e.getMessage(), e);
}
}
String params = sb.toString();
url += params.substring(0, params.length() - 1);
}
HttpGet method = new HttpGet(url);
return executeMethod(method, HttpClients.custom().setConnectionManager(connectionManager).build());
}
public static String post(String uri, Map params) throws Exception {
// 创建默认的httpClient实例.
CloseableHttpClient httpclient = HttpClients.createDefault();
// 创建httppost
HttpPost httppost = new HttpPost(uri);
// 创建参数队列
List formparams = new ArrayList();
if (params != null && !params.isEmpty()) {
for (String key : params.keySet()) {
formparams.add(new BasicNameValuePair(key, params.get(key)));
}
}
UrlEncodedFormEntity uefEntity;
try {
uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");
httppost.setEntity(uefEntity);
CloseableHttpResponse response = httpclient.execute(httppost);
try {
HttpEntity entity = response.getEntity();
if (entity != null) {
return EntityUtils.toString(entity, "UTF-8");
}
} finally {
response.close();
}
} catch (Exception e) {
throw e;
} finally {
// 关闭连接,释放资源
try {
httpclient.close();
} catch (Exception e) {
throw e;
}
}
return null;
}
public static String postJson(String url, String jsonStr) {
HttpPost method = new HttpPost(url);
method.setEntity(new StringEntity(jsonStr, ContentType.create("application/json", "UTF-8")));
return executeMethod(method, HttpClients.custom().setConnectionManager(connectionManager).build());
}
private static final String executeMethod(HttpRequestBase method, CloseableHttpClient client) {
method.setConfig(config);
CloseableHttpResponse response = null;
try {
response = client.execute(method);
if (HTTP_SUCCESS == response.getStatusLine().getStatusCode()) {
return EntityUtils.toString(response.getEntity());
} else {
log.warn("response code: {}", response.getStatusLine().getStatusCode());
log.warn(EntityUtils.toString(response.getEntity(), "UTF-8"));
}
} catch (Exception e) {
log.error("#http client post error with reason : {}", e.getMessage());
log.error(e.getMessage(), e);
} finally {
if (null != response) {
try {
response.close();
} catch (IOException e) {
log.error(e.getMessage(), e);
}
}
}
return null;
}
/**
* @see com.aliyun.oss.ClientConfiguration
* @see com.aliyun.oss.common.comm.DefaultServiceClient#createHttpClientConnectionManager()
* @param maxTotal
* @param maxPerRoute
* @return
*/
private static HttpClientConnectionManager createHttpClientConnectionManager(int maxTotal,
int maxPerRoute,
int socketTimeout) {
SSLContext sslContext = null;
try {
sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
public boolean isTrusted(X509Certificate[] chain, String authType)
throws CertificateException {
return true;
}
}).build();
} catch (Exception e) {
throw new RuntimeException(e.getMessage());
}
SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
Registry socketFactoryRegistry = RegistryBuilder. create()
.register("http", PlainConnectionSocketFactory.getSocketFactory())
.register("https", sslSocketFactory)
.build();
PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
connectionManager.setDefaultMaxPerRoute(maxPerRoute);
connectionManager.setMaxTotal(maxTotal);
connectionManager.setValidateAfterInactivity(2000);
connectionManager.setDefaultSocketConfig(SocketConfig.custom().setSoTimeout(socketTimeout).setTcpNoDelay(true).build());
IdleConnectionReaper.setIdleConnectionTime(60 * 1000);
IdleConnectionReaper.registerConnectionManager(connectionManager);
return connectionManager;
}
private static final class IdleConnectionReaper extends Thread {
private static long idleConnectionTime = 60 * 1000;
private static final int REAP_INTERVAL_MILLISECONDS = 5 * 1000;
private volatile boolean shuttingDown;
private static IdleConnectionReaper instance;
private static final ArrayList connectionManagers = new ArrayList();
private IdleConnectionReaper() {
super("idle_connection_reaper");
setDaemon(true);
}
public static synchronized boolean registerConnectionManager(HttpClientConnectionManager connectionManager) {
if (instance == null) {
instance = new IdleConnectionReaper();
instance.start();
}
return connectionManagers.add(connectionManager);
}
public static synchronized boolean removeConnectionManager(HttpClientConnectionManager connectionManager) {
boolean b = connectionManagers.remove(connectionManager);
if (connectionManagers.isEmpty()) {
shutdown();
}
return b;
}
private void markShuttingDown() {
shuttingDown = true;
}
@SuppressWarnings("unchecked")
@Override
public void run() {
while (true) {
if (shuttingDown) {
System.out.println("Shutting down reaper thread.");
return;
}
try {
Thread.sleep(REAP_INTERVAL_MILLISECONDS);
} catch (InterruptedException e) {
}
try {
List connectionManagers = null;
synchronized (IdleConnectionReaper.class) {
connectionManagers = (List)IdleConnectionReaper.connectionManagers.clone();
}
for (HttpClientConnectionManager connectionManager : connectionManagers) {
try {
connectionManager.closeExpiredConnections();
connectionManager.closeIdleConnections(idleConnectionTime, TimeUnit.MILLISECONDS);
} catch (Exception ex) {
System.err.println("Unable to close idle connections");
ex.printStackTrace();
}
}
} catch (Throwable t) {
t.printStackTrace();
}
}
}
public static synchronized boolean shutdown() {
if (instance != null) {
instance.markShuttingDown();
instance.interrupt();
connectionManagers.clear();
instance = null;
return true;
}
return false;
}
public static synchronized int size() {
return connectionManagers.size();
}
public static synchronized void setIdleConnectionTime(long idletime) {
idleConnectionTime = idletime;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy