package com.util;
import java.io.InterruptedIOException;
import java.net.URI;
import java.rmi.UnknownHostException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Map;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.routing.HttpRoute;
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.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
public class SkipHttpsUtil{
private static Integer requestTimeout =6000;
private static Integer defaultMaxPerRoute =20;
private static Integer maxTotal =20;
private static Integer timeout =6000;
private static Integer socketTimeout =6000;
//绕过证书
public static HttpClient wrapClient(String key) {
try {
SSLContext ctx = SSLContext.getInstance("TLS");
X509TrustManager tm = new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
}
public void checkClientTrusted(X509Certificate[] arg0,
String arg1) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] arg0,
String arg1) throws CertificateException {
}
};
ctx.init(null, new TrustManager[] { tm }, null);
SSLConnectionSocketFactory sslSF = new SSLConnectionSocketFactory(
ctx, NoopHostnameVerifier.INSTANCE);
PlainConnectionSocketFactory plainSF = PlainConnectionSocketFactory.getSocketFactory();
Registry registry = RegistryBuilder.create().register("http", plainSF).register("https", sslSF).build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
Map httpKeyConfig = httpKeyConfig(key);
cm.setMaxTotal(((Integer) httpKeyConfig.get("maxTotal")).intValue());
cm.setDefaultMaxPerRoute(((Integer) httpKeyConfig.get("defaultMaxPerRoute")).intValue());
String host = getIP(URI.create(key));
if (host == null) {
System.out.println("获取http请求host失败，http地址：" + key);
}
cm.setMaxPerRoute(new HttpRoute(HttpHost.create(host)), 50);
HttpRequestRetryHandler httpRequestRetryHandler = retryHandler();
RequestConfig defaultRequestConfig = RequestConfig.custom()
.setSocketTimeout(((Integer) httpKeyConfig.get("socketTimeout")).intValue())
.setConnectTimeout(((Integer) httpKeyConfig.get("timeout")).intValue())
.setConnectionRequestTimeout(((Integer) httpKeyConfig.get("requestTimeout")).intValue()).build();
CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.setConnectionManager(cm).setRetryHandler(httpRequestRetryHandler).build();
return httpClient;
} catch (Exception e) {
return HttpClients.createDefault();
}
}
private static String getIP(URI uri) {
URI effectiveURI;
try {
effectiveURI = new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), (String) null,
(String) null, (String) null);
} catch (Throwable arg2) {
effectiveURI = null;
}
return effectiveURI.toString();
}
private static HttpRequestRetryHandler retryHandler() {
return (exception, executionCount, context) -> {
if (executionCount >= 1) {
System.out.println("已经重试了1次，放弃连接！");
return false;
} else if (exception instanceof NoHttpResponseException) {
System.out.println("服务器丢掉了连接，请重试！");
return true;
} else if (exception instanceof SSLHandshakeException) {
System.out.println("SSL握手异常！");
return false;
} else if (exception instanceof InterruptedIOException) {
System.out.println("连接异常中断");
return false;
} else if (exception instanceof UnknownHostException) {
System.out.println("目标服务器不可达");
return false;
} else if (exception instanceof SSLException) {
System.out.println("ssl握手异常");
return false;
} else {
HttpClientContext clientContext = HttpClientContext.adapt(context);
HttpRequest request = clientContext.getRequest();
return !(request instanceof HttpEntityEnclosingRequest);
}
};
}
private static Map<String, Integer> httpKeyConfig(String key) {
HashMap keyConfig = new HashMap();
keyConfig.put("maxTotal", Integer.valueOf(200));
keyConfig.put("defaultMaxPerRoute", Integer.valueOf(20));
keyConfig.put("timeout", Integer.valueOf(6000));
keyConfig.put("requestTimeout", Integer.valueOf(6000));
keyConfig.put("socketTimeout", Integer.valueOf(6000));
try {
keyConfig.put("maxTotal", maxTotal);
} catch (Exception arg7) {
System.out.println(key + ".maxTotal配置未找到，使用默认值200");
}
try {
keyConfig.put("defaultMaxPerRoute", defaultMaxPerRoute);
} catch (Exception arg6) {
System.out.println(key + ".defaultMaxPerRoute配置未找到，使用默认值20");
}
try {
keyConfig.put("timeout", timeout);
keyConfig.put("requestTimeout", requestTimeout);
keyConfig.put("socketTimeout", socketTimeout);
} catch (Exception arg5) {
System.out.println(key + ".timeout配置未找到，使用默认值6000");
}
try {
keyConfig.put("requestTimeout", requestTimeout);
} catch (Exception arg4) {
System.out.println(key + ".requestTimeout配置未找到，使用默认值6000");
}
try {
keyConfig.put("socketTimeout", socketTimeout);
} catch (Exception arg3) {
System.out.println(key + ".socketTimeout配置未找到，使用默认值6000");
}
return keyConfig;
}
}
测试类
package com.util;
import java.io.IOException;
import java.net.URI;
import java.util.LinkedList;
import java.util.List;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
public class Test {
public static void main(String[] args) {
String url = "https://60.191.11.249:18443/sdk_service/rest/users/login/v1.1";
CloseableHttpResponse response = null;
// CloseableHttpClient httpClient = HttpManager.getHttpClint(url);
CloseableHttpClient httpClient=(CloseableHttpClient) SkipHttpsUtil.wrapClient(url);
try {
URIBuilder uri = new URIBuilder(url);
//get请求带参数
List<NameValuePair> list = new LinkedList<>();
BasicNameValuePair param1 = new BasicNameValuePair("account", "zhyusr");
BasicNameValuePair param2 = new BasicNameValuePair("pwd", "root@123");
list.add(param1);
list.add(param2);
uri.setParameters(list);
URI fullUri = uri.build();
HttpPost httpPost = new HttpPost(fullUri);
System.out.println("地图地理编码转换请求地址：" + fullUri);
//设置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(20000)
.setSocketTimeout(20000).setConnectTimeout(20000).build();
httpPost.setConfig(requestConfig);
// 发送请求
response = httpClient.execute(httpPost);
int status = response.getStatusLine().getStatusCode();
if (status == 200) {
HttpEntity entity = response.getEntity();
String output = EntityUtils.toString(entity, "utf-8");
System.out.println(output);
} else {
System.out.println("***接口请求失败，请求返回状态码：" + status + " ***");
}
} catch (Exception e) {
System.out.println("*** 转换接口请求异常 ***");
System.out.println(e.getMessage());
} finally {
try {
if (response != null)
response.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
