package org.ruoyi.system.util;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import org.apache.commons.io.IOUtils;
|
import org.apache.http.Header;
|
import org.apache.http.HttpEntity;
|
import org.apache.http.HttpEntityEnclosingRequest;
|
import org.apache.http.client.HttpClient;
|
import org.apache.http.client.config.RequestConfig;
|
import org.apache.http.client.methods.*;
|
import org.apache.http.config.Registry;
|
import org.apache.http.config.RegistryBuilder;
|
import org.apache.http.conn.socket.ConnectionSocketFactory;
|
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
|
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
|
import org.apache.http.entity.*;
|
import org.apache.http.impl.client.HttpClients;
|
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
|
|
import javax.net.ssl.SSLContext;
|
import javax.net.ssl.X509TrustManager;
|
import java.io.*;
|
import java.net.HttpURLConnection;
|
import java.net.SocketException;
|
import java.net.URL;
|
import java.net.URLEncoder;
|
import java.nio.charset.StandardCharsets;
|
import java.security.SecureRandom;
|
import java.security.cert.X509Certificate;
|
import java.util.*;
|
import java.util.concurrent.*;
|
import java.util.concurrent.atomic.AtomicInteger;
|
import java.util.function.Consumer;
|
import java.util.function.Function;
|
|
/**
|
* HttpUtils
|
*
|
* @author NSL
|
* @since 2024-12-30
|
*/
|
public class HttpUtils {
|
|
public static final String CHARSET_DEFAULT = "UTF-8";
|
public static final String CONTENT_TYPE = "Content-Type";
|
public static final String CONTENT_TYPE_JSON = "application/json";
|
public static final String CONTENT_TYPE_FORM_DATA = "application/x-www-form-urlencoded";
|
private static final PoolingHttpClientConnectionManager CONNECTION_MANAGER;
|
private static final int MAX_CONNECT_TIMEOUT = 8000;
|
private static final int MAX_SOCKET_TIMEOUT = 90000;
|
|
static {
|
CONNECTION_MANAGER = new PoolingHttpClientConnectionManager(getDefaultRegistry());
|
CONNECTION_MANAGER.setMaxTotal(500);
|
CONNECTION_MANAGER.setDefaultMaxPerRoute(50);
|
CONNECTION_MANAGER.setValidateAfterInactivity(2000);
|
}
|
|
public static HttpResponse get(String url) {
|
return get(url, null);
|
}
|
|
public static HttpResponse get(String url, Map<String, Object> params) {
|
String urlLinks = getUrlLinks(params);
|
if (urlLinks != null) {
|
if (url.contains("?")) {
|
url = url + "&" + urlLinks;
|
} else {
|
url = url + "?" + urlLinks;
|
}
|
}
|
return request(HttpRequest.build(url, "GET"));
|
}
|
|
public static void download(String url, File destFile) throws Exception {
|
HttpRequest request = HttpRequest.build(url, "GET");
|
request.setResponseHandler(entity -> {
|
try {
|
if (!destFile.getParentFile().exists()) {
|
destFile.getParentFile().mkdirs();
|
}
|
try (FileOutputStream fs = new FileOutputStream(destFile)) {
|
entity.writeTo(fs);
|
}
|
return destFile;
|
} catch (Exception e) {
|
return e;
|
}
|
});
|
HttpResponse response = request(request);
|
if (response.getResponse() instanceof Exception) {
|
throw (Exception) response.getResponse();
|
}
|
}
|
|
public static HttpResponse postJson(String url, String bodyJson) {
|
HttpRequest request = HttpRequest.build(url, "POST").setBody(bodyJson);
|
if (request.getHeaders() == null) {
|
request.setHeaders(Collections.singletonMap(CONTENT_TYPE, CONTENT_TYPE_JSON));
|
} else {
|
request.getHeaders().put(CONTENT_TYPE, CONTENT_TYPE_JSON);
|
}
|
return request(request);
|
}
|
|
public static HttpResponse postForm(String url, Map<String, Object> params) {
|
String urlLinks = getUrlLinks(params);
|
HttpRequest request = HttpRequest.build(url, "POST").setBody(urlLinks != null ? urlLinks : "");
|
if (request.getHeaders() == null) {
|
request.setHeaders(Collections.singletonMap(CONTENT_TYPE, CONTENT_TYPE_FORM_DATA));
|
} else {
|
request.getHeaders().put(CONTENT_TYPE, CONTENT_TYPE_FORM_DATA);
|
}
|
return request(request);
|
}
|
|
public static HttpResponse requestWithEventStream(ExecutorService executorService, long firstReadTimeout, HttpRequest request, Consumer<String> dataConsumer) throws ExecutionException, InterruptedException, TimeoutException {
|
return requestWithEventStream(executorService, firstReadTimeout, request, dataConsumer, null);
|
}
|
|
public static HttpResponse requestWithEventStream(ExecutorService executorService, long firstReadTimeout, HttpRequest request, Consumer<String> dataConsumer, Consumer<Future<?>> futureConsumer) throws ExecutionException, InterruptedException, TimeoutException {
|
// status: 0 start 1 run 2 timeout
|
AtomicInteger status = new AtomicInteger(0);
|
Future<HttpResponse> submit = executorService.submit(() -> {
|
if (request.getMaxSocketTimeout() == null) {
|
request.setMaxSocketTimeout(30_000);
|
}
|
request.setResponseHandler(entity -> {
|
StringBuilder sb = new StringBuilder();
|
try {
|
try (InputStream is = entity.getContent()) {
|
try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
|
String line;
|
while ((line = bufferedReader.readLine()) != null) {
|
if (status.get() == 2) {
|
throw new TimeoutException();
|
}
|
status.set(1);
|
sb.append(line).append("\n");
|
if (line.startsWith("data:")) {
|
dataConsumer.accept(line.substring(line.startsWith("data: ") ? 6 : 5));
|
}
|
}
|
}
|
}
|
} catch (Exception e) {
|
throw new RuntimeException("eventStream 请求异常", e);
|
}
|
return sb.toString();
|
});
|
return request(request);
|
});
|
if (futureConsumer != null) {
|
futureConsumer.accept(submit);
|
}
|
try {
|
HttpResponse httpResponse = submit.get(firstReadTimeout, TimeUnit.MILLISECONDS);
|
if (httpResponse != null) {
|
return httpResponse;
|
}
|
} catch (TimeoutException e) {
|
if (status.get() == 0) {
|
status.set(2);
|
submit.cancel(true);
|
throw e;
|
}
|
}
|
return submit.get();
|
}
|
|
public static HttpResponse requestWithEventStream(HttpRequest request, Consumer<String> dataConsumer) {
|
if (request.getMaxSocketTimeout() == null) {
|
request.setMaxSocketTimeout(30_000);
|
}
|
request.setResponseHandler(entity -> {
|
StringBuilder sb = new StringBuilder();
|
try {
|
try (InputStream is = entity.getContent()) {
|
try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
|
String line;
|
while ((line = bufferedReader.readLine()) != null) {
|
sb.append(line).append("\n");
|
if (line.startsWith("data:")) {
|
dataConsumer.accept(line.substring(line.startsWith("data: ") ? 6 : 5));
|
}
|
}
|
}
|
}
|
} catch (Exception e) {
|
throw new RuntimeException("eventStream 请求异常", e);
|
}
|
return sb.toString();
|
});
|
return request(request);
|
}
|
|
public static int getUrlHttpStatus(String _url) {
|
HttpURLConnection urlConnection = null;
|
try {
|
URL url = new URL(_url);
|
urlConnection = (HttpURLConnection) url.openConnection();
|
urlConnection.connect();
|
return urlConnection.getResponseCode();
|
} catch (Exception ignored) {
|
return -1;
|
} finally {
|
if (urlConnection != null) {
|
urlConnection.disconnect();
|
}
|
}
|
}
|
|
public static String getUrlLinks(Map<String, Object> params) {
|
if (params == null || params.isEmpty()) {
|
return null;
|
}
|
StringBuilder sb = new StringBuilder();
|
try {
|
String[] sortedKeys = params.keySet().toArray(new String[0]);
|
Arrays.sort(sortedKeys);
|
for (String key : sortedKeys) {
|
if (key == null || key.isEmpty()) {
|
continue;
|
}
|
Object value = params.get(key);
|
sb.append(key).append("=");
|
if (value != null) {
|
sb.append(URLEncoder.encode(value.toString(), "UTF-8"));
|
}
|
sb.append("&");
|
}
|
} catch (UnsupportedEncodingException e) {
|
throw new RuntimeException(e);
|
}
|
if (sb.length() > 0) {
|
sb.setLength(sb.length() - 1);
|
}
|
return sb.toString();
|
}
|
|
@SuppressWarnings("unchecked")
|
public static Map<String, Object> parseUrlLinks(String params) {
|
Map<String, Object> result = new LinkedHashMap<>();
|
if (params == null || params.isEmpty()) {
|
return result;
|
}
|
for (String param : params.split("&")) {
|
String[] split = param.split("=");
|
String key = split[0];
|
String value = "";
|
if (split.length > 1) {
|
value = split[1];
|
}
|
if (result.containsKey(key)) {
|
Object o = result.get(key);
|
if (o instanceof List) {
|
((List<Object>) o).add(value);
|
} else {
|
List<Object> list = new ArrayList<>();
|
list.add(o);
|
list.add(value);
|
result.put(key, list);
|
}
|
} else {
|
result.put(key, value);
|
}
|
}
|
return result;
|
}
|
|
/**
|
* 通用接口请求
|
*/
|
public static HttpResponse request(HttpRequest request) {
|
return request(request, 0);
|
}
|
|
private static HttpResponse request(HttpRequest request, int retryCount) {
|
HttpRequestBase requestBase = toRequest(request);
|
Map<String, String> headers = request.getHeaders();
|
ContentType contentType = null;
|
if (headers != null && !headers.isEmpty()) {
|
for (Map.Entry<String, String> entry : headers.entrySet()) {
|
String key = entry.getKey();
|
if (key == null || key.isEmpty()) {
|
continue;
|
}
|
String value = entry.getValue();
|
if (CONTENT_TYPE.equalsIgnoreCase(key) && value != null) {
|
contentType = ContentType.parse(value);
|
}
|
requestBase.setHeader(key, value);
|
}
|
}
|
|
// body
|
setBodyEntity(requestBase, contentType, request.getBody());
|
|
try {
|
HttpClient client = getHttpClient(request, requestBase);
|
org.apache.http.HttpResponse response;
|
long startTime = System.currentTimeMillis();
|
response = client.execute(requestBase);
|
HttpResponse httpResponse = new HttpResponse();
|
httpResponse.setReqTime(System.currentTimeMillis() - startTime);
|
httpResponse.setStatus(response.getStatusLine().getStatusCode());
|
Header[] allHeaders = response.getAllHeaders();
|
if (allHeaders != null && allHeaders.length > 0) {
|
httpResponse.setHeaders(new HashMap<>());
|
for (Header header : allHeaders) {
|
httpResponse.getHeaders().put(header.getName(), header.getValue());
|
}
|
}
|
HttpEntity entity = response.getEntity();
|
if (request.responseHandler != null) {
|
httpResponse.setResponse(request.responseHandler.apply(entity));
|
} else {
|
String charset = null;
|
if (entity.getContentType() != null && entity.getContentType().getValue() != null) {
|
contentType = ContentType.parse(entity.getContentType().getValue());
|
if (contentType.getCharset() != null) {
|
charset = contentType.getCharset().name();
|
}
|
}
|
if (charset == null) {
|
charset = CHARSET_DEFAULT;
|
}
|
httpResponse.setResponse(IOUtils.toString(entity.getContent(), charset));
|
}
|
return httpResponse;
|
} catch (Exception e) {
|
requestBase.abort();
|
if (request.getMaxRetryCount() > retryCount) {
|
return request(request, retryCount + 1);
|
} else if (e instanceof SocketException && "Connection reset".equals(e.getMessage()) && retryCount == 0 && request.getMaxRetryCount() == 0) {
|
// 遇到 Connection reset 默认重试一次
|
return request(request, retryCount + 1);
|
} else {
|
throw new RuntimeException("请求异常", e);
|
}
|
} finally {
|
requestBase.releaseConnection();
|
}
|
}
|
|
private static void setBodyEntity(HttpRequestBase requestBase, ContentType contentType, Object body) {
|
if (body != null && requestBase instanceof HttpEntityEnclosingRequest) {
|
HttpEntityEnclosingRequest entityRequest = (HttpEntityEnclosingRequest) requestBase;
|
if (body instanceof HttpEntity) {
|
entityRequest.setEntity((HttpEntity) body);
|
} else if (body instanceof String) {
|
entityRequest.setEntity(getStringEntity((String) body, contentType));
|
} else if (body instanceof byte[]) {
|
entityRequest.setEntity(new ByteArrayEntity((byte[]) body, contentType));
|
} else if (body instanceof File) {
|
entityRequest.setEntity(new FileEntity((File) body, contentType));
|
} else if (body instanceof InputStream) {
|
entityRequest.setEntity(new InputStreamEntity((InputStream) body, contentType));
|
} else if (ContentType.APPLICATION_JSON.equals(contentType)) {
|
entityRequest.setEntity(getStringEntity(JSON.toJSONString(body), contentType));
|
} else {
|
entityRequest.setEntity(getStringEntity(body.toString(), contentType));
|
}
|
}
|
}
|
|
private static StringEntity getStringEntity(String body, ContentType contentType) {
|
if (contentType != null && contentType.getCharset() != null) {
|
return new StringEntity(body, contentType);
|
} else {
|
return new StringEntity(body, CHARSET_DEFAULT);
|
}
|
}
|
|
public static HttpRequestBase toRequest(HttpRequest request) {
|
String url = request.getUrl();
|
String method = request.getMethod();
|
if (url == null || url.isEmpty()) {
|
throw new RuntimeException("url不能为空");
|
}
|
if (method == null || method.isEmpty()) {
|
method = "GET";
|
}
|
switch (method.toUpperCase()) {
|
case "GET":
|
return new HttpGet(url);
|
case "POST":
|
return new HttpPost(url);
|
case "PUT":
|
return new HttpPut(url);
|
case "PATCH":
|
return new HttpPatch(url);
|
case "DELETE":
|
return new HttpDelete(url);
|
default:
|
throw new RuntimeException("不支持的请求方式：" + method);
|
}
|
}
|
|
private static HttpClient getHttpClient(HttpRequest req, HttpRequestBase request) {
|
RequestConfig.Builder customReqConf = RequestConfig.custom();
|
if (req.getMaxSocketTimeout() != null) {
|
customReqConf.setSocketTimeout(req.getMaxSocketTimeout());
|
} else {
|
customReqConf.setSocketTimeout(MAX_SOCKET_TIMEOUT);
|
}
|
customReqConf.setConnectTimeout(MAX_CONNECT_TIMEOUT);
|
customReqConf.setConnectionRequestTimeout(MAX_CONNECT_TIMEOUT);
|
if (req.getRequestConfigConsumer() != null) {
|
req.getRequestConfigConsumer().accept(customReqConf);
|
}
|
request.setConfig(customReqConf.build());
|
return HttpClients.custom().setConnectionManager(CONNECTION_MANAGER).build();
|
}
|
|
private static Registry<ConnectionSocketFactory> getDefaultRegistry() {
|
try {
|
// ssl: TLS / TLSv1.2 / TLSv1.3
|
SSLContext context = SSLContext.getInstance("TLS");
|
context.init(null, new X509TrustManager[]{new X509TrustManager() {
|
public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {
|
}
|
|
public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {
|
}
|
|
public X509Certificate[] getAcceptedIssuers() {
|
return new X509Certificate[0];
|
}
|
}}, new SecureRandom());
|
return RegistryBuilder.<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", new SSLConnectionSocketFactory(context)).build();
|
} catch (Exception e) {
|
return RegistryBuilder.<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", SSLConnectionSocketFactory.getSocketFactory()).build();
|
}
|
}
|
|
public static String toParamLinks(Map<String, Object> params, boolean encode) {
|
List<String> keys = new ArrayList<>(params.keySet());
|
Collections.sort(keys);
|
StringBuilder sb = new StringBuilder();
|
try {
|
for (String key : keys) {
|
if (key == null || "".equals(key)) {
|
continue;
|
}
|
Object value = params.get(key);
|
if (value == null || "".equals(value)) {
|
continue;
|
}
|
if (encode) {
|
sb.append(key).append("=").append(URLEncoder.encode(value.toString(), "UTF-8")).append("&");
|
} else {
|
sb.append(key).append("=").append(value).append("&");
|
}
|
}
|
} catch (UnsupportedEncodingException e) {
|
throw new RuntimeException("编码失败", e);
|
}
|
if (sb.length() > 0) {
|
sb.setLength(sb.length() - 1);
|
}
|
return sb.toString();
|
}
|
|
public static class HttpRequest implements Serializable {
|
|
private String url;
|
private String method;
|
private Map<String, String> headers;
|
private Object body;
|
private int maxRetryCount = 0;
|
private Integer maxSocketTimeout;
|
private Consumer<RequestConfig.Builder> requestConfigConsumer;
|
private Function<HttpEntity, Object> responseHandler;
|
|
public static HttpRequest build(String url, String method) {
|
HttpRequest request = new HttpRequest();
|
request.url = url;
|
request.method = method;
|
return request;
|
}
|
|
public static HttpRequest get(String url) {
|
return build(url, "GET");
|
}
|
|
public static HttpRequest postJson(String url) {
|
return build(url, "POST").setContentType(CONTENT_TYPE_JSON);
|
}
|
|
public static HttpRequest postFormData(String url) {
|
return build(url, "POST").setContentType(CONTENT_TYPE_FORM_DATA);
|
}
|
|
public String getUrl() {
|
return url;
|
}
|
|
public HttpRequest setUrl(String url) {
|
this.url = url;
|
return this;
|
}
|
|
public String getMethod() {
|
return method;
|
}
|
|
public HttpRequest setMethod(String method) {
|
this.method = method;
|
return this;
|
}
|
|
public Map<String, String> getHeaders() {
|
return headers;
|
}
|
|
public HttpRequest setHeaders(Map<String, String> headers) {
|
this.headers = headers;
|
return this;
|
}
|
|
public HttpRequest setContentType(String contentType) {
|
if (this.headers == null) {
|
this.headers = new HashMap<>();
|
}
|
this.headers.put(CONTENT_TYPE, contentType);
|
return this;
|
}
|
|
public HttpRequest addHeaders(String key, Object value) {
|
if (headers == null) {
|
headers = new HashMap<>();
|
}
|
headers.put(key, value != null ? value.toString() : null);
|
return this;
|
}
|
|
public Object getBody() {
|
return body;
|
}
|
|
public HttpRequest setBody(Object body) {
|
this.body = body;
|
return this;
|
}
|
|
public void setMaxRetryCount(int maxRetryCount) {
|
this.maxRetryCount = maxRetryCount;
|
}
|
|
public int getMaxRetryCount() {
|
return maxRetryCount;
|
}
|
|
public HttpRequest setMaxSocketTimeout(Integer maxSocketTimeout) {
|
this.maxSocketTimeout = maxSocketTimeout;
|
return this;
|
}
|
|
public Integer getMaxSocketTimeout() {
|
return maxSocketTimeout;
|
}
|
|
public Consumer<RequestConfig.Builder> getRequestConfigConsumer() {
|
return requestConfigConsumer;
|
}
|
|
public void setRequestConfigConsumer(Consumer<RequestConfig.Builder> requestConfigConsumer) {
|
this.requestConfigConsumer = requestConfigConsumer;
|
}
|
|
public Function<HttpEntity, Object> getResponseHandler() {
|
return responseHandler;
|
}
|
|
public HttpRequest setResponseHandler(Function<HttpEntity, Object> responseHandler) {
|
this.responseHandler = responseHandler;
|
return this;
|
}
|
}
|
|
public static class HttpResponse implements Serializable {
|
|
private int status;
|
private long reqTime;
|
private Object response;
|
private Map<String, String> headers;
|
|
public int getStatus() {
|
return status;
|
}
|
|
public void setStatus(int status) {
|
this.status = status;
|
}
|
|
public long getReqTime() {
|
return reqTime;
|
}
|
|
public void setReqTime(long reqTime) {
|
this.reqTime = reqTime;
|
}
|
|
public Object getResponse() {
|
return response;
|
}
|
|
public String getResponseToString() {
|
if (response == null) {
|
return null;
|
}
|
return response instanceof String ? (String) response : String.valueOf(response);
|
}
|
|
public JSONObject getResponseToJson() {
|
return JSON.parseObject(getResponseToString());
|
}
|
|
public void setResponse(Object response) {
|
this.response = response;
|
}
|
|
public Map<String, String> getHeaders() {
|
return headers;
|
}
|
|
public void setHeaders(Map<String, String> headers) {
|
this.headers = headers;
|
}
|
}
|
|
}
|
