public class HttpUtils {
private static final Logger logger = LoggerFactory.getLogger(HttpUtils.class);
private static final CloseableHttpClient httpClient;
private static final RequestConfig requestConfig;
static final String CHARSET = "UTF-8";
//连接池最大并发连接数
private static final int MAX_TOTAL_CONNECTIONS = 2000;
//单路由最大并发数
private static final int MAX_ROUTE_CONNECTIONS = 2000;
//超时时间
private static final int CONNECT_TIMEOUT = 15000;
private static final int SOCKET_TIMEOUT = 15000;
private static final int CONNECTION_REQUEST_TIMEOUT = 15000;
/*
配置http连接池
*/
static {
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
cm.setMaxTotal(MAX_TOTAL_CONNECTIONS);
cm.setDefaultMaxPerRoute(MAX_ROUTE_CONNECTIONS);
httpClient = HttpClients.custom().setConnectionManager(cm).build();
requestConfig = RequestConfig.custom().setSocketTimeout(SOCKET_TIMEOUT).setConnectTimeout(CONNECT_TIMEOUT)
.setConnectionRequestTimeout(CONNECTION_REQUEST_TIMEOUT).build();
}
/**
* post请求(Map方式)
*
* @param url 请求的url地址 ?之前的地址
* @param params 请求的参数
* @param charset 编码格式
* @return 返回所请求接口的反馈信息
*/
public static String doPost(String url, Map<String, String> params, String charset) {
logger.info(">>>>>>>>>>>>>doPost 请求url：{}，参数：{}，字符编码：{}", url, JSON.toJSONString(params), charset);
if (StringUtils.isBlank(url)) {
return null;
}
HttpPost httpPost = null;
try {
// 使用NameValuePairca格式进行接口请求参数的传递和拼装
List<NameValuePair> pairs = null;
if (params != null && !params.isEmpty()) {
pairs = new ArrayList<>(params.size());
for (Map.Entry<String, String> entry : params.entrySet()) {
String value = entry.getValue();
if (value != null) {
pairs.add(new BasicNameValuePair(entry.getKey(), value));
}
}
}
httpPost = new HttpPost(url);
httpPost.setConfig(requestConfig);
if (pairs != null && pairs.size() > 0) {
httpPost.setEntity(new UrlEncodedFormEntity(pairs, CHARSET));
}
long startTime = System.currentTimeMillis();
CloseableHttpResponse response = httpClient.execute(httpPost);
long endTime = System.currentTimeMillis();
logger.info("{} spend time {} millis", url, (endTime - startTime));
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode != 200) {
httpPost.abort();
throw new RuntimeException("HttpClient,error status code :" + statusCode);
}
HttpEntity entity = response.getEntity();
String result = null;
if (entity != null) {
result = EntityUtils.toString(entity, "utf-8");
}
EntityUtils.consume(entity);
response.close();
logger.info("调用post请求接口，响应结果：{}", result);
return result;
} catch (IOException e) {
httpPost.releaseConnection();
e.printStackTrace();
}
return null;
}
/**
* post请求(NameValuePair方式)
*
* @param url 请求的url地址 ?之前的地址
* @param map 请求的参数
* @param charset 编码格式
* @return 返回所请求接口的反馈信息
*/
public static String doPost(String url, List<NameValuePair> map, String charset, Map<String, String> headerMap) {
logger.info(">>>>>>>>>>>>>doPost 请求url：{}，参数：{}，字符编码：{}，header：{}", url, JSON.toJSONString(map), charset, headerMap);
CloseableHttpResponse response = null;
if (StringUtils.isBlank(url)) {
return null;
}
HttpPost httpPost = null;
try {
httpPost = createHttpPost(url, map);
if (null != headerMap && !headerMap.isEmpty()) {
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpPost.addHeader(entry.getKey(), entry.getValue());
}
}
response = httpClient.execute(httpPost);
String result = acquireResult(response, httpPost);
logger.info("调用post请求接口，响应结果：{}", result);
return result;
}catch (ConnectTimeoutException timeoutException){
logger.error("do post error ", timeoutException);
return "timeOut";
}catch (Exception e) {
logger.error("do post error ", e);
} finally {
close(response);
if (httpPost != null) {
httpPost.releaseConnection();
}
}
return null;
}
/**
* POST请求,参数在url上
*
* @param url 请求url
* @param urlParams url参数
* @param charset 字符编码
* @param headerMap 请求头
* @return String 服务器返回数据
*/
public static String doPost(String url, Map<String, String> urlParams, String charset, Map<String, String> headerMap, RequestConfig requestConfig) {
logger.info(">>>>>>>>>>>>>doPost 请求 url：{}，url参数：{}，字符编码：{}", url, JSON.toJSONString(urlParams), charset);
if (StringUtils.isBlank(url)) {
return null;
}
CloseableHttpResponse response = null;
HttpPost httpPost = null;
try {
url = getString(url, urlParams, charset);
httpPost = new HttpPost(url);
httpPost.setConfig(requestConfig);
if (null != headerMap && !headerMap.isEmpty()) {
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpPost.addHeader(entry.getKey(), entry.getValue());
}
}
response = httpClient.execute(httpPost);
return acquireResult(response, httpPost);
} catch (IOException e) {
if (null != httpPost) {
httpPost.releaseConnection();
}
logger.error("<<<<<<<<<<<<<doPost 请求失败：{}", urlParams, e);
}
logger.info("调用post请求接口，响应结果：{}", response);
return null;
}
private static String getString(String url, Map<String, String> urlParams, String charset) throws IOException {
if (urlParams != null && !urlParams.isEmpty()) {
List<NameValuePair> pairs = new ArrayList<>(urlParams.size());
for (Map.Entry<String, String> entry : urlParams.entrySet()) {
String value = entry.getValue();
if (value != null) {
pairs.add(new BasicNameValuePair(entry.getKey(), value));
}
}
url += "?" + EntityUtils.toString(new UrlEncodedFormEntity(pairs, charset));
}
return url;
}
/**
* Get请求(Map方式)
*
* @param url 请求的url地址 ?之前的地址
* @param params 请求的参数
* @return 返回所请求接口的反馈信息
*/
public static String doGet(String url, Map<String, Object> params, Map<String, String> headerMap) {
logger.info(">>>>>>>>>>>>>doGet 请求 url：{}，参数：{}，字符编码：{}", url, JSON.toJSONString(params), HttpUtils.CHARSET);
if (StringUtils.isBlank(url)) {
return null;
}
HttpGet httpGet = null;
try {
if (params != null && !params.isEmpty()) {
List<NameValuePair> pairs = new ArrayList<>(params.size());
for (Map.Entry<String, Object> entry : params.entrySet()) {
String value = null;
if(!ObjectUtils.isEmpty(entry.getValue())){
value = String.valueOf(entry.getValue());
}
if (value != null) {
pairs.add(new BasicNameValuePair(entry.getKey(), value));
}
}
url += "?" + EntityUtils.toString(new UrlEncodedFormEntity(pairs, HttpUtils.CHARSET));
}
httpGet = new HttpGet(url);
httpGet.setConfig(requestConfig);
if (null != headerMap && !headerMap.isEmpty()) {
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpGet.addHeader(entry.getKey(), entry.getValue());
}
}
//跳过证书认证
CloseableHttpClient httpClient = wrapClient(url, null);
CloseableHttpResponse response = httpClient.execute(httpGet);
int statusCode = response.getStatusLine().getStatusCode();
// if (statusCode != 200) {
// httpGet.abort();
// throw new RuntimeException("HttpClient,error status code :" + statusCode);
// }
HttpEntity entity = response.getEntity();
String result = null;
if (entity != null) {
result = EntityUtils.toString(entity, "utf-8");
}
EntityUtils.consume(entity);
response.close();
logger.info(">>>>>>>>>>>>>doGet 返回：{}", result);
return result;
} catch (IOException e) {
if (null != httpGet) {
httpGet.releaseConnection();
}
logger.error("<<<<<<<<<<<<<doGet 请求失败：{}", params, e);
}
return null;
}
/**
* Get请求(NameValuePair方式)
*
* @param url 请求的url地址 ?之前的地址
* @param params 请求的参数
* @param charset 编码格式
* @return 返回所请求接口的反馈信息
*/
public static String doGet(String url, List<NameValuePair> params, String charset) {
logger.info(">>>>>>>>>>>>>doGet 请求url ：{}，参数：{}，字符编码：{}", url, JSON.toJSONString(params), charset);
CloseableHttpResponse response = null;
if (StringUtils.isBlank(url)) {
return null;
}
HttpGet httpGet = null;
try {
if (params != null && !params.isEmpty()) {
url += "?" + EntityUtils.toString(new UrlEncodedFormEntity(params, charset));
}
httpGet = createHttpGet(url);
response = httpClient.execute(httpGet);
return acquireResult(response, httpGet);
} catch (Exception e) {
logger.error("do get error ", e);
} finally {
close(response);
if (httpGet != null) {
httpGet.releaseConnection();
}
}
logger.info("调用get请求接口，响应结果：{}", response);
return null;
}
public static String doGet(String url, Map<String, Object> params) {
return doGet(url, params, null);
}
public static String doPost(String url, Map<String, String> params) {
return doPost(url, params, CHARSET);
}
/***
* 获取Http Get/Post请求中返回的数据
* @param response 服务器返回response
* @param requestBase HttpGet/HttpPost 对象
*
* @return String 服务器返回数据
* */
private static String acquireResult(CloseableHttpResponse response, HttpRequestBase requestBase) throws IOException {
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode != HttpStatus.SC_OK) {
requestBase.abort();
throw new RuntimeException("HttpClient,error status code :" + statusCode);
}
HttpEntity entity = response.getEntity();
String result = null;
if (entity != null) {
result = EntityUtils.toString(entity, "utf-8");
}
EntityUtils.consume(entity);
return result;
}
private static HttpPost createHttpPost(String url, List<NameValuePair> pairs) {
HttpPost post = new HttpPost(url);
post.setConfig(requestConfig);
try {
if (pairs != null && pairs.size() > 0) {
post.setEntity(new UrlEncodedFormEntity(pairs, CHARSET));
}
} catch (Exception e) {
logger.error("create http post error ", e);
}
return post;
}
private static HttpGet createHttpGet(String url) {
HttpGet get = new HttpGet(url);
get.setConfig(requestConfig);
return get;
}
/**
* 调用post请求接口
*
* @param url 发送的服务器地址
* @param json 请求的json报文
* @return 响应结果JSON对象
*/
public static JSONObject doPostOfJson(String url, JSONObject json) {
return doPostOfJson(url,json,null);
}
public static JSONObject doPostOfJson(String url, JSONObject json,Map<String, String> headerMap) {
logger.info("调用post请求接口，请求地址：{},请求参数Head：{},请求参数：{}", url,JSON.toJSONString(headerMap), json);
CloseableHttpClient httpclient = HttpClientBuilder.create().build();
HttpPost post = new HttpPost(url);
JSONObject response = null;
try {
if (null != headerMap && !headerMap.isEmpty()) {
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
post.addHeader(entry.getKey(), entry.getValue());
}
}
StringEntity httpEntity = new StringEntity(json.toString(), CHARSET);
httpEntity.setContentEncoding("UTF-8");
// //发送json数据需要设置contentType
httpEntity.setContentType("application/json;charset=UTF-8");
post.setEntity(httpEntity);
HttpResponse res = httpclient.execute(post);
logger.info("StatusCode[{}]",res.getStatusLine().getStatusCode());
if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
// 返回json格式：
String result = EntityUtils.toString(res.getEntity(), "utf-8");
response = JSONObject.parseObject(result);
}else {
try {
String result = EntityUtils.toString(res.getEntity(), "utf-8");
logger.info("entity[{}]",result);
response = JSONObject.parseObject(result);
}catch (Exception e){
logger.error(e.getMessage());
}
}
} catch (ConnectTimeoutException timeoutException) {
logger.error(timeoutException.getMessage(), timeoutException);
response = new JSONObject();
response.put("code","timeOut");
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
logger.info("调用post请求接口，响应结果：{}", response);
return response;
}
public static String doPutOfJson(String url, JSONObject json) {
logger.info("调用put请求接口，请求地址：{},请求参数：{}", url, json);
CloseableHttpClient httpclient = HttpClientBuilder.create().build();
HttpPut httpPut = new HttpPut(url);
String resultString = "";
int statusCode = 200;
try {
StringEntity s = new StringEntity(json.toString(), "utf-8");
s.setContentEncoding("UTF-8");
//发送json数据需要设置contentType
s.setContentType("application/json;charset=UTF-8");
httpPut.setEntity(s);
HttpResponse res = httpclient.execute(httpPut);
statusCode = res.getStatusLine().getStatusCode();
// 返回json格式：
resultString = EntityUtils.toString(res.getEntity(), "utf-8");
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
logger.info("调用put请求接口，HTTP状态码：{}，响应结果：{}", statusCode, resultString);
return resultString;
}
public static String doPostString(String url, JSONObject json) {
logger.info("调用post请求接口，请求地址：{},请求参数：{}", url, json);
CloseableHttpClient httpclient = HttpClientBuilder.create().build();
HttpPost post = new HttpPost(url);
String response = null;
int statusCode = 200;
try {
StringEntity s = new StringEntity(json.toString(), "utf-8");
s.setContentEncoding("UTF-8");
//发送json数据需要设置contentType
s.setContentType("application/json;charset=UTF-8");
post.setEntity(s);
HttpResponse res = httpclient.execute(post);
statusCode = res.getStatusLine().getStatusCode();
// 返回json格式：
response = EntityUtils.toString(res.getEntity(), "utf-8");
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
logger.info("调用put请求接口，HTTP状态码：{}，响应结果：{}", statusCode, response);
return response;
}
public static JSONObject doPostWithHeader(String url, String json, Map<String, String> headerMap) {
logger.info("调用post请求接口，请求地址：{},请求参数：{}", url, json);
CloseableHttpClient httpclient = HttpClientBuilder.create().build();
HttpPost post = new HttpPost(url);
JSONObject response = null;
try {
StringEntity s = new StringEntity(json, "UTF-8");
s.setContentEncoding("UTF-8");
s.setContentType("application/json;charset=utf-8");
post.setEntity(s);
if (null != headerMap && !headerMap.isEmpty()) {
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
post.addHeader(entry.getKey(), entry.getValue());
}
}
HttpResponse res = httpclient.execute(post);
if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
String result = EntityUtils.toString(res.getEntity());
response = JSONObject.parseObject(result);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
logger.info("调用post请求接口，响应结果：{}", response);
return response;
}
public static String doDelete(String url, Map<String, Object> params) {
logger.info(">>>>>>>>>>>>>doDelete 请求 url：{}，参数：{}，字符编码：{}", url, JSON.toJSONString(params), HttpUtils.CHARSET);
if (StringUtils.isBlank(url)) {
return null;
}
HttpDelete httpDelete = null;
try {
if (params != null && !params.isEmpty()) {
List<NameValuePair> pairs = new ArrayList<>(params.size());
for (Map.Entry<String, Object> entry : params.entrySet()) {
String value = (String) entry.getValue();
if (value != null) {
pairs.add(new BasicNameValuePair(entry.getKey(), value));
}
}
url += "?" + EntityUtils.toString(new UrlEncodedFormEntity(pairs, HttpUtils.CHARSET));
}
httpDelete = new HttpDelete(url);
httpDelete.setConfig(requestConfig);
CloseableHttpResponse response = httpClient.execute(httpDelete);
int statusCode = response.getStatusLine().getStatusCode();
HttpEntity entity = response.getEntity();
String result = null;
if (entity != null) {
result = EntityUtils.toString(entity, "utf-8");
}
EntityUtils.consume(entity);
response.close();
logger.info(">>>>>>>>>>>>>doDelete HTTP状态码：{}， 返回：{}", statusCode, result);
return result;
} catch (IOException e) {
if (null != httpDelete) {
httpDelete.releaseConnection();
}
logger.error("<<<<<<<<<<<<<doDelete 请求失败：{}", params, e);
}
return null;
}
/**
* 创建一个用于basic auth验证的请求头
*
* @param headerMap 请求头
* @param username 用户名
* @param password 密码
* @return map
*/
public static Map<String, String> createBasicAuthHeader(Map<String, String> headerMap,
String username, String password) {
if (MapUtils.isEmpty(headerMap)) {
headerMap = new HashMap<>();
}
headerMap.put("Authorization", "Basic " + Base64
.getUrlEncoder().encodeToString((username + ":" + password).getBytes()));
return headerMap;
}
public static void close(Closeable closeable) {
if (null != closeable) {
try {
closeable.close();
} catch (IOException var2) {
logger.error("Close closeable faild: " + closeable.getClass(), var2);
}
}
}
/**
* @param url
* @param jsonString
* @param charset
* @param headerMap
* @return java.lang.String
* @Author huo
* @Description json格式post
* @Date 14:57 2021/7/7
**/
public static String post(String url, String jsonString, String charset, Map<String, String> headerMap) {
logger.info(">>>>>>>>>>>>>doPost 请求url：{}，参数：{}，字符编码：{}，header：{}", url, jsonString, charset, headerMap);
CloseableHttpResponse response = null;
BufferedReader in = null;
String result = "";
HttpPost httpPost = null;
try {
//跳过证书认证
CloseableHttpClient httpClient = wrapClient(url, null);
httpPost = new HttpPost(url);
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(30000).setConnectionRequestTimeout(30000).setSocketTimeout(30000).build();
httpPost.setConfig(requestConfig);
httpPost.setConfig(requestConfig);
if (null != headerMap && !headerMap.isEmpty()) {
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpPost.addHeader(entry.getKey(), entry.getValue());
}
}
httpPost.setEntity(new StringEntity(jsonString, Charset.forName(charset)));
response = httpClient.execute(httpPost);
result = acquireResult(response, httpPost);
logger.info("调用post请求接口，响应结果：{}", result);
return result;
} catch (IOException e) {
e.printStackTrace();
} finally {
close(response);
if (httpPost != null) {
httpPost.releaseConnection();
}
}
return null;
}
/**
* @param urlStr
* @param textMap
* @param fileMap
* @param headersMaps
* @param contentType
* @return java.lang.String
* @Author huo
* @Description 文件上传
* @Date 10:49 2021/7/8
**/
@SuppressWarnings("rawtypes")
public static String formUpload(String urlStr, Map<String, String> textMap,
Map<String, String> fileMap, Map<String, String> headersMaps, String contentType) {
logger.info(">>>>>>>>>>>>>doPost 请求url：{}，参数：{}，文件参数：{}，contentType：{}，header：{}", urlStr, JSON.toJSONString(textMap), JSON.toJSONString(fileMap), contentType, JSON.toJSONString(headersMaps));
String res = "";
HttpURLConnection conn = null;
// boundary就是request头和上传文件内容的分隔符
String BOUNDARY = "---------------------------123821742118716";
try {
//该部分必须在获取connection前调用 java访问https资源时,忽略证书信任问题
trustAllHttpsCertificates();
HostnameVerifier hv = new HostnameVerifier() {
@Override
public boolean verify(String urlHostName, SSLSession session) {
logger.info("Warning: URL Host: " + urlHostName + " vs. " + session.getPeerHost());
return true;
}
};
HttpsURLConnection.setDefaultHostnameVerifier(hv);
URL url = new URL(urlStr);
conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5000);
conn.setReadTimeout(30000);
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
conn.setRequestMethod("POST");
conn.setRequestProperty("Connection", "Keep-Alive");
// conn.setRequestProperty("User-Agent","Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN; rv:1.9.2.6)");
conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + BOUNDARY);
HttpURLConnection finalConn = conn;
headersMaps.forEach((k, v) -> {
finalConn.setRequestProperty(k, v);
});
OutputStream out = new DataOutputStream(conn.getOutputStream());
// text
if (textMap != null) {
StringBuffer strBuf = new StringBuffer();
Iterator iter = textMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
String inputName = (String) entry.getKey();
String inputValue = (String) entry.getValue();
if (inputValue == null) {
continue;
}
strBuf.append("\r\n").append("--").append(BOUNDARY).append("\r\n");
strBuf.append("Content-Disposition: form-data; name=\"" + inputName + "\"\r\n\r\n");
strBuf.append(inputValue);
}
out.write(strBuf.toString().getBytes());
}
// file
if (fileMap != null && !fileMap.isEmpty()) {
Iterator iter = fileMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
String inputName = (String) entry.getKey();
String inputValue = (String) entry.getValue();
if (inputValue == null) {
continue;
}
File file = new File(inputValue);
String filename = file.getName();
//没有传入文件类型，同时根据文件获取不到类型，默认采用application/octet-stream
contentType = new MimetypesFileTypeMap().getContentType(file);
//contentType非空采用filename匹配默认的图片类型
if (!"".equals(contentType)) {
if (filename.endsWith(".png")) {
contentType = "image/png";
} else if (filename.endsWith(".jpg") || filename.endsWith(".jpeg") || filename.endsWith(".jpe")) {
contentType = "image/jpeg";
} else if (filename.endsWith(".gif")) {
contentType = "image/gif";
} else if (filename.endsWith(".ico")) {
contentType = "image/image/x-icon";
}
}
if (contentType == null || "".equals(contentType)) {
contentType = "application/octet-stream";
}
StringBuffer strBuf = new StringBuffer();
strBuf.append("\r\n").append("--").append(BOUNDARY).append("\r\n");
strBuf.append("Content-Disposition: form-data; name=\"" + inputName + "\"; filename=\"" + filename + "\"\r\n");
strBuf.append("Content-Type:" + contentType + "\r\n\r\n");
out.write(strBuf.toString().getBytes());
DataInputStream in = new DataInputStream(new FileInputStream(file));
int bytes = 0;
byte[] bufferOut = new byte[1024];
while ((bytes = in.read(bufferOut)) != -1) {
out.write(bufferOut, 0, bytes);
}
in.close();
}
}
byte[] endData = ("\r\n--" + BOUNDARY + "--\r\n").getBytes();
out.write(endData);
out.flush();
out.close();
// 读取返回数据
StringBuffer strBuf = new StringBuffer();
BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line = null;
while ((line = reader.readLine()) != null) {
// strBuf.append(line).append("\n");
strBuf.append(line);
}
res = strBuf.toString();
logger.info("调用post请求接口，响应结果：{}", res);
reader.close();
reader = null;
} catch (Exception e) {
System.out.println("发送POST请求出错。" + urlStr);
e.printStackTrace();
} finally {
if (conn != null) {
conn.disconnect();
conn = null;
}
}
return res;
}
public static Map<String,Object> doGetFile(String url, Map<String, Object> params, Map<String, String> headerMap) {
logger.info(">>>>>>>>>>>>>doGetFile 请求 url：{}，参数：{}，字符编码：{}", url, JSON.toJSONString(params), HttpUtils.CHARSET);
if (StringUtils.isBlank(url)) {
return null;
}
HttpGet httpGet = null;
try {
if (params != null && !params.isEmpty()) {
List<NameValuePair> pairs = new ArrayList<>(params.size());
for (Map.Entry<String, Object> entry : params.entrySet()) {
String value = String.valueOf(entry.getValue());
if (value != null) {
pairs.add(new BasicNameValuePair(entry.getKey(), value));
}
}
url += "?" + EntityUtils.toString(new UrlEncodedFormEntity(pairs, HttpUtils.CHARSET));
}
//跳过证书认证
CloseableHttpClient httpClient = wrapClient(url, null);
httpGet = new HttpGet(url);
httpGet.setConfig(requestConfig);
if (null != headerMap && !headerMap.isEmpty()) {
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpGet.addHeader(entry.getKey(), entry.getValue());
}
}
CloseableHttpResponse response = httpClient.execute(httpGet);
HttpEntity entity = response.getEntity();
String fileName = getFileName(response);
logger.info(">>>>>>>>>>>>>doGetFile[{}] 请求成功",fileName);
Map<String,Object> rspMap = new HashMap<>();
rspMap.put("fileName",fileName);
rspMap.put("fileInputStream",entity.getContent());
return rspMap;
} catch (IOException e) {
if (null != httpGet) {
httpGet.releaseConnection();
}
logger.error("<<<<<<<<<<<<<doGet 请求失败：{}", params, e);
}
return null;
}
/**
* 获取response header中Content-Disposition中的filename值
*
* @param response
* @return
*/
public static String getFileName(HttpResponse response) {
Header contentHeader = response.getFirstHeader("Content-Disposition");
String filename = null;
if (contentHeader != null) {
HeaderElement[] values = contentHeader.getElements();
if (values.length == 1) {
NameValuePair param = values[0].getParameterByName("filename");
if (param != null) {
try {
//filename = new String(param.getValue().toString().getBytes(), "utf-8");
//filename=URLDecoder.decode(param.getValue(),"utf-8");
filename = param.getValue();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
return filename;
}
/**
* 获取 HttpClient
*
* @param host
* @param path
* @return
*/
private static CloseableHttpClient wrapClient(String host, String path) {
CloseableHttpClient httpClient = HttpClientBuilder.create().build();
if (host != null && host.startsWith("https://")) {
return sslClient();
} else if (StringUtils.isBlank(host) && path != null && path.startsWith("https://")) {
return sslClient();
}
return httpClient;
}
/**
* 在调用SSL之前需要重写验证方法，取消检测SSL
* 创建ConnectionManager，添加Connection配置信息
*
* @return HttpClient 支持https
*/
private static CloseableHttpClient sslClient() {
try {
// 在调用SSL之前需要重写验证方法，取消检测SSL
X509TrustManager trustManager = new X509TrustManager() {
@Override
public X509Certificate[] getAcceptedIssuers() {
return null;
}
@Override
public void checkClientTrusted(X509Certificate[] xcs, String str) {
}
@Override
public void checkServerTrusted(X509Certificate[] xcs, String str) {
}
};
SSLContext ctx = SSLContext.getInstance(SSLConnectionSocketFactory.TLS);
ctx.init(null, new TrustManager[]{trustManager}, null);
SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(ctx, NoopHostnameVerifier.INSTANCE);
// 创建Registry
RequestConfig requestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT)
.setExpectContinueEnabled(Boolean.TRUE).setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM, AuthSchemes.DIGEST))
.setProxyPreferredAuthSchemes(Arrays.asList(AuthSchemes.BASIC)).build();
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.INSTANCE)
.register("https", socketFactory).build();
// 创建ConnectionManager，添加Connection配置信息
PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
CloseableHttpClient closeableHttpClient = HttpClients.custom().setConnectionManager(connectionManager)
.setDefaultRequestConfig(requestConfig).build();
return closeableHttpClient;
} catch (KeyManagementException ex) {
throw new RuntimeException(ex);
} catch (NoSuchAlgorithmException ex) {
throw new RuntimeException(ex);
}
}
private static void trustAllHttpsCertificates() throws Exception {
TrustManager[] trustAllCerts = new TrustManager[1];
TrustManager tm = new miTM();
trustAllCerts[0] = tm;
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCerts, null);
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
}
static class miTM implements TrustManager, X509TrustManager {
@Override
public X509Certificate[] getAcceptedIssuers() {
return null;
}
public boolean isServerTrusted(X509Certificate[] certs) {
return true;
}
public boolean isClientTrusted(X509Certificate[] certs) {
return true;
}
@Override
public void checkServerTrusted(X509Certificate[] certs, String authType)
throws java.security.cert.CertificateException {
return;
}
@Override
public void checkClientTrusted(X509Certificate[] certs, String authType)
throws java.security.cert.CertificateException {
return;
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
