package io.dataease.utils;
|
|
import io.dataease.exception.DEException;
|
import lombok.Data;
|
import org.apache.commons.collections4.MapUtils;
|
import org.apache.commons.lang3.ObjectUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.http.HttpEntity;
|
import org.apache.http.HttpResponse;
|
import org.apache.http.HttpStatus;
|
import org.apache.http.NameValuePair;
|
import org.apache.http.client.entity.EntityBuilder;
|
import org.apache.http.client.entity.UrlEncodedFormEntity;
|
import org.apache.http.client.methods.*;
|
import org.apache.http.config.Registry;
|
import org.apache.http.config.RegistryBuilder;
|
import org.apache.http.conn.HttpClientConnectionManager;
|
import org.apache.http.conn.socket.ConnectionSocketFactory;
|
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.entity.ContentType;
|
import org.apache.http.entity.mime.MultipartEntityBuilder;
|
import org.apache.http.entity.mime.content.StringBody;
|
import org.apache.http.impl.client.CloseableHttpClient;
|
import org.apache.http.impl.client.HttpClientBuilder;
|
import org.apache.http.impl.client.HttpClients;
|
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
|
import org.apache.http.message.BasicNameValuePair;
|
import org.apache.http.ssl.SSLContextBuilder;
|
import org.apache.http.util.EntityUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.*;
|
import java.net.HttpURLConnection;
|
import java.net.URL;
|
import java.net.URLDecoder;
|
import java.net.URLEncoder;
|
import java.nio.charset.StandardCharsets;
|
import java.security.cert.X509Certificate;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
|
import static io.dataease.result.ResultCode.SYSTEM_INNER_ERROR;
|
|
public class HttpClientUtil {
|
|
private static Logger logger = LoggerFactory.getLogger(HttpClientUtil.class);
|
|
private static final String HTTPS = "https";
|
|
/**
|
* 根据url构建HttpClient（区分http和https）
|
*
|
* @param url 请求地址
|
* @return CloseableHttpClient实例
|
*/
|
private static CloseableHttpClient buildHttpClient(String url) {
|
if (StringUtils.isEmpty(url)) {
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: url 不能为空！");
|
}
|
try {
|
if (url.startsWith(HTTPS)) {
|
return buildHttpClient(true);
|
} else {
|
// http
|
return HttpClientBuilder.create().build();
|
}
|
} catch (Exception e) {
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
}
|
}
|
|
private static CloseableHttpClient buildHttpClient(boolean ssl) {
|
try {
|
if (ssl) {
|
SSLContextBuilder builder = new SSLContextBuilder();
|
builder.loadTrustMaterial(null, (X509Certificate[] x509Certificates, String s) -> true);
|
SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(builder.build(), new String[]{"TLSv1.1", "TLSv1.2", "SSLv3"}, null, NoopHostnameVerifier.INSTANCE);
|
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
|
.register("http", new PlainConnectionSocketFactory())
|
.register("https", socketFactory).build();
|
HttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(registry);
|
return HttpClients.custom().setConnectionManager(connManager).build();
|
} else {
|
// http
|
return HttpClientBuilder.create().build();
|
}
|
} catch (Exception e) {
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
}
|
}
|
|
public static boolean validateUrl(String url, HttpClientConfig config) {
|
CloseableHttpClient httpClient = null;
|
try {
|
httpClient = buildHttpClient(url);
|
HttpGet httpGet = new HttpGet(url);
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
httpGet.setConfig(config.buildRequestConfig());
|
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpGet.addHeader(key, header.get(key));
|
}
|
HttpResponse response = httpClient.execute(httpGet);
|
if (response.getStatusLine().getStatusCode() >= 400) {
|
String msg = EntityUtils.toString(response.getEntity(), config.getCharset());
|
if (StringUtils.isEmpty(msg)) {
|
msg = "StatusCode: " + response.getStatusLine().getStatusCode();
|
}
|
throw new Exception(msg);
|
}
|
return true;
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
} finally {
|
try {
|
if (httpClient != null) {
|
httpClient.close();
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient关闭连接失败", e);
|
}
|
}
|
}
|
|
/**
|
* Get http请求
|
*
|
* @param url 请求地址
|
* @param config 配置项，如果null则使用默认配置
|
* @return 响应结果字符串
|
*/
|
public static String get(String url, HttpClientConfig config) {
|
CloseableHttpClient httpClient = null;
|
try {
|
httpClient = buildHttpClient(url);
|
HttpGet httpGet = new HttpGet(url);
|
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
httpGet.setConfig(config.buildRequestConfig());
|
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpGet.addHeader(key, header.get(key));
|
}
|
HttpResponse response = httpClient.execute(httpGet);
|
return getResponseStr(response, config);
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
} finally {
|
try {
|
if (httpClient != null) {
|
httpClient.close();
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient关闭连接失败", e);
|
}
|
}
|
}
|
|
public static String patch(String url, String json, HttpClientConfig config) {
|
CloseableHttpClient httpClient = buildHttpClient(url);
|
HttpPatch httpPatch = new HttpPatch(url);
|
config = config == null ? new HttpClientConfig() : config;
|
try {
|
httpPatch.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpPatch.addHeader(key, header.get(key));
|
}
|
EntityBuilder entityBuilder = EntityBuilder.create();
|
entityBuilder.setText(json);
|
entityBuilder.setContentType(ContentType.APPLICATION_JSON);
|
HttpEntity requestEntity = entityBuilder.build();
|
httpPatch.setEntity(requestEntity);
|
HttpResponse response = httpClient.execute(httpPatch);
|
return getResponseStr(response, config);
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
} finally {
|
try {
|
httpClient.close();
|
} catch (Exception e) {
|
logger.error("HttpClient关闭连接失败", e);
|
}
|
}
|
}
|
|
/**
|
* Post请求，请求内容必须为JSON格式的字符串
|
*
|
* @param url 请求地址
|
* @param config 配置项，如果null则使用默认配置
|
* @param json JSON格式的字符串
|
* @return 响应结果字符串
|
*/
|
public static String post(String url, String json, HttpClientConfig config) {
|
CloseableHttpClient httpClient = null;
|
try {
|
httpClient = buildHttpClient(url);
|
HttpPost httpPost = new HttpPost(url);
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
httpPost.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpPost.addHeader(key, header.get(key));
|
}
|
EntityBuilder entityBuilder = EntityBuilder.create();
|
entityBuilder.setText(json);
|
entityBuilder.setContentType(ContentType.APPLICATION_JSON);
|
HttpEntity requestEntity = entityBuilder.build();
|
httpPost.setEntity(requestEntity);
|
|
HttpResponse response = httpClient.execute(httpPost);
|
return getResponseStr(response, config);
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
} finally {
|
try {
|
if (httpClient != null) {
|
httpClient.close();
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient关闭连接失败", e);
|
}
|
}
|
}
|
|
public static HttpResponse postWithHeaders(String url, String json, HttpClientConfig config) {
|
CloseableHttpClient httpClient = null;
|
try {
|
httpClient = buildHttpClient(url);
|
HttpPost httpPost = new HttpPost(url);
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
httpPost.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpPost.addHeader(key, header.get(key));
|
}
|
EntityBuilder entityBuilder = EntityBuilder.create();
|
entityBuilder.setText(json);
|
entityBuilder.setContentType(ContentType.APPLICATION_JSON);
|
HttpEntity requestEntity = entityBuilder.build();
|
httpPost.setEntity(requestEntity);
|
|
HttpResponse response = httpClient.execute(httpPost);
|
return response;
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
} finally {
|
try {
|
if (httpClient != null) {
|
httpClient.close();
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient关闭连接失败", e);
|
}
|
}
|
}
|
|
public static String put(String url, String json, HttpClientConfig config) {
|
CloseableHttpClient httpClient = null;
|
try {
|
httpClient = buildHttpClient(url);
|
HttpPut httpPut = new HttpPut(url);
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
httpPut.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpPut.addHeader(key, header.get(key));
|
}
|
EntityBuilder entityBuilder = EntityBuilder.create();
|
entityBuilder.setText(json);
|
entityBuilder.setContentType(ContentType.APPLICATION_JSON);
|
HttpEntity requestEntity = entityBuilder.build();
|
httpPut.setEntity(requestEntity);
|
|
HttpResponse response = httpClient.execute(httpPut);
|
return getResponseStr(response, config);
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
} finally {
|
try {
|
if (httpClient != null) {
|
httpClient.close();
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient关闭连接失败", e);
|
}
|
}
|
}
|
|
/**
|
* Post请求，请求内容必须为JSON格式的字符串
|
*
|
* @param url 请求地址
|
* @param json JSON格式的字符串
|
* @return 响应结果字符串
|
*/
|
public static String post(String url, String json) {
|
return HttpClientUtil.post(url, json, null);
|
}
|
|
/**
|
* Post请求，请求内容必须为键值对参数
|
*
|
* @param url 请求地址
|
* @param config 配置项，如果null则使用默认配置
|
* @param body 请求内容键值对参数
|
* @return 响应结果字符串
|
*/
|
public static String post(String url, Map<String, String> body, HttpClientConfig config) {
|
try (CloseableHttpClient httpClient = buildHttpClient(url)) {
|
HttpPost httpPost = new HttpPost(url);
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
httpPost.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpPost.addHeader(key, header.get(key));
|
}
|
if (body != null && body.size() > 0) {
|
List<NameValuePair> nvps = new ArrayList<>();
|
for (String key : body.keySet()) {
|
nvps.add(new BasicNameValuePair(key, body.get(key)));
|
}
|
try {
|
httpPost.setEntity(new UrlEncodedFormEntity(nvps, config.getCharset()));
|
} catch (Exception e) {
|
logger.error("HttpClient转换编码错误", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient转换编码错误: " + e.getMessage());
|
}
|
}
|
|
HttpResponse response = httpClient.execute(httpPost);
|
return getResponseStr(response, config);
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
}
|
}
|
|
private static String getResponseStr(HttpResponse response, HttpClientConfig config) throws Exception {
|
if (response.getStatusLine().getStatusCode() >= 400) {
|
String msg = EntityUtils.toString(response.getEntity(), config.getCharset());
|
if (StringUtils.isEmpty(msg)) {
|
msg = "StatusCode: " + response.getStatusLine().getStatusCode();
|
}
|
throw new Exception(msg);
|
}
|
return EntityUtils.toString(response.getEntity(), config.getCharset());
|
}
|
|
public static Map<String, String> downloadFile(String url, HttpClientConfig config, String path) {
|
String encodeUIl = url;
|
Map<String, String> name = new HashMap<>();
|
if (!url.contains("%")) {
|
String[] http = url.split("://");
|
String[] server = http[1].split("/");
|
encodeUIl = http[0] + "://" + server[0] + "/" + URLEncoder.encode(http[1].substring(server[0].length() + 1, http[1].length()));
|
}
|
try (CloseableHttpClient httpClient = buildHttpClient(encodeUIl.replace("+", "%20"))) {
|
HttpGet httpGet = new HttpGet(encodeUIl.replace("+", "%20"));
|
// 设置请求配置
|
httpGet.setConfig(config.buildRequestConfig());
|
// 设置请求头
|
config.getHeader().forEach(httpGet::addHeader);
|
HttpResponse response = httpClient.execute(httpGet);
|
if (response.getStatusLine().getStatusCode() >= 400) {
|
String msg = EntityUtils.toString(response.getEntity(), config.getCharset());
|
if (StringUtils.isEmpty(msg)) {
|
msg = "StatusCode: " + response.getStatusLine().getStatusCode();
|
}
|
throw new Exception(msg);
|
}
|
String fileName = extractFileName(response, url);
|
String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);
|
String tranName = UUID.randomUUID().toString() + "." + suffix;
|
name.put("fileName", fileName);
|
name.put("tranName", tranName);
|
File localFile = new File(path + tranName);
|
try (InputStream is = response.getEntity().getContent();
|
FileOutputStream outputStream = new FileOutputStream(localFile)) {
|
byte[] buffer = new byte[4096];
|
int bytesRead;
|
while ((bytesRead = is.read(buffer)) != -1) {
|
outputStream.write(buffer, 0, bytesRead);
|
}
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new RuntimeException("HttpClient查询失败: " + e.getMessage(), e);
|
}
|
return name;
|
}
|
|
private static String extractFileName(HttpResponse response, String url) {
|
url = URLDecoder.decode(url);
|
String fileName = "";
|
String disposition = response.getHeaders("Content-Disposition").toString();
|
if (disposition != null) {
|
int filenameIndex = disposition.indexOf("filename=");
|
if (filenameIndex > 0) {
|
fileName = disposition.substring(filenameIndex + 9)
|
.replaceAll("\"", "") // 去除引号
|
.trim();
|
}
|
}
|
if (fileName.isEmpty()) {
|
url = url.split("\\?")[0];
|
fileName = url.contains("/")
|
? url.substring(url.lastIndexOf('/') + 1)
|
: "download_" + System.currentTimeMillis();
|
}
|
if (fileName.trim().isEmpty()) {
|
fileName = "download_" + System.currentTimeMillis();
|
}
|
return fileName;
|
}
|
|
public static byte[] downloadBytes(String url) {
|
HttpClientConfig config = new HttpClientConfig();
|
return HttpClientUtil.downFromRemote(url, config);
|
}
|
|
public static byte[] downFromRemote(String url, HttpClientConfig config) {
|
try (CloseableHttpClient httpClient = buildHttpClient(url)) {
|
HttpGet httpGet = new HttpGet(url);
|
// 设置请求配置
|
httpGet.setConfig(config.buildRequestConfig());
|
|
// 设置请求头
|
config.getHeader().forEach(httpGet::addHeader);
|
HttpResponse response = httpClient.execute(httpGet);
|
try (InputStream inputStream = response.getEntity().getContent();
|
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
|
|
byte[] buffer = new byte[1024];
|
int bytesRead;
|
|
// 读取响应内容并写入输出流
|
while ((bytesRead = inputStream.read(buffer)) != -1) {
|
outputStream.write(buffer, 0, bytesRead);
|
}
|
|
return outputStream.toByteArray();
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new RuntimeException("HttpClient查询失败: " + e.getMessage(), e);
|
}
|
}
|
|
public static String postFile(String fileServer, byte[] bytes, String fileName, Map<String, String> param, HttpClientConfig config) {
|
CloseableHttpClient httpClient = buildHttpClient(fileServer);
|
HttpPost postRequest = new HttpPost(fileServer);
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
|
postRequest.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
if (MapUtils.isNotEmpty(header)) {
|
Iterator var8 = header.keySet().iterator();
|
|
while (var8.hasNext()) {
|
String key = (String) var8.next();
|
postRequest.addHeader(key, (String) header.get(key));
|
}
|
}
|
|
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
|
builder.setCharset(StandardCharsets.UTF_8);
|
builder.addBinaryBody("image", bytes, ContentType.DEFAULT_BINARY, fileName);
|
if (param != null) {
|
Iterator var13 = param.entrySet().iterator();
|
while (var13.hasNext()) {
|
Map.Entry<String, String> entry = (Map.Entry) var13.next();
|
builder.addTextBody((String) entry.getKey(), (String) entry.getValue());
|
}
|
}
|
try {
|
postRequest.setEntity((HttpEntity) builder.build());
|
return getResponseStr(httpClient.execute(postRequest), config);
|
} catch (Exception var11) {
|
logger.error("HttpClient查询失败", var11);
|
throw new RuntimeException("HttpClient查询失败: " + var11.getMessage());
|
}
|
}
|
|
public static String upload(String url, byte[] bytes, String name, Map<String, String> paramMap, Map<String, Object> headMap) {
|
HttpClientConfig config = new HttpClientConfig();
|
addHead(config, headMap);
|
return HttpClientUtil.postFile(url, bytes, name, paramMap, config);
|
}
|
|
public static String upload(String url, File file, String name) {
|
HttpClientConfig config = new HttpClientConfig();
|
Map<String, String> param = new HashMap<>();
|
param.put("fileFlag", "media");
|
param.put("fileName", name);
|
return HttpClientUtil.postFile(url, file, param, config);
|
}
|
|
public static String postFile(String fileServer, File file, Map<String, String> param, HttpClientConfig config) {
|
CloseableHttpClient httpClient = buildHttpClient(fileServer);
|
HttpPost postRequest = new HttpPost(fileServer);
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
postRequest.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
String fileFlag = param.get("fileFlag");
|
String fileName = param.get("fileName");
|
param.remove("fileFlag");
|
param.remove("fileName");
|
if (MapUtils.isNotEmpty(header)) {
|
for (String key : header.keySet()) {
|
postRequest.addHeader(key, header.get(key));
|
}
|
}
|
postRequest.setHeader("Content-Type", "multipart/form-data");
|
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
|
builder.setCharset(StandardCharsets.UTF_8);
|
builder.addBinaryBody(StringUtils.isNotBlank(fileFlag) ? fileFlag : "file", file, ContentType.APPLICATION_OCTET_STREAM, StringUtils.isNotBlank(fileName) ? fileName : file.getName());
|
if (MapUtils.isNotEmpty(param)) {
|
for (Map.Entry<String, String> entry : param.entrySet()) {
|
StringBody stringBody = new StringBody(entry.getValue(), ContentType.TEXT_PLAIN.withCharset("utf-8"));
|
builder.addPart(entry.getKey(), stringBody);
|
}
|
}
|
try {
|
postRequest.setEntity(builder.build());
|
return getResponseStr(httpClient.execute(postRequest), config);
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new RuntimeException("HttpClient查询失败: " + e.getMessage());
|
}
|
}
|
|
private static void addHead(HttpClientConfig config, Map<String, Object> headMap) {
|
if (MapUtils.isEmpty(headMap)) return;
|
for (Map.Entry<String, Object> entry : headMap.entrySet()) {
|
config.addHeader(entry.getKey(), entry.getValue().toString());
|
}
|
}
|
|
public static String delete(String url, HttpClientConfig config) {
|
CloseableHttpClient httpClient = null;
|
try {
|
httpClient = buildHttpClient(url);
|
HttpDelete httpDelete = new HttpDelete(url);
|
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
httpDelete.setConfig(config.buildRequestConfig());
|
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpDelete.addHeader(key, header.get(key));
|
}
|
HttpResponse response = httpClient.execute(httpDelete);
|
return getResponseStr(response, config);
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
} finally {
|
try {
|
if (httpClient != null) {
|
httpClient.close();
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient关闭连接失败", e);
|
}
|
}
|
}
|
|
public static boolean isURLReachable(String urlString, Map<String, String> head) {
|
try {
|
URL url = new URL(urlString);
|
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
|
connection.setRequestMethod("GET");
|
connection.setConnectTimeout(5000); // 设置连接超时时间，单位为毫秒
|
connection.setReadTimeout(5000); // 设置读取超时时间，单位为毫秒
|
if (MapUtils.isNotEmpty(head)) {
|
for (Map.Entry<String, String> entry : head.entrySet()) {
|
connection.addRequestProperty(entry.getKey(), entry.getValue());
|
}
|
}
|
int responseCode = connection.getResponseCode();
|
if (responseCode == HttpURLConnection.HTTP_OK) {
|
return true; // 状态码200表示URL可达
|
} else if (StringUtils.equalsIgnoreCase("Unauthorized", connection.getResponseMessage())) {
|
LogUtil.error("apisix key error [failed to check token]");
|
}
|
} catch (IOException e) {
|
return false;
|
}
|
return false; // 如果发生异常或状态码不是200，则URL不可达
|
}
|
|
public static String postWebhook(String url, String contentType, Map<String, Object> param, boolean ssl, HttpClientConfig config) {
|
|
CloseableHttpClient httpClient = null;
|
try {
|
httpClient = buildHttpClient(ssl);
|
HttpPost httpPost = new HttpPost(url);
|
if (ObjectUtils.isEmpty(config)) {
|
config = new HttpClientConfig();
|
}
|
httpPost.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpPost.addHeader(key, header.get(key));
|
}
|
if (StringUtils.equalsIgnoreCase(contentType, ContentType.APPLICATION_JSON.getMimeType())) {
|
EntityBuilder entityBuilder = EntityBuilder.create();
|
if (MapUtils.isNotEmpty(param)) {
|
String json = JsonUtil.toJSONString(param).toString();
|
entityBuilder.setText(json);
|
}
|
entityBuilder.setContentType(ContentType.APPLICATION_JSON);
|
HttpEntity requestEntity = entityBuilder.build();
|
httpPost.setEntity(requestEntity);
|
} else {
|
List<NameValuePair> nvps = param.entrySet().stream().map(entry -> new BasicNameValuePair(entry.getKey(), ObjectUtils.isEmpty(entry.getValue()) ? null : entry.getValue().toString())).collect(Collectors.toList());
|
try {
|
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(nvps, config.getCharset());
|
httpPost.setEntity(entity);
|
} catch (Exception e) {
|
logger.error("HttpClient转换编码错误", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient转换编码错误: " + e.getMessage());
|
}
|
}
|
HttpResponse response = httpClient.execute(httpPost);
|
return getResponseStr(response, config);
|
} catch (Exception e) {
|
logger.error("HttpClient查询失败", e);
|
throw new DEException(SYSTEM_INNER_ERROR.code(), "HttpClient查询失败: " + e.getMessage());
|
} finally {
|
try {
|
if (httpClient != null) {
|
httpClient.close();
|
}
|
} catch (Exception e) {
|
logger.error("HttpClient关闭连接失败", e);
|
}
|
}
|
}
|
|
public static MultipartResponse postForScreenshot(
|
String url, Map<String,String> body, HttpClientConfig config) throws IOException {
|
CloseableHttpClient httpClient = null;
|
try {
|
httpClient = buildHttpClient(url);
|
HttpPost httpPost = new HttpPost(url);
|
if (config == null) {
|
config = new HttpClientConfig();
|
}
|
httpPost.setConfig(config.buildRequestConfig());
|
Map<String, String> header = config.getHeader();
|
for (String key : header.keySet()) {
|
httpPost.addHeader(key, header.get(key));
|
}
|
EntityBuilder entityBuilder = EntityBuilder.create();
|
String json = JsonUtil.toJSONString(body).toString();
|
entityBuilder.setText(json);
|
entityBuilder.setContentType(ContentType.APPLICATION_JSON);
|
HttpEntity requestEntity = entityBuilder.build();
|
httpPost.setEntity(requestEntity);
|
|
|
try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
|
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
|
throw new DEException(response.getStatusLine().getStatusCode(), response.toString());
|
}
|
HttpEntity entity = response.getEntity();
|
byte[] bytes = EntityUtils.toByteArray(entity); // raw bytes
|
String contentType = response.getFirstHeader("Content-Type").getValue();
|
if (contentType.startsWith("multipart/")) {
|
return MultipartParser.parse(bytes, contentType); // see util below
|
} else {
|
throw new IOException("unexpected response: " + contentType);
|
}
|
}
|
} catch (IOException e) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
@Data
|
public static class MultipartResponse {
|
Map<String,Object> metadata;
|
byte[] image;
|
}
|
|
public class MultipartParser {
|
public static MultipartResponse parse(byte[] body, String contentType) throws IOException {
|
String boundary = extractBoundary(contentType);
|
String delim = "--" + boundary;
|
byte[] delimBytes = delim.getBytes();
|
MultipartResponse resp = new MultipartResponse();
|
resp.metadata = new HashMap<>();
|
|
int idx = 0;
|
while (idx < body.length) {
|
int start = indexOf(body, delimBytes, idx);
|
if (start < 0) break;
|
idx = start + delimBytes.length;
|
if (idx + 1 < body.length && body[idx] == '-' && body[idx+1] == '-') break; // final boundary
|
// skip CRLF
|
if (body[idx] == '\r' && body[idx+1] == '\n') idx += 2;
|
|
// read headers
|
int headerEnd = indexOf(body, "\r\n\r\n".getBytes(), idx);
|
String headers = new String(body, idx, headerEnd - idx);
|
idx = headerEnd + 4;
|
|
boolean isImage = headers.contains("name=\"image\"");
|
int nextBoundary = indexOf(body, delimBytes, idx);
|
if (nextBoundary < 0) break;
|
|
byte[] part = new byte[nextBoundary - idx - 2]; // strip trailing CRLF
|
System.arraycopy(body, idx, part, 0, part.length);
|
|
if (isImage) {
|
resp.image = part;
|
} else {
|
String json = new String(part);
|
// 最简单把整个 JSON 字符串放到 metadata map；
|
// 你也可以用 Jackson/Gson 解析成具体字段
|
resp.metadata = JsonUtil.parseObject(json, Map.class);
|
}
|
idx = nextBoundary;
|
}
|
return resp;
|
}
|
|
private static String extractBoundary(String contentType) {
|
Pattern p = Pattern.compile("boundary=(.*)");
|
Matcher m = p.matcher(contentType);
|
if (m.find()) {
|
return m.group(1);
|
}
|
throw new IllegalArgumentException("No boundary in content-type");
|
}
|
|
private static int indexOf(byte[] array, byte[] target, int start) {
|
outer:
|
for (int i = start; i <= array.length - target.length; i++) {
|
for (int j = 0; j < target.length; j++) {
|
if (array[i+j] != target[j]) continue outer;
|
}
|
return i;
|
}
|
return -1;
|
}
|
}
|
}
|
