package com.walker.remote.util;
import com.walker.remote.AbstractByteCoder;
import com.walker.remote.DoubleTrust;
import com.walker.remote.RemoteAccessor;
import com.walker.remote.RemoteAccessorException;
import com.walker.remote.support.DefaultRemoteAccessor;
import org.apache.hc.client5.http.classic.HttpClient;
import org.apache.hc.client5.http.cookie.CookieStore;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
import org.apache.hc.core5.http.NameValuePair;
import org.apache.hc.core5.http.io.SocketConfig;
import org.apache.hc.core5.http.message.BasicNameValuePair;
import org.apache.hc.core5.ssl.SSLContexts;
import org.apache.hc.core5.util.Timeout;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyStore;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class HttpUtils {
// private Log logger = LogFactory.getLog(getClass());
// http调用客户端
private HttpClient httpClient = null;
// private AbstractByteCoder contentCoder = null;
private static HttpUtils httpUtils;
private HttpUtils(){
// beanFactory = new DefaultBeanFactory();
// BeanFactoryHelper.setBeanFactory(beanFactory);
//
// httpClient = doCreateSafeHttpClient();
// beanFactory.addBean(HttpClient.class, httpClient);
// this.doCreateRemoteAccessor();
httpClient = this.doCreateSafeHttpClient(null, null);
}
public static HttpUtils getInstance(){
if(httpUtils == null){
httpUtils = new HttpUtils();
}
return httpUtils;
}
public HttpClient getHttpClient() {
return httpClient;
// return doGetNewHttpClient();
}
/**
* 返回设置过cookie的httpClient对象，每次都要新创建
*
* @param cookieStore
* @return
*/
public HttpClient getHttpClientWithCookie(CookieStore cookieStore) {
// return httpClient;
return this.doCreateSafeHttpClient(null, cookieStore);
}
/**
* 返回一个双向认证的HttpClient对象。
* 注意：在上层应用中，该方法通常被初始化调用，而不是每次使用都被频繁获取。
* @param doubleTrust
* @return
*/
public HttpClient getHttpDoubleTrustClient(DoubleTrust doubleTrust, CookieStore cookieStore) {
return this.doCreateSafeHttpClient(doubleTrust, cookieStore);
// try{
// // 重新加入https信息
// KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
// FileInputStream instream = new FileInputStream(new File(doubleTrust.getCerFilepath()));
// //密匙库的密码
// trustStore.load(instream, doubleTrust.getPassword().toCharArray());
// //注册密匙库
// SSLSocketFactory socketFactory = new SSLSocketFactory(trustStore);
// //不校验域名
// socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
// Scheme sch = new Scheme("https", 443, socketFactory);
// httpClient.getConnectionManager().getSchemeRegistry().register(sch);
// return httpClient;
// } catch(Exception ex){
// ex.printStackTrace();
// return null;
// }
}
/**
* 创建线程安全的HttpClient对象。
* @return
*/
private HttpClient doCreateSafeHttpClient(DoubleTrust clientTrust, CookieStore cookieStore){
// HttpParams params = new BasicHttpParams();
//
// //设置基本参数
// HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
// HttpProtocolParams.setContentCharset(params, StringUtils.DEFAULT_CHARSET_UTF8);
// HttpProtocolParams.setUserAgent(params, "HttpComponents/1.1");
//
// HttpConnectionParams.setStaleCheckingEnabled(params, false);
// HttpConnectionParams.setTcpNoDelay(params, true);
// HttpConnectionParams.setSocketBufferSize(params, 8 * 1024);
//
// HttpClientParams.setRedirecting(params, false);
//
// //超时设置
// params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 15000);
// params.setParameter(CoreConnectionPNames.SO_TIMEOUT, 15000);
// // 该值就是连接不够用的时候等待超时时间，一定要设置，而且不能太大 ()
// params.setLongParameter(ClientPNames.CONN_MANAGER_TIMEOUT, 500L);
// // 在提交请求之前 测试连接是否可用
// params.setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, true);
//
// //设置HttpClient支持HTTp和HTTPS两种模式
// SchemeRegistry schReg = new SchemeRegistry();
//// schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
//// schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
// schReg.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
// try {
// schReg.register(new Scheme("https", 443, getSSLSocketFactory(clientTrust)));
// } catch (KeyManagementException e) {
// e.printStackTrace();
// throw new IllegalStateException("KeyManagementException: 创建ssl httpclient证书错误：" + e.getMessage());
// } catch (NoSuchAlgorithmException e) {
// e.printStackTrace();
// throw new IllegalStateException("NoSuchAlgorithmException: 创建ssl httpclient算法错误：" + e.getMessage());
// } catch(FileNotFoundException ex){
// throw new IllegalStateException("FileNotFoundException: 创建ssl失败未找到客户端证书：" + ex.getMessage());
// } catch(Exception rex){
// throw new IllegalStateException(rex);
// }
//
// PoolingClientConnectionManager conMgr = new PoolingClientConnectionManager(schReg);
// conMgr.setDefaultMaxPerRoute(128); //每个主机的最大并行链接数
// conMgr.setMaxTotal(512); //客户端总并行链接最大数
//
// HttpClient client = new DefaultHttpClient(conMgr, params);
// return client;
CloseableHttpClient httpclient = null;
//密匙库的密码
InputStream instream = null;
Resource resource = null;
KeyStore keyStore = null;
PoolingHttpClientConnectionManager cm = null;
try {
resource = new ClassPathResource(clientTrust.getCerFilepath());
instream = resource.getInputStream();
keyStore = KeyStore.getInstance("PKCS12");
// instream = new FileInputStream(new File(clientTrust.getCerFilepath()));
// keyStore.load(instream, clientTrust.getPassword().toCharArray());
keyStore.load(instream, clientTrust.getPassword().toCharArray());
} catch (Exception ex){
throw new RemoteAccessorException("加载证书错误: " + clientTrust.getCerFilepath(), ex);
}
try {
SSLContext sslcontext = SSLContexts.custom()
.loadKeyMaterial(keyStore, clientTrust.getPassword().toCharArray()).build();
// Allow TLSv1 protocol only
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
sslcontext,
new String[] {"TLSv1", "TLSv1.1", "TLSv1.2"},
null,
// SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER
// SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER
new NoopHostnameVerifier()
);
//
SocketConfig socketConfig = SocketConfig.custom()
.setSoTimeout(Timeout.ofSeconds(10))
.build();
cm = PoolingHttpClientConnectionManagerBuilder.create()
.setDefaultSocketConfig(socketConfig)
.setSSLSocketFactory(sslsf).build();
cm.setDefaultMaxPerRoute(128);
cm.setMaxTotal(512);
} catch (Exception ex){
throw new RemoteAccessorException("SSLContext 异常: " + ex.getMessage(), ex);
}
if(clientTrust != null){
try {
httpclient = HttpClients.custom().setConnectionManager(cm).build();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
} finally {
try {
instream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} else {
if(cookieStore != null){
httpclient = HttpClients.custom().setConnectionManager(cm).setDefaultCookieStore(cookieStore).build();
} else {
httpclient = HttpClients.custom().setConnectionManager(cm).build();
}
}
return httpclient;
}
// private static SSLSocketFactory getSSLSocketFactory(DoubleTrust clientTrust)
// throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, FileNotFoundException{
// SSLContext ctx = SSLContext.getInstance("TLSv1");
// TrustManager[] trustManagers = null;
//
// if(clientTrust != null){
// // 如果存在双向认证
// // 重新加入https信息
// KeyStore trustStore = KeyStore.getInstance("PKCS12");
// FileInputStream instream = new FileInputStream(new File(clientTrust.getCerFilepath()));
// //密匙库的密码
// try {
// trustStore.load(instream, clientTrust.getPassword().toCharArray());
// } catch (Exception e) {
// e.printStackTrace();
// throw new RuntimeException(e);
// }
// TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
// tmf.init(trustStore);
// trustManagers = tmf.getTrustManagers();
//
// } else {
// X509TrustManager tm = new X509TrustManager() {
// @Override
// public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType)
// throws java.security.cert.CertificateException {
//
// }
//
// @Override
// public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType)
// throws java.security.cert.CertificateException {
//
// }
//
// @Override
// public java.security.cert.X509Certificate[] getAcceptedIssuers() {
// return null;
// }
// };
// trustManagers = new TrustManager[]{tm};
// }
//
// ctx.init(null, trustManagers, null);
// return new SSLSocketFactory(ctx, SSLSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
// }
// private HttpClient doGetNewHttpClient(){
// HttpParams params = new BasicHttpParams();
//
// //设置基本参数
// HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
// HttpProtocolParams.setContentCharset(params, StringUtils.DEFAULT_CHARSET_UTF8);
// HttpProtocolParams.setUserAgent(params, "Android client");
//
// HttpConnectionParams.setStaleCheckingEnabled(params, false);
// HttpConnectionParams.setTcpNoDelay(params, true);
// HttpConnectionParams.setSocketBufferSize(params, 8 * 1024);
//
// HttpClientParams.setRedirecting(params, false);
// /*连接超时*/
// HttpConnectionParams.setConnectionTimeout(params, 20000);
// /*请求超时*/
// HttpConnectionParams.setSoTimeout(params, 20000);
// HttpClient client = new DefaultHttpClient(params);
// return client;
// }
public static List doTranslatePairs(Map simpleData){
List pair = new ArrayList();
for(Map.Entry entry : simpleData.entrySet()){
pair.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
}
return pair;
}
/**
* 把json格式参数转换为特定http参数
* @param json
* @return
*/
public static List doTranslatePairs(String json){
List pair = new ArrayList();
pair.add(new BasicNameValuePair(RemoteAccessor.DEFALUT_FORM_DATA_NAME, json));
return pair;
}
/**
* 返回一个通用的远程访问对象
* @param contentCoder
* @return
*/
public RemoteAccessor getNewRemoteAccessor(String remoteURL
, AbstractByteCoder contentCoder, DoubleTrust doubleTrust){
// String remoteURL = getRemoteServerURL();
RemoteAccessor remoteAccessor = new DefaultRemoteAccessor();
remoteAccessor.setBaseUrl(remoteURL);
remoteAccessor.setContentEncoder(contentCoder);
// 设置双向认证的客户端证书，如果存在
remoteAccessor.setDoubleTrust(doubleTrust);
return remoteAccessor;
}
// /**
// * 添加远程请求单例对象。
// * 此方法放在initialize()方法之后，是因为需要子类先提供服务端访问URL地址，才能初始化该对象。
// */
// private void doCreateRemoteAccessor(){
// String remoteURL = getRemoteServerURL();
// logger.debug("............应用启动，获得一次RemoteURL: " + remoteURL);
// contentCoder = new Base64ByteCoder();
// RemoteAccessor remoteAccessor = new DefaultRemoteAccessor();
// remoteAccessor.setBaseUrl(remoteURL);
// remoteAccessor.setContentEncoder(contentCoder);
// }
// private String getRemoteServerURL(){
// return "http://opentest.17wanxiao.com:80/campus/";
// return "http://120.55.104.155:80/campus/";
// return "http://www.17wanxiao.com/campus/";
// }
}