package com.project.common.utils.http;
|
|
import com.alibaba.fastjson2.JSON;
|
import com.project.common.constant.Constants;
|
import com.project.common.utils.SslUtils;
|
import com.project.common.utils.StringUtils;
|
import org.apache.http.HttpEntity;
|
import org.apache.http.HttpResponse;
|
import org.apache.http.client.HttpClient;
|
import org.apache.http.client.config.RequestConfig;
|
import org.apache.http.client.methods.*;
|
import org.apache.http.client.protocol.HttpClientContext;
|
import org.apache.http.conn.ssl.NoopHostnameVerifier;
|
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
|
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
|
import org.apache.http.entity.StringEntity;
|
import org.apache.http.impl.client.CloseableHttpClient;
|
import org.apache.http.impl.client.HttpClients;
|
import org.apache.http.protocol.HttpContext;
|
import org.apache.http.ssl.SSLContexts;
|
import org.apache.http.util.EntityUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import javax.net.ssl.*;
|
import java.io.*;
|
import java.net.*;
|
import java.nio.charset.Charset;
|
import java.nio.charset.StandardCharsets;
|
import java.security.cert.X509Certificate;
|
import java.util.Map;
|
|
/**
|
* 通用http发送方法
|
*
|
* @author manton
|
*/
|
public class HttpUtils
|
{
|
private static final Logger log = LoggerFactory.getLogger(HttpUtils.class);
|
|
/**
|
* 向指定 URL 发送GET方法的请求
|
*
|
* @param url 发送请求的 URL
|
* @return 所代表远程资源的响应结果
|
*/
|
public static String sendGet(String url)
|
{
|
return sendGet(url, StringUtils.EMPTY);
|
}
|
|
/**
|
* 向指定 URL 发送GET方法的请求
|
*
|
* @param url 发送请求的 URL
|
* @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
|
* @return 所代表远程资源的响应结果
|
*/
|
public static String sendGet(String url, String param)
|
{
|
return sendGet(url, param, Constants.UTF8);
|
}
|
|
/**
|
* 向指定 URL 发送GET方法的请求
|
*
|
* @param url 发送请求的 URL
|
* @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
|
* @param contentType 编码类型
|
* @return 所代表远程资源的响应结果
|
*/
|
public static String sendGet(String url, String param, String contentType)
|
{
|
try {
|
SslUtils.ignoreSsl();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
StringBuilder result = new StringBuilder();
|
BufferedReader in = null;
|
try
|
{
|
String urlNameString = StringUtils.isNotBlank(param) ? url + "?" + param : url;
|
log.info("sendGet - {}", urlNameString);
|
URL realUrl = new URL(urlNameString);
|
URLConnection connection = realUrl.openConnection();
|
connection.setRequestProperty("accept", "*/*");
|
connection.setRequestProperty("connection", "Keep-Alive");
|
connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
|
connection.connect();
|
in = new BufferedReader(new InputStreamReader(connection.getInputStream(), contentType));
|
String line;
|
while ((line = in.readLine()) != null)
|
{
|
result.append(line);
|
}
|
log.info("recv - {}", result);
|
}
|
catch (ConnectException e)
|
{
|
log.error("调用HttpUtils.sendGet ConnectException, url=" + url + ",param=" + param, e);
|
}
|
catch (SocketTimeoutException e)
|
{
|
log.error("调用HttpUtils.sendGet SocketTimeoutException, url=" + url + ",param=" + param, e);
|
}
|
catch (IOException e)
|
{
|
log.error("调用HttpUtils.sendGet IOException, url=" + url + ",param=" + param, e);
|
}
|
catch (Exception e)
|
{
|
log.error("调用HttpsUtil.sendGet Exception, url=" + url + ",param=" + param, e);
|
}
|
finally
|
{
|
try
|
{
|
if (in != null)
|
{
|
in.close();
|
}
|
}
|
catch (Exception ex)
|
{
|
log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
|
}
|
}
|
return result.toString();
|
}
|
|
/**
|
* 向指定 URL 发送POST方法的请求
|
*
|
* @param url 发送请求的 URL
|
* @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
|
* @return 所代表远程资源的响应结果
|
*/
|
public static String sendPost(String url, String param)
|
{
|
PrintWriter out = null;
|
BufferedReader in = null;
|
StringBuilder result = new StringBuilder();
|
try
|
{
|
log.info("sendPost - {}", url);
|
URL realUrl = new URL(url);
|
URLConnection conn = realUrl.openConnection();
|
conn.setRequestProperty("accept", "*/*");
|
conn.setRequestProperty("connection", "Keep-Alive");
|
conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
|
conn.setRequestProperty("Accept-Charset", "utf-8");
|
conn.setRequestProperty("contentType", "utf-8");
|
conn.setDoOutput(true);
|
conn.setDoInput(true);
|
out = new PrintWriter(conn.getOutputStream());
|
out.print(param);
|
out.flush();
|
in = new BufferedReader(new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8));
|
String line;
|
while ((line = in.readLine()) != null)
|
{
|
result.append(line);
|
}
|
log.info("recv - {}", result);
|
}
|
catch (ConnectException e)
|
{
|
log.error("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param, e);
|
}
|
catch (SocketTimeoutException e)
|
{
|
log.error("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param, e);
|
}
|
catch (IOException e)
|
{
|
log.error("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param, e);
|
}
|
catch (Exception e)
|
{
|
log.error("调用HttpsUtil.sendPost Exception, url=" + url + ",param=" + param, e);
|
}
|
finally
|
{
|
try
|
{
|
if (out != null)
|
{
|
out.close();
|
}
|
if (in != null)
|
{
|
in.close();
|
}
|
}
|
catch (IOException ex)
|
{
|
log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
|
}
|
}
|
return result.toString();
|
}
|
|
public static String sendSSLPost(String httpUrl, String param)
|
{
|
HttpURLConnection connection = null;
|
InputStream is = null;
|
OutputStream os = null;
|
BufferedReader br = null;
|
String result = null;
|
try {
|
URL url = new URL(httpUrl);
|
if("https".equalsIgnoreCase(url.getProtocol())){
|
SslUtils.ignoreSsl();
|
}
|
// 通过远程url连接对象打开连接
|
connection = (HttpURLConnection) url.openConnection();
|
// 设置连接请求方式
|
connection.setRequestMethod("POST");
|
// 设置连接主机服务器超时时间：15000毫秒
|
connection.setConnectTimeout(15000);
|
// 设置读取主机服务器返回数据超时时间：60000毫秒
|
connection.setReadTimeout(60000);
|
// 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
|
connection.setDoOutput(true);
|
// 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
|
connection.setDoInput(true);
|
// 设置传入参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
|
connection.setRequestProperty("Content-Type", "application/json");
|
// 建立连接
|
connection.connect();
|
// 通过连接对象获取一个输出流对象
|
OutputStreamWriter writer = new OutputStreamWriter(connection.getOutputStream(),"UTF-8");
|
writer.write(param);
|
writer.flush();
|
// 通过连接对象获取一个输入流，向远程读取
|
if (connection.getResponseCode() == 200) {
|
is = connection.getInputStream();
|
// 对输入流对象进行包装:charset根据工作项目组的要求来设置
|
br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
|
StringBuffer sbf = new StringBuffer();
|
String temp = null;
|
// 循环遍历一行一行读取数据
|
while ((temp = br.readLine()) != null) {
|
sbf.append(temp);
|
sbf.append("\r");
|
}
|
result = sbf.toString();
|
}
|
} catch (MalformedURLException e) {
|
e.printStackTrace();
|
} catch (IOException e) {
|
e.printStackTrace();
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
} finally {
|
// 关闭资源
|
if (null != br) {
|
try {
|
br.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
if (null != os) {
|
try {
|
os.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
if (null != is) {
|
try {
|
is.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
// 断开与远程地址url的连接
|
connection.disconnect();
|
}
|
return result;
|
}
|
|
private static class TrustAnyTrustManager implements X509TrustManager
|
{
|
@Override
|
public void checkClientTrusted(X509Certificate[] chain, String authType)
|
{
|
}
|
|
@Override
|
public void checkServerTrusted(X509Certificate[] chain, String authType)
|
{
|
}
|
|
@Override
|
public X509Certificate[] getAcceptedIssuers()
|
{
|
return new X509Certificate[] {};
|
}
|
}
|
|
private static class TrustAnyHostnameVerifier implements HostnameVerifier
|
{
|
@Override
|
public boolean verify(String hostname, SSLSession session)
|
{
|
return true;
|
}
|
}
|
|
|
public static String callPostServices(String url, Map<String, Object> objects, Map<String, String> header) {
|
return HttpUtils.callPostServices(url, objects, header, "UTF-8");
|
}
|
|
/**
|
* httpPost 请求
|
* @param url 地址
|
* @param reqPqrams 请求参数
|
* @param header 请求头
|
* @param responseCharset 返回数据编码
|
* @return
|
*/
|
public static String callPostServices(String url, Map<String, Object> reqPqrams, Map<String, String> header, String responseCharset) {
|
String result = "";
|
HttpClient httpClient = getHttpClient(url);
|
HttpEntityEnclosingRequestBase method = null;
|
HttpEntity httpEntity = null;
|
try {
|
method = (HttpEntityEnclosingRequestBase) getHttpRequest(url, HttpPost.METHOD_NAME, header);
|
method.setEntity(new StringEntity(reqPqrams == null ? "" : JSON.toJSONString(reqPqrams), Charset.forName(responseCharset)));
|
HttpContext context = HttpClientContext.create();
|
HttpResponse httpResponse = httpClient.execute(method, context);
|
httpEntity = httpResponse.getEntity();
|
if (httpEntity != null) {
|
result = EntityUtils.toString(httpEntity, responseCharset);
|
}
|
} catch (Exception e) {
|
if(method != null){
|
try {
|
method.abort();
|
} catch (Exception e2) {}
|
}
|
log.error("callPostServicesStringEntity Exception", e);
|
} finally {
|
if (httpEntity != null) {
|
try {
|
EntityUtils.consumeQuietly(httpEntity);
|
} catch (Exception e) {}
|
}
|
}
|
return result;
|
}
|
|
private static HttpClient getHttpClient(String url) {
|
HttpClient client = null;
|
if (url.startsWith("https")) {
|
try {
|
client = createHttpsClient();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
} else {
|
client = HttpClients.createDefault();
|
}
|
return client;
|
}
|
|
private static HttpRequestBase getHttpRequest(String url, String methodName, Map<String, String> headMap) {
|
HttpRequestBase method = null;
|
if (HttpPut.METHOD_NAME.equalsIgnoreCase(methodName)) {
|
method = new HttpPut(url);
|
} else if (HttpPost.METHOD_NAME.equalsIgnoreCase(methodName)) {
|
method = new HttpPost(url);
|
} else if (HttpGet.METHOD_NAME.equalsIgnoreCase(methodName)) {
|
method = new HttpGet(url);
|
} else if (HttpDelete.METHOD_NAME.equalsIgnoreCase(methodName)) {
|
method = new HttpDelete(url);
|
} else {
|
method = new HttpPost(url);
|
}
|
int timeOut = 30;
|
if(headMap != null){
|
for(Map.Entry<String, String> entry : headMap.entrySet()){
|
if ("timeout".equals(entry.getKey())) {
|
try {
|
timeOut = Integer.parseInt(entry.getValue().trim());
|
} catch (Exception e) {}
|
} else {
|
method.addHeader(entry .getKey(), entry .getValue());
|
}
|
}
|
}
|
RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeOut * 1000).setConnectTimeout(timeOut * 1000)
|
.setConnectionRequestTimeout(timeOut * 1000).setExpectContinueEnabled(false).build();
|
|
method.setConfig(requestConfig);
|
return method;
|
}
|
|
private static CloseableHttpClient createHttpsClient() throws Exception {
|
SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(null,
|
new TrustSelfSignedStrategy()).build();
|
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext,
|
new String[]{"TLSv1.2", "TLSv1.1", "TLSv1", "SSLv3"}, null, new NoopHostnameVerifier());
|
CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
|
return httpClient;
|
}
|
}
|
