不多说了直接上代码,代码经过线上测试过
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Consts;
import org.apache.http.Header;
import org.apache.http.HeaderIterator;
import org.apache.http.HttpEntity;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpRequest;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.NoHttpResponseException;
import org.apache.http.ParseException;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.GzipDecompressingEntity;
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.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.ConnectTimeoutException;
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.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.BasicCookieStore;
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.impl.cookie.BasicClientCookie;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HttpContext;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 功能说明
* HttpClient 4.5.X版本
* http连接是基于tcp的,而tcp创建连接需要三次握手,断开连接四次挥手,
* 为了提升性能,使用连接池进行Http连接管理:
* 1、降低延迟
* 2、支持更大的并发
* 工具类支持http与https协议,同 时支持采用双向认证
*
*
* @author Administrator
*
*/
public class HttpClientUtils {
private static final Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);
//报文压缩协议类型
private static final String GZIP = "gzip";
//请求协议类型
private static final String HTTP = "http";
private static final String HTTPS = "https";
private static final String CHAR_SET = "UTF-8";
// 代理IP
// private String InetAddressStr;
// 代理端口
// private int InetPort;
/**
* 连接池的最大连接数400
*/
private static int MAX_CONNECTION_NUM = 400;
/**
* 单路由最大连接数80
*/
/// private static int MAX_PER_ROUTE = 100;
/**
* 默认的每个路由的最大连接数80
*/
private static int DEFALUT_MAX_PER_ROUTE = 40;
/**
* 向服务端请求超时时间设置(单位:毫秒)
* 读超时时间(等待数据超时时间)setSocketTimeout
*/
private static int SOCKET_TIME_OUT = 60000;
/**
* 向服务端请求超时时间设置(单位:毫秒)
* 接收数据的等待超时时间,单位ms setSoTimeout
*/
private static int SO_TIME_OUT = 60000;
/**
* 向服务端请求超时时间设置(单位:毫秒)
* 关闭Socket时,要么发送完所有数据,要么等待60s后,就关闭连接,此时socket.close()是阻塞的
*/
private static int SO_LINGER = 60;
/**
* 从池中获取连接超时时间(单位:毫秒)
*/
private static int CONNECT_REQUEST_TIME_OUT = 60000;
/**
* 服务端响应超时时间设置(单位:毫秒)
*/
// private static int SERVER_RESPONSE_TIME_OUT = 2000;
/**
* 连接超时时间
*/
private static int CONNECT_TIME_OUT = 60000;
/**
* 重试处理
* 重试次数,重试多少次放弃重试
*/
private static int EXECUTION_COUNT = 5;
private static RequestConfig requestConfig;
//HttpClient连接
private static CloseableHttpClient httpClient;
//SSL连接工厂类
private static SSLConnectionSocketFactory sslsf;
//连接池管理器
private static PoolingHttpClientConnectionManager cm;
//SSL上下文创建器
private static SSLContextBuilder builder;
private final static Object syncLock = new Object();
// 请求重试处理
private static HttpRequestRetryHandler httpRequestRetryHandler;
//会话存储
private static CookieStore cookieStore;
//认证证书相关信息
/**
* 私钥证书 文件存放路径
*/
private static String keyStoreFilePath;
/**
* 私钥证书 密钥
*/
private static String keyStorePass;
/**
* 信任证书库 文件存放路径
*/
private static String trustStoreFilePath;
/**
* 信任证书库 密钥
*/
private static String trustStorePass;
/**
* 创建httpclient连接池并初始化
*/
static {
//请求配置
requestConfig = RequestConfig.custom()
.setCookieSpec(CookieSpecs.STANDARD_STRICT)
.build();
//设置Cookie存储
cookieStore = new BasicCookieStore();
BasicClientCookie cookie = new BasicClientCookie("sessionID", "######");
cookie.setDomain("#####");
cookie.setPath("/");
cookieStore.addCookie(cookie);
/**
* 重试处理
* 默认是重试5次
*/
//禁用重试(参数:retryCount、requestSentRetryEnabled)
//HttpRequestRetryHandler requestRetryHandler = new DefaultHttpRequestRetryHandler(0, false);
httpRequestRetryHandler = new HttpRequestRetryHandler() {
public boolean retryRequest(IOException exception,
int executionCount, HttpContext context) {
if (executionCount >= EXECUTION_COUNT) {// 如果已经重试了5次,就放弃
return false;
}
if (exception instanceof NoHttpResponseException) {// 如果服务器丢掉了连接,那么就重试
return true;
}
if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常
return false;
}
if (exception instanceof InterruptedIOException) {// 超时
return false;
}
if (exception instanceof UnknownHostException) {// 目标服务器不可达
return false;
}
if (exception instanceof ConnectTimeoutException) {// 连接被拒绝
return false;
}
if (exception instanceof SSLException) {// SSL握手异常
return false;
}
HttpClientContext clientContext = HttpClientContext.adapt(context);
HttpRequest request = clientContext.getRequest();
// 如果请求是幂等的,就再次尝试
//Retry if the request is considered idempotent
//如果请求类型不是HttpEntityEnclosingRequest,被认为是幂等的,那么就重试
//HttpEntityEnclosingRequest指的是有请求体的request,比HttpRequest多一个Entity属性
//而常用的GET请求是没有请求体的,POST、PUT都是有请求体的
//Rest一般用GET请求获取数据,故幂等,POST用于新增数据,故不幂等
if (!(request instanceof HttpEntityEnclosingRequest)) {
return true;
}
return false;
}
};
System.out.println("init conection pool...");
try {
builder = new SSLContextBuilder();
//使用证书方式
//initKeyStore(builder);
// 如果没有服务器证书,可以采用自定义 信任机制 (即全部信任 不做身份鉴定 )
builder.loadTrustMaterial(null, new TrustStrategy() {
@Override
public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
return true;
}
});
sslsf = new SSLConnectionSocketFactory(
builder.build(),
new String[]{"SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.2"},
null, NoopHostnameVerifier.INSTANCE);
// 注册Socket连接的协议
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
.register(HTTP, PlainConnectionSocketFactory.INSTANCE)//new PlainConnectionSocketFactory()
.register(HTTPS, sslsf)
.build();
cm = new PoolingHttpClientConnectionManager(registry);
//设置连接池的最大连接数
cm.setMaxTotal(MAX_CONNECTION_NUM);//max connection
/**
* 路由配置(默认配置 和 某个host的配置)
*/
//默认的每个路由的最大连接数
cm.setDefaultMaxPerRoute(DEFALUT_MAX_PER_ROUTE);
//设置到某个路由的最大连接数,会覆盖defaultMaxPerRoute
//cm.setMaxPerRoute(new HttpRoute(new HttpHost("somehost", 80)), MAX_PER_ROUTE);
/**
* socket配置(默认配置 和 某个host的配置)
*/
SocketConfig socketConfig = SocketConfig.custom()
.setTcpNoDelay(true) //是否立即发送数据,设置为true会关闭Socket缓冲,默认为false
.setSoReuseAddress(true) //是否可以在一个进程关闭Socket后,即使它还没有释放端口,其它进程还可以立即重用端口
.setSoTimeout(SO_TIME_OUT) //接收数据的等待超时时间,单位ms
.setSoLinger(SO_LINGER) //关闭Socket时,要么发送完所有数据,要么等待60s后,就关闭连接,此时socket.close()是阻塞的
.setSoKeepAlive(true) //开启监视TCP连接是否有效
.build();
cm.setDefaultSocketConfig(socketConfig);
//cm.setSocketConfig(new HttpHost("somehost", 80), socketConfig);
getHttpClient();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 初始化证书
* @param builder
* @throws IOException
*/
private static void initKeyStore(SSLContextBuilder builder) throws IOException {
InputStream ksis = null;
InputStream tsis = null;
try {
ksis = new FileInputStream(new File(keyStoreFilePath));// 私钥证书
tsis = new FileInputStream(new File(trustStoreFilePath));// 信任证书库
KeyStore ks = KeyStore.getInstance("PKCS12");
ks.load(ksis, keyStorePass.toCharArray());
KeyStore ts = KeyStore.getInstance("JKS");
ts.load(tsis, trustStorePass.toCharArray());
} catch (Exception e) {
e.printStackTrace();
} finally {
if (ksis != null) {
ksis.close();
}
if (tsis != null) {
tsis.close();
}
}
//builder.loadKeyMaterial(ks, keyStorePass.toCharArray());
// 如果有 服务器证书
//builder.loadTrustMaterial(ts, new TrustSelfSignedStrategy());
}
/**
* 线程安全并支持懒加载功能
* @return
*/
public static CloseableHttpClient getConnectionInsatance() {
return SingletonHttpClientHolder.closeableHttpClient;
}
/**
* 创建HttpClient
*
* @return
*/
public static CloseableHttpClient getHttpClient() {
if(httpClient == null){
synchronized (syncLock){
if (httpClient == null){
httpClient =HttpClients.custom()
.setConnectionManager(cm) //连接池管理器
//.setProxy(new HttpHost("myproxy", 8080)) //设置代理
.setDefaultCookieStore(cookieStore) // Cookie存储
.setDefaultRequestConfig(requestConfig) //默认请求配置
.setSSLSocketFactory(sslsf)
.setRetryHandler(httpRequestRetryHandler) // 请求重试处理(重试策略)
.setConnectionManagerShared(true) //支持连接共享
.build();
}
}
}
return httpClient;
}
/**
* 设置请求配置
* 创建一个Get请求,并重新设置请求参数,覆盖默认
* @param httpget
*/
private static void requestConfig(HttpRequestBase httpget) {
// 配置请求的超时设置
RequestConfig requestConfig = RequestConfig.custom()
.setSocketTimeout(SOCKET_TIME_OUT)
.setConnectTimeout(CONNECT_TIME_OUT)
.setConnectionRequestTimeout(CONNECT_REQUEST_TIME_OUT) //从池中获取连接超时时间
//.setProxy(new HttpHost("myotherproxy", 8080))
//.setStaleConnectionCheckEnabled(true)//在提交请求之前 测试连接是否可用
.build();
httpget.setConfig(requestConfig);
}
/**
* 获取 Cookie
*
* @param url
* @return
*/
public static Map<String,String> getCookie(String url){
//getHttpClient();
HttpRequest httpGet = new HttpGet(url);
CloseableHttpResponse response = null;
try{
response =httpClient.execute((HttpGet)httpGet);
Header[] headers = response.getAllHeaders();
Map<String,String> cookies=new HashMap<String, String>();
for(Header header:headers){
cookies.put(header.getName(),header.getValue());
}
return cookies;
}catch (Exception e){
e.printStackTrace();
} finally {
closeResponse(response);
//closeHttpClient(httpClient);
}
return null;
}
/**
* httpClient post请求
* @param url 请求url
* @param header 头部信息
* @param param 请求参数 form提交适用
* @param entity 请求实体 json/xml提交适用
* @return 可能为空 需要处理
* @throws Exception
*
*/
public static String post(String url, Map<String, String> header, Map<String, String> param, HttpEntity entity) throws Exception {
String result = "";
CloseableHttpResponse response = null;
try {
HttpPost httpPost = new HttpPost(url);
// 设置头信息
if (MapUtils.isNotEmpty(header)) {
for (Map.Entry<String, String> entry : header.entrySet()) {
httpPost.addHeader(entry.getKey(), entry.getValue());
}
}
// 设置请求参数
if (MapUtils.isNotEmpty(param)) {
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
for (Map.Entry<String, String> entry : param.entrySet()) {
//给参数赋值
formparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
}
UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(formparams, Consts.UTF_8);
httpPost.setEntity(urlEncodedFormEntity);
}
// 设置实体 优先级高
if (entity != null) {
httpPost.setEntity(entity);
}
//设置请求配置
requestConfig(httpPost);
response = httpClient.execute(httpPost);
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode == HttpStatus.SC_OK) {
HttpEntity resEntity = response.getEntity();
result = EntityUtils.toString(resEntity);
} else {
readHttpResponse(response);
}
} catch (Exception e) {throw e;
} finally {
closeResponse(response);
//closeHttpClient(httpClient);
}
return result;
}
/**
* 读请求响应
*
* @param httpResponse
* @return
* @throws ParseException
* @throws IOException
*/
public static String readHttpResponse(CloseableHttpResponse httpResponse)
throws ParseException, IOException {
StringBuilder builder = new StringBuilder();
// 获取响应消息实体
HttpEntity entity = httpResponse.getEntity();
// 响应状态
builder.append("status:" + httpResponse.getStatusLine());
builder.append("headers:");
HeaderIterator iterator = httpResponse.headerIterator();
while (iterator.hasNext()) {
builder.append("\t" + iterator.next());
}
// 判断响应实体是否为空
if (entity != null) {
String responseString = EntityUtils.toString(entity);
builder.append("response length:" + responseString.length());
builder.append("response content:" + responseString.replace("\r\n", ""));
}
return builder.toString();
}
/**
* post请求,使用json格式传参
* @param url
* @param headers
* @param data
* @return
*/
public static HttpEntity postJson(String url,Map<String,Object> headers,String data){
HttpRequest request = new HttpPost(url);
if(headers!=null&&!headers.isEmpty()){
request = setHeaders(headers,request);
}
CloseableHttpResponse response = null;
try {
HttpPost httpPost = (HttpPost) request;
httpPost.setEntity(new StringEntity(data, ContentType.create("application/json", CHAR_SET)));//解决中文乱码问题
response=httpClient.execute(httpPost);
HttpEntity entity = response.getEntity();
return entity;
} catch (IOException e) {
e.printStackTrace();
} finally {
closeResponse(response);
}
return null;
}
/**
* post请求,使用json格式传参
* @param url
* @param headers
* @param data
* @return
*/
public static String postJsonToString(String url,Map<String,Object> headers,String data){
HttpRequest request = new HttpPost(url);
if(headers!=null&&!headers.isEmpty()){
request = setHeaders(headers,request);
}
CloseableHttpResponse response = null;
try {
HttpPost httpPost = (HttpPost) request;
httpPost.setEntity(new StringEntity(data, ContentType.create("application/json", CHAR_SET)));//解决中文乱码问题
response=httpClient.execute(httpPost);
HttpEntity entity = response.getEntity();
return EntityUtils.toString(entity);
} catch (IOException e) {
e.printStackTrace();
} finally {
closeResponse(response);
}
return null;
}
/**
* 设置请求头信息
*
* @param headers
* @param request
* @return
*/
private static HttpRequest setHeaders(Map<String,Object> headers, HttpRequest request) {
for (Map.Entry<String, Object> entry : headers.entrySet()) {
//如果设置的协议头不是Cookies
if (!entry.getKey().equals("Cookie")) {
request.addHeader((String) entry.getKey(), (String) entry.getValue());
} else {
Map<String, Object> Cookies = (Map<String, Object>) entry.getValue();
for (Map.Entry<String, Object> entry1 : Cookies.entrySet()) {
request.addHeader(new BasicHeader("Cookie", (String) entry1.getValue()));
}
}
}
return request;
}
/**
* 使用表单键值对传参
* @param url
* @param headers
* @param data
* @return
*/
public static HttpEntity postForm(String url,Map<String,Object> headers,List<NameValuePair> data){
CloseableHttpClient httpClient = getHttpClient();
HttpRequest request = new HttpPost(url);
//设置请求配置
requestConfig((HttpPost)request);
if(headers!=null&&!headers.isEmpty()){
request = setHeaders(headers,request);
}
CloseableHttpResponse response = null;
try {
HttpPost httpPost = (HttpPost) request;
UrlEncodedFormEntity uefEntity = new UrlEncodedFormEntity(data,CHAR_SET);
httpPost.setEntity(uefEntity);
// httpPost.setEntity(new StringEntity(data, ContentType.create("application/json", "UTF-8")));
response=httpClient.execute(httpPost);
HttpEntity entity = response.getEntity();
return entity;
} catch (IOException e) {
e.printStackTrace();
} finally {
closeResponse(response);
}
return null;
}
/**
* 拼装HTTP的Get请求URL与参数
* @param url
* @param params
* @return
*/
private static String assemblyGetRequestUrlAndParams(String url, Map<String, String> params) {
if (StringUtils.isBlank(url)) {
logger.error("Request URL Is Not Null");
return null;
}
StringBuffer buffer = new StringBuffer(url);
if (params != null && !params.isEmpty()) {
if (url.indexOf("?") < 0) {
buffer.append("?");
}
for (Map.Entry<String, String> entry : params.entrySet()) {
if (url.indexOf("?") > 0) {
buffer.append("&" + entry.getKey() + "=" + entry.getValue());
} else {
buffer.append(entry.getKey() + "=" + entry.getValue() + "&");
}
}
}
return buffer.toString();
}
/**
* 获取HTTP的响应
* @param url
* @param headers
* @return
*/
public static CloseableHttpResponse getResponse(String url, Map<String, String> headers) {
//1.创建客户端访问服务器的httpclient对象 打开浏览器
getHttpClient();
//2.以请求的连接地址创建get请求对象 浏览器中输入网址
HttpGet httpget = new HttpGet(url);
//设置请求头
if (headers != null && !headers.isEmpty()) {
for (Map.Entry<String, String> entry : headers.entrySet()) {
httpget.setHeader(entry.getKey(), entry.getValue());
}
}
//设置请求配置
requestConfig(httpget);
//3.向服务器端发送请求 并且获取响应对象 浏览器中输入网址点击回车
CloseableHttpResponse response = null;
try {
response = httpClient.execute(httpget);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
//释放资源直接中止这次连接 否则服务将会出现大量的CLOSE_WAIT
httpget.abort();
return response;
}
} catch (ClientProtocolException e) {
httpget.abort();
//logger.error(e.getMessage());
e.printStackTrace();
return null;
} catch (IOException e) {
httpget.abort();
//logger.error(e.getMessage());
e.printStackTrace();
return response;
} finally {
}
return response;
}
/**
* GET 请求
*
* @param url - 请求路径
* @param params - 请求参数
* @param headers - 请求头
* @return
* @throws Exception
*/
public static HttpEntity get(String url, Map<String, String> params, Map<String, String> headers) {
//1.拼装URL
String tempUrl = assemblyGetRequestUrlAndParams(url, params);
//2.向服务器端发送请求 并且获取响应对象 浏览器中输入网址点击回车
CloseableHttpResponse response = getResponse(tempUrl, headers);
if (response == null) {
logger.error("CloseableHttpResponse Object Is Not Null");
return null;
}
//3.获取响应实体
HttpEntity entity = response.getEntity();
try{
//4.获取响应对象中的响应码
StatusLine statusLine = response.getStatusLine();//获取请求对象中的响应行对象
int responseCode = statusLine.getStatusCode();//从状态行中获取状态码
if (responseCode == 200) {
System.out.println("响应成功!");
System.out.println("信息----------------------------------------");
System.out.println(response.getStatusLine());
System.out.println("----------------------------------------");
} else {
System.out.println("响应失败!");
System.out.println("错误信息----------------------------------------");
System.out.println(response.getStatusLine());
System.out.println("----------------------------------------");
}
EntityUtils.consume(entity);
} catch (Exception e){
e.printStackTrace();
} finally {
closeResponse(response);
//closeHttpClient(httpClient);
}
return entity;
}
/**
* 返回字符串,适合于返回结果为JSON XML格式
*
* @param url
* @param params
* @param headers
* @return
* @throws Exception
*/
public static String getString(String url, Map<String, String> params, Map<String, String> headers){
//1.拼装URL
String tempUrl = assemblyGetRequestUrlAndParams(url, params);
//2.向服务器端发送请求 并且获取响应对象 浏览器中输入网址点击回车
CloseableHttpResponse response = getResponse(tempUrl, headers);
//3.获取响应实体
if (response == null) {
logger.error("CloseableHttpResponse Object Is Not Null");
return null;
}
HttpEntity entity = response.getEntity(); ;
if (entity != null) {
try {
// 判断返回报文是否压缩
if (entity.getContentEncoding() != null && GZIP.equalsIgnoreCase(entity.getContentEncoding().getName())) {
entity = new GzipDecompressingEntity(entity);
}
String temp = EntityUtils.toString(entity);
EntityUtils.consume(entity);
return temp;
} catch (ParseException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
closeResponse(response);
//closeHttpClient(httpClient);
}
}
return null;
}
/**
* 关闭请求资源,
* @param response
*/
public static void closeResponse(CloseableHttpResponse response) {
if(response!=null){
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 关闭连接管理器,并会关闭其管理的连接
* @param httpClient
*/
public static void closeHttpClient(CloseableHttpClient httpClient) {
if (httpClient != null){
try {
//关闭连接管理器,并会关闭其管理的连接
httpClient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 单例模式
* 利用静态内部类特性实现线程安全与懒加载
*
* @author
*
*/
private static class SingletonHttpClientHolder {
private static final CloseableHttpClient closeableHttpClient = HttpClients.custom() //
.setConnectionManager(cm) //连接池管理器
//.setProxy(new HttpHost("myproxy", 8080)) //设置代理
.setDefaultCookieStore(cookieStore) // Cookie存储
.setDefaultRequestConfig(requestConfig) //默认请求配置
.setSSLSocketFactory(sslsf)
.setRetryHandler(httpRequestRetryHandler) // 请求重试处理(重试策略)
.setConnectionManagerShared(true) //支持连接共享
.build();
}
}
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import com.alibaba.fastjson.JSONObject;
public class TestHttp {
public static void main(String[] args) {
// URL列表数组
String[] urisToGet1 = {
"http://blog.csdn.net/gaolu/article/details/48466059",
"http://blog.csdn.net/gaolu/article/details/48243103",
"http://blog.csdn.net/gaolu/article/details/47656987",
"http://blog.csdn.net/gaolu/article/details/47055029",
"http://blog.csdn.net/gaolu/article/details/46400883",
"http://blog.csdn.net/gaolu/article/details/46359127",
"http://blog.csdn.net/gaolu/article/details/46224821",
"http://blog.csdn.net/gaolu/article/details/45305769",
"http://blog.csdn.net/gaolu/article/details/43701763",
"http://blog.csdn.net/gaolu/article/details/43195449",
"http://blog.csdn.net/gaolu/article/details/42915521",
"http://blog.csdn.net/gaolu/article/details/41802319",
"http://blog.csdn.net/gaolu/article/details/41045233",
"http://blog.csdn.net/gaolu/article/details/40395425",
"http://blog.csdn.net/gaolu/article/details/40047065",
"http://blog.csdn.net/gaolu/article/details/39891877",
"http://blog.csdn.net/gaolu/article/details/39499073",
"http://blog.csdn.net/gaolu/article/details/39314327",
"http://blog.csdn.net/gaolu/article/details/38820809",
"http://blog.csdn.net/gaolu/article/details/38439375",
"http://10.10.0.186/galaxy-openplatform-business/common/queryByWaybillNo?waybillNo=100000971089&orderSource=11&accessKey=5c7944d98cfd80055ac05dd4214aa788&secretKey=37399ec2e08f0ec70c78780b175e4954&compCode=whddwl×tamp=20180417125001&version=v1.0.0&messageBody=5SllNoJJDKsbGyfbfwAHNA==&digest=NpygFP/1UoTlglbS8f4Ldg=="
};
int size = 800;
String[] urisToGet = new String[size];
for(int i=0; i<size; i++) {
urisToGet[i]= "http://10.10.0.179:8080/galaxy-openplatform-business/common/saveOutOrderToYmOrder";
}
long start = System.currentTimeMillis();
try {
Map<String, String> params = new HashMap<>();
//params.put("sectionCode", "yimidida");
int pagecount = urisToGet.length;
ExecutorService executors = Executors.newFixedThreadPool(pagecount,
new ThreadFactory() {
AtomicInteger atomic = new AtomicInteger();
public Thread newThread(Runnable r) {
return new Thread(r, "Thread" + this.atomic.getAndIncrement());
}
});
CountDownLatch countDownLatch = new CountDownLatch(pagecount);
for(int i = 0; i< pagecount;i++){
//启动线程抓取
executors.execute(new GetRunnable(i, urisToGet[i], null, countDownLatch));
System.out.println(i);
}
countDownLatch.await();
executors.shutdown();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("线程" + Thread.currentThread().getName() + "," + System.currentTimeMillis() + ", 所有线程已完成,开始进入下一步!");
}
long end = System.currentTimeMillis();
System.out.println("consume -> " + (end - start));
}
static class GetRunnable implements Runnable {
private CountDownLatch countDownLatch;
/* private final CloseableHttpClient httpClient;
private final HttpGet httpget; */
private String url;
private Map<String, String> params;
private final int i;
public GetRunnable(int i, String url, Map<String, String> params, CountDownLatch countDownLatch){
/*this.httpClient = httpClient;
this.httpget = httpget; */
this.url = url;
this.params = params;
this.i=i;
this.countDownLatch = countDownLatch;
}
/**
* 获取参数名与参数值的MD5加密字符串
* @param content
* @param charset
* @return
*/
public static String md5(String content, String charset) {
if (StringUtils.isBlank(charset)) {
charset="utf-8";
}
if (StringUtils.isBlank(content)) {
return content;
}
try {
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.update(content.getBytes(charset));
return new String(Base64.encodeBase64(messageDigest.digest()), charset);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 生成一个由大写字母和数字组成的6位的随机字符串,并且字符串不重复
* @param length
*/
public static String random(int length) {
char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P','Q', 'R', 'S', 'T', 'U', 'V',
'W', 'X', 'Y', 'Z','0','1','2','3','4','5','6','7','8','9'};
boolean[] flags = new boolean[letters.length];
char[] chs = new char[length];
for (int i = 0; i < chs.length; i++) {
int index;
do {
index = (int) (Math.random() * (letters.length));
} while (flags[index]);// 判断生成的字符是否重复
chs[i] = letters[index];
flags[index] = true;
}
return String.valueOf(chs);
}
private String getData() {
//订单基础信息
OrderVo orderVo = new OrderVo();
orderVo.setBizType("1");
orderVo.setProvince("贵州省");
orderVo.setCity("贵阳市");
orderVo.setCounty("云岩区");
orderVo.setTown("蚂蚁村");
orderVo.setWeChatID("18917566957");
orderVo.setOrderChannel(7);
orderVo.setOutsideNo(random(8));
orderVo.setConsigneeAddress("收件地址");
orderVo.setSenderAddress("寄件地址");
orderVo.setVolume(BigDecimal.valueOf(92.390));
//包装规格
List<OrderPackageRuleVo> packageRuleList = new ArrayList<OrderPackageRuleVo>();
OrderPackageRuleVo oprVo1 = new OrderPackageRuleVo();
oprVo1.setQuantity(1);
oprVo1.setRuleCode("TC00");
oprVo1.setRuleName("木箱");
OrderPackageRuleVo oprVo2 = new OrderPackageRuleVo();
oprVo2.setQuantity(1);
oprVo2.setRuleCode("TC003");
oprVo2.setRuleName("标准");
packageRuleList.add(oprVo1);
packageRuleList.add(oprVo2);
orderVo.setPackageRuleList(packageRuleList);
//费用
List<OrderServiceFeeVo> serviceFeeList = new ArrayList<OrderServiceFeeVo>();
OrderServiceFeeVo osfVo1 = new OrderServiceFeeVo();
osfVo1.setInFeeAmt(BigDecimal.valueOf(92.390));
osfVo1.setOutFeeAmt(BigDecimal.valueOf(92.390));
osfVo1.setServiceTypeCode("CT01");
OrderServiceFeeVo osfVo2 = new OrderServiceFeeVo();
osfVo2.setInFeeAmt(BigDecimal.valueOf(92.390));
osfVo2.setOutFeeAmt(BigDecimal.valueOf(92.390));
osfVo2.setServiceTypeCode("CT02");
serviceFeeList.add(osfVo1);
serviceFeeList.add(osfVo2);
OrderDiscountVo odVo = new OrderDiscountVo();
odVo.setAmount(BigDecimal.valueOf(92.390));
odVo.setCouponName("优惠券");
orderVo.setOrderDiscount(odVo);
//加密报文Json
JSONObject object1 = new JSONObject();
object1.put("orderSource", "7");
object1.put("orderVo", orderVo);
String messageBody = md5(object1.toJSONString(), null);
System.out.println("messageBody 报文实体MD5加密====="+ messageBody);
//签名Digest JSON
JSONObject object = new JSONObject();
object.put("accessKey", "8acba5cf2f50e6037a9c412b52f9ca75");
object.put("secretKey", "73f33acded6741eac5a17a01374fd3d2");
object.put("compCode", "yunjitong");
object.put("messageBody", messageBody);
object.put("timestamp", "20170409182301");
object.put("version", "v1.0.0");
String digest = md5(object.toJSONString(), null);
System.out.println("digest签名MD5加密==="+digest);
//Post数据字符串 JSON
JSONObject data = new JSONObject();
data.put("accessKey", "8acba5cf2f50e6037a9c412b52f9ca75");
data.put("secretKey", "73f33acded6741eac5a17a01374fd3d2");
data.put("compCode", "yunjitong");
data.put("messageBody", messageBody);
data.put("digest", digest);
data.put("timestamp", "20170409182301");
data.put("version", "v1.0.0");
data.put("orderSource", "7");
data.put("orderVo", orderVo);
System.out.println(data.toJSONString());
return data.toJSONString();
}
@Override
public void run() {
Map<String, Object> headers = new HashMap<>();
headers.put("Accept", "*/*");
headers.put("Accept-Encoding", "gzip, deflate, sdch");
headers.put("Accept-Language", "zh-CN,zh;q=0.8");
System.out.println(i+"========");
//System.out.println(Thread.currentThread().getName()+"=="+HttpClientUtils.getString(url, params, headers));
System.out.println(Thread.currentThread().getName()+"=="+HttpClientUtils.postJsonToString(url, headers, getData()));
countDownLatch.countDown();
}
}
}