ecology_maven/aiyh/utils/httpUtil/util/HttpUtils.java

773 lines
30 KiB
Java
Raw Normal View History

2021-11-14 15:29:16 +08:00
package aiyh.utils.httpUtil.util;
import com.alibaba.fastjson.JSON;
import com.google.common.base.Strings;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
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.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import aiyh.utils.httpUtil.ExtendedIOUtils;
import aiyh.utils.httpUtil.HttpArgsType;
import aiyh.utils.httpUtil.HttpManager;
import aiyh.utils.httpUtil.ResponeVo;
import aiyh.utils.httpUtil.httpAsync.HttpAsyncThread;
import aiyh.utils.httpUtil.httpAsync.HttpAsyncThreadCallBack;
import aiyh.utils.zwl.common.ToolUtil;
import weaver.file.ImageFileManager;
import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.Consumer;
/**
* @author EBU7-dev1-ayh
* @date 2021/8/31 0031 17:16
* http HttpStaticUtils使HttpStaticUtils
*/
public class HttpUtils {
// 默认编码
private String DEFAULT_ENCODING = "UTF-8";
private final ToolUtil toolUtil = new ToolUtil();
private final GlobalCache globalCache = new GlobalCache();
// 线程池
private final ThreadPoolExecutor executorService;
{
// private final ExecutorService executorService = Executors.newFixedThreadPool(3);
ThreadFactoryBuilder threadFactoryBuilder = new ThreadFactoryBuilder();
ThreadFactory threadFactory = threadFactoryBuilder.setNameFormat("xxx-pool-%d").build();
executorService = new ThreadPoolExecutor(5, 200, 0L,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(1024),
threadFactory,
new ThreadPoolExecutor.AbortPolicy());
}
public HttpUtils() {
}
public GlobalCache getGlobalCache() {
return globalCache;
}
public void setDEFAULT_ENCODING() {
this.DEFAULT_ENCODING = DEFAULT_ENCODING;
}
public HttpUtils(String DEFAULT_ENCODING) {
this.DEFAULT_ENCODING = DEFAULT_ENCODING;
}
public HttpPost getHttpPost(String url) {
HttpPost httpPost = new HttpPost(url);
RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(10000)
.setConnectionRequestTimeout(10000)
.setRedirectsEnabled(true)
.build();
httpPost.setConfig(requestConfig);
return httpPost;
}
public HttpGet getHttpGet(String url) {
HttpGet httpGet = new HttpGet(url);
RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(10000)
.setConnectionRequestTimeout(10000)
.setRedirectsEnabled(true)
.build();
httpGet.setConfig(requestConfig);
return httpGet;
}
/**
* get
*
* @param url
* @return
* @throws IOException io
*/
public ResponeVo apiGet(String url) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> params = paramsHandle(null);
String getUrl = urlHandle(url, params);
Map<String, String> headers = headersHandle(null);
HttpGet httpGet = new HttpGet(getUrl.trim());
for (Map.Entry<String, String> entry : headers.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
return baseRequest(httpConnection, httpGet);
}
/**
* delete
*
* @param url
* @return
* @throws IOException io
*/
public ResponeVo apiDelete(String url) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> params = paramsHandle(null);
String getUrl = urlHandle(url, params);
Map<String, String> headers = headersHandle(null);
HttpDelete httpDelete = new HttpDelete(getUrl.trim());
for (Map.Entry<String, String> entry : headers.entrySet()) {
httpDelete.setHeader(entry.getKey(), entry.getValue());
}
return baseRequest(httpConnection, httpDelete);
}
/**
* get
*
* @param url
* @param headers
* @return
* @throws IOException io
*/
public ResponeVo apiGet(String url, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> params = paramsHandle(null);
String getUrl = urlHandle(url, params);
Map<String, String> headerMap = headersHandle(headers);
HttpGet httpGet = new HttpGet(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
return baseRequest(httpConnection, httpGet);
}
public ResponeVo apiDelete(String url, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> params = paramsHandle(null);
String getUrl = urlHandle(url, params);
Map<String, String> headerMap = headersHandle(headers);
HttpDelete httpDelete = new HttpDelete(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpDelete.setHeader(entry.getKey(), entry.getValue());
}
return baseRequest(httpConnection, httpDelete);
}
public ResponeVo apiGet(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
Map<String, Object> paramsMap = paramsHandle(params);
String getUrl = urlHandle(url, paramsMap);
Map<String, String> headerMap = headersHandle(headers);
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
HttpGet httpGet = new HttpGet(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
return baseRequest(httpConnection, httpGet);
}
public ResponeVo apiDelete(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
Map<String, Object> paramsMap = paramsHandle(params);
String getUrl = urlHandle(url, paramsMap);
Map<String, String> headerMap = headersHandle(headers);
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
HttpDelete httpDelete = new HttpDelete(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpDelete.setHeader(entry.getKey(), entry.getValue());
}
return baseRequest(httpConnection, httpDelete);
}
/**
*
*
* @param url
* @param params
* @param headers
* @param consumer
* @throws IOException io
*/
public void apiGet(String url, Map<String, Object> params, Map<String, String> headers, Consumer<CloseableHttpResponse> consumer) throws IOException {
Map<String, Object> paramsMap = paramsHandle(params);
String getUrl = urlHandle(url, paramsMap);
Map<String, String> headerMap = headersHandle(headers);
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
HttpGet httpGet = new HttpGet(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
callBackRequest(httpConnection, httpGet, consumer);
}
/**
*
*
* @param url
* @param params
* @param headers
* @param consumer
* @throws IOException io
*/
public void apiDelete(String url, Map<String, Object> params, Map<String, String> headers, Consumer<CloseableHttpResponse> consumer) throws IOException {
Map<String, Object> paramsMap = paramsHandle(params);
String getUrl = urlHandle(url, paramsMap);
Map<String, String> headerMap = headersHandle(headers);
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
HttpDelete httpDelete = new HttpDelete(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpDelete.setHeader(entry.getKey(), entry.getValue());
}
callBackRequest(httpConnection, httpDelete, consumer);
}
public ResponeVo apiPost(String url, Map<String, Object> params) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(null);
HttpPost httpPost = handleHttpPost(url, headerMap, paramsMap);
return baseRequest(httpConnection, httpPost);
}
public ResponeVo apiPut(String url, Map<String, Object> params) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(null);
HttpPut httpPut = handleHttpPut(url, headerMap, paramsMap);
return baseRequest(httpConnection, httpPut);
}
public ResponeVo apiPost(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPost httpPost = handleHttpPost(url, headerMap, paramsMap);
return baseRequest(httpConnection, httpPost);
}
public ResponeVo apiPut(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPut httpPut = handleHttpPut(url, headerMap, paramsMap);
return baseRequest(httpConnection, httpPut);
}
public ResponeVo apiUploadFile(String url,InputStream inputStream, String fileKey,String fileName,
Map<String, Object> params, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPost httpPost = uploadFileByInputStream(url,inputStream, fileKey,fileName, paramsMap, headerMap);
return baseRequest(httpConnection, httpPost);
}
public ResponeVo apiUploadFile(String url,File file, String fileKey,String fileName,
Map<String, Object> params, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPost httpPost = uploadFileByInputStream(url,file, fileKey,fileName, paramsMap, headerMap);
return baseRequest(httpConnection, httpPost);
}
public ResponeVo apiUploadFileById(String url,int id, String fileKey,String fileName,
Map<String, Object> params, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
InputStream inputStream = ImageFileManager.getInputStreamById(id);
HttpPost httpPost = uploadFileByInputStream(url,inputStream, fileKey,fileName, paramsMap, headerMap);
return baseRequest(httpConnection, httpPost);
}
/**
* @param url
* @param params
* @param headers
* @param consumer
* @throws IOException io
*/
public void apiPost(String url, Map<String, Object> params, Map<String, String> headers, Consumer<CloseableHttpResponse> consumer) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPost httpPost = handleHttpPost(url, headerMap, paramsMap);
callBackRequest(httpConnection, httpPost, consumer);
}
/**
* @param url
* @param params
* @param headers
* @param consumer
* @throws IOException io
*/
public void apiPut(String url, Map<String, Object> params, Map<String, String> headers, Consumer<CloseableHttpResponse> consumer) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPut httpPut = handleHttpPut(url, headerMap, paramsMap);
callBackRequest(httpConnection, httpPut, consumer);
}
private void callBackRequest(CloseableHttpClient httpClient, HttpUriRequest request, Consumer<CloseableHttpResponse> consumer) throws IOException {
CloseableHttpResponse response = null;
try {
response = httpClient.execute(request);
consumer.accept(response);
} catch (Exception e) {
toolUtil.writeErrorLog(" http调用失败:" + e);
throw e;
}
// new CloseThread(httpClient,response).run();
ExtendedIOUtils.closeQuietly(httpClient);
ExtendedIOUtils.closeQuietly(response);
}
public ResponeVo baseRequest(CloseableHttpClient httpClient, HttpUriRequest request) throws IOException {
ResponeVo responeVo = new ResponeVo();
CloseableHttpResponse response = null;
try {
response = httpClient.execute(request);
HttpEntity entity = response.getEntity();
Header[] allHeaders = response.getAllHeaders();
Locale locale = response.getLocale();
responeVo.setLocale(locale);
responeVo.setAllHeaders(allHeaders);
responeVo.setEntityString(EntityUtils.toString(entity, DEFAULT_ENCODING));
responeVo.setCode(response.getStatusLine().getStatusCode());
} catch (Exception e) {
toolUtil.writeErrorLog(" http调用失败:" + e);
throw e;
}
// new CloseThread(httpClient,response).run();
ExtendedIOUtils.closeQuietly(httpClient);
ExtendedIOUtils.closeQuietly(response);
return responeVo;
}
/**
* get
*
* @param url
* @return
* @throws IOException io
*/
public Future<ResponeVo> asyncApiGet(String url) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> params = paramsHandle(null);
String getUrl = urlHandle(url, params);
Map<String, String> headers = headersHandle(null);
HttpGet httpGet = new HttpGet(getUrl.trim());
for (Map.Entry<String, String> entry : headers.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
return executorService.submit(new HttpAsyncThread(httpConnection, httpGet, DEFAULT_ENCODING));
}
/**
* delete
*
* @param url
* @return
* @throws IOException io
*/
public Future<ResponeVo> asyncApiDelete(String url) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> params = paramsHandle(null);
String getUrl = urlHandle(url, params);
Map<String, String> headers = headersHandle(null);
HttpDelete httpDelete = new HttpDelete(getUrl.trim());
for (Map.Entry<String, String> entry : headers.entrySet()) {
httpDelete.setHeader(entry.getKey(), entry.getValue());
}
return executorService.submit(new HttpAsyncThread(httpConnection, httpDelete, DEFAULT_ENCODING));
}
/**
* get
*
* @param url
* @param headers
* @return
* @throws IOException io
*/
public Future<ResponeVo> asyncApiGet(String url, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> params = paramsHandle(null);
String getUrl = urlHandle(url, params);
Map<String, String> headerMap = headersHandle(headers);
HttpGet httpGet = new HttpGet(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
return executorService.submit(new HttpAsyncThread(httpConnection, httpGet, DEFAULT_ENCODING));
}
public Future<ResponeVo> asyncApiDelete(String url, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> params = paramsHandle(null);
String getUrl = urlHandle(url, params);
Map<String, String> headerMap = headersHandle(headers);
HttpDelete httpDelete = new HttpDelete(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpDelete.setHeader(entry.getKey(), entry.getValue());
}
return executorService.submit(new HttpAsyncThread(httpConnection, httpDelete, DEFAULT_ENCODING));
}
public Future<ResponeVo> asyncApiGet(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
Map<String, Object> paramsMap = paramsHandle(params);
String getUrl = urlHandle(url, paramsMap);
Map<String, String> headerMap = headersHandle(headers);
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
HttpGet httpGet = new HttpGet(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
return executorService.submit(new HttpAsyncThread(httpConnection, httpGet, DEFAULT_ENCODING));
}
public Future<ResponeVo> asyncApiDelete(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
Map<String, Object> paramsMap = paramsHandle(params);
String getUrl = urlHandle(url, paramsMap);
Map<String, String> headerMap = headersHandle(headers);
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
HttpDelete httpDelete = new HttpDelete(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpDelete.setHeader(entry.getKey(), entry.getValue());
}
return executorService.submit(new HttpAsyncThread(httpConnection, httpDelete, DEFAULT_ENCODING));
}
/**
*
*
* @param url
* @param params
* @param headers
* @param consumer
* @throws IOException io
*/
public void asyncApiGet(String url, Map<String, Object> params, Map<String, String> headers, Consumer<CloseableHttpResponse> consumer) throws IOException {
Map<String, Object> paramsMap = paramsHandle(params);
String getUrl = urlHandle(url, paramsMap);
Map<String, String> headerMap = headersHandle(headers);
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
HttpGet httpGet = new HttpGet(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpGet.setHeader(entry.getKey(), entry.getValue());
}
executorService.execute(new HttpAsyncThreadCallBack(httpConnection, httpGet, consumer));
}
/**
*
* @param url
* @param params
* @param headers
* @param consumer
* @throws IOException io
*/
public void asyncApiDelete(String url, Map<String, Object> params, Map<String, String> headers, Consumer<CloseableHttpResponse> consumer) throws IOException {
Map<String, Object> paramsMap = paramsHandle(params);
String getUrl = urlHandle(url, paramsMap);
Map<String, String> headerMap = headersHandle(headers);
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
HttpDelete httpDelete = new HttpDelete(getUrl.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpDelete.setHeader(entry.getKey(), entry.getValue());
}
executorService.execute(new HttpAsyncThreadCallBack(httpConnection, httpDelete, consumer));
}
public Future<ResponeVo> asyncApiPost(String url, Map<String, Object> params) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(null);
HttpPost httpPost = handleHttpPost(url, headerMap, paramsMap);
return executorService.submit(new HttpAsyncThread(httpConnection, httpPost, DEFAULT_ENCODING));
}
public Future<ResponeVo> asyncApiPut(String url, Map<String, Object> params) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(null);
HttpPut httpPut = handleHttpPut(url, headerMap, paramsMap);
return executorService.submit(new HttpAsyncThread(httpConnection, httpPut, DEFAULT_ENCODING));
}
public Future<ResponeVo> asyncApiPost(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPost httpPost = handleHttpPost(url, headerMap, paramsMap);
return executorService.submit(new HttpAsyncThread(httpConnection, httpPost, DEFAULT_ENCODING));
}
public Future<ResponeVo> asyncApiPut(String url, Map<String, Object> params, Map<String, String> headers) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPut httpPut = handleHttpPut(url, headerMap, paramsMap);
return executorService.submit(new HttpAsyncThread(httpConnection, httpPut, DEFAULT_ENCODING));
}
/**
* @param url
* @param params
* @param headers
* @param consumer
* @throws IOException io
*/
public void asyncApiPost(String url, Map<String, Object> params, Map<String, String> headers, Consumer<CloseableHttpResponse> consumer) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPost httpPost = handleHttpPost(url, headerMap, paramsMap);
executorService.execute(new HttpAsyncThreadCallBack(httpConnection, httpPost, consumer));
}
/**
* @param url
* @param params
* @param headers
* @param consumer
* @throws IOException io
*/
public void asyncApiPut(String url, Map<String, Object> params, Map<String, String> headers, Consumer<CloseableHttpResponse> consumer) throws IOException {
CloseableHttpClient httpConnection = HttpManager.getHttpConnection(url);
Map<String, Object> paramsMap = paramsHandle(params);
Map<String, String> headerMap = headersHandle(headers);
HttpPut httpPut = handleHttpPut(url, headerMap, paramsMap);
executorService.execute(new HttpAsyncThreadCallBack(httpConnection, httpPut, consumer));
}
private HttpPost handleHttpPost(String url, Map<String, String> headerMap, Map<String, Object> paramsMap) throws UnsupportedEncodingException {
String contentType = "";
HttpPost httpPost = new HttpPost(url.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpPost.setHeader(entry.getKey(), entry.getValue());
if ("Content-Type".equalsIgnoreCase(entry.getKey())) {
contentType = entry.getValue();
}
}
if (Strings.isNullOrEmpty(contentType)) {
List<NameValuePair> nvps = new ArrayList<>();
for (Map.Entry<String, Object> entry : paramsMap.entrySet()) {
nvps.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
}
httpPost.setHeader("Content-Type", HttpArgsType.DEFAULT_CONTENT_TYPE);
httpPost.setEntity(new UrlEncodedFormEntity(nvps));
} else if (contentType.toUpperCase().startsWith(HttpArgsType.X_WWW_FORM_URLENCODED.toUpperCase())) {
List<NameValuePair> nvps = new ArrayList<>();
for (Map.Entry<String, Object> entry : paramsMap.entrySet()) {
nvps.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
}
httpPost.setEntity(new UrlEncodedFormEntity(nvps));
// } else if (contentType.toUpperCase().startsWith(HttpArgsType.APPLICATION_JSON.toUpperCase())) {
} else{
StringEntity stringEntity = new StringEntity(JSON.toJSONString(paramsMap),DEFAULT_ENCODING);
httpPost.setEntity(stringEntity);
}
return httpPost;
}
public HttpPost uploadFileByInputStream(String url,InputStream inputStream, String fileKey,String fileName,
Map<String, Object> params, Map<String, String> headers){
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
builder.setCharset(StandardCharsets.UTF_8);
builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
builder.addBinaryBody(fileKey,inputStream, ContentType.MULTIPART_FORM_DATA,fileName);
ContentType contentType= ContentType.create("text/plain",StandardCharsets.UTF_8);
for (Map.Entry<String,Object> param : params.entrySet()){
StringBody stringBody = new StringBody(String.valueOf(param.getValue()), contentType);
builder.addPart(param.getKey(),stringBody);
}
HttpPost httpPost = new HttpPost(url.trim());
for (Map.Entry<String, String> entry : headers.entrySet()) {
if("Content-Type".equalsIgnoreCase(entry.getKey())){
continue;
}
httpPost.setHeader(entry.getKey(), entry.getValue());
}
HttpEntity entity = builder.build();
httpPost.setEntity(entity);
return httpPost;
}
public HttpPost uploadFileByInputStream(String url,File file, String fileKey,String fileName,
Map<String, Object> params, Map<String, String> headers){
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
builder.addBinaryBody(fileKey,file, ContentType.MULTIPART_FORM_DATA,fileName);
for (Map.Entry<String,Object> param : params.entrySet()){
StringBody stringBody = new StringBody(String.valueOf(param.getValue()),ContentType.MULTIPART_FORM_DATA);
builder.addPart(param.getKey(),stringBody);
}
HttpPost httpPost = new HttpPost(url.trim());
for (Map.Entry<String, String> entry : headers.entrySet()) {
if("Content-Type".equalsIgnoreCase(entry.getKey())){
continue;
}
httpPost.setHeader(entry.getKey(), entry.getValue());
}
HttpEntity entity = builder.build();
httpPost.setEntity(entity);
return httpPost;
}
private HttpPut handleHttpPut(String url, Map<String, String> headerMap, Map<String, Object> paramsMap) throws UnsupportedEncodingException {
String contentType = "";
HttpPut httpPut = new HttpPut(url.trim());
for (Map.Entry<String, String> entry : headerMap.entrySet()) {
httpPut.setHeader(entry.getKey(), entry.getValue());
if ("Content-Type".equalsIgnoreCase(entry.getKey())) {
contentType = entry.getValue();
}
}
if (Strings.isNullOrEmpty(contentType)) {
List<NameValuePair> nvps = new ArrayList<>();
for (Map.Entry<String, Object> entry : paramsMap.entrySet()) {
nvps.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
}
httpPut.setHeader("Content-Type", HttpArgsType.DEFAULT_CONTENT_TYPE);
httpPut.setEntity(new UrlEncodedFormEntity(nvps));
} else if (contentType.toUpperCase().startsWith(HttpArgsType.X_WWW_FORM_URLENCODED.toUpperCase())) {
List<NameValuePair> nvps = new ArrayList<>();
for (Map.Entry<String, Object> entry : paramsMap.entrySet()) {
nvps.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
}
httpPut.setEntity(new UrlEncodedFormEntity(nvps));
} else if (contentType.toUpperCase().startsWith(HttpArgsType.APPLICATION_JSON.toUpperCase())) {
StringEntity stringEntity = new StringEntity(JSON.toJSONString(paramsMap),DEFAULT_ENCODING);
httpPut.setEntity(stringEntity);
}
return httpPut;
}
private String inputStreamToString(InputStream is) {
String line = "";
StringBuilder total = new StringBuilder();
BufferedReader rd = new BufferedReader(new InputStreamReader(is));
try {
while ((line = rd.readLine()) != null) {
total.append(line);
}
} catch (IOException e) {
toolUtil.writeErrorLog(e.getLocalizedMessage() + "\n" + e);
}
return total.toString();
}
public Map<String, String> headersHandle(Map<String, String> headers) {
Map<String, String> map = new HashMap<>();
if (headers != null && headers.size() > 0) {
if (globalCache.header != null && globalCache.header.size() > 0) {
map.putAll(globalCache.header);
}
map.putAll(headers);
} else {
map.putAll(globalCache.header);
}
return map;
}
public Map<String, Object> paramsHandle(Map<String, Object> params) {
Map<String, Object> map = new HashMap<>();
if (params != null && params.size() > 0) {
if (globalCache.paramMap != null && globalCache.paramMap.size() > 0) {
map.putAll(globalCache.paramMap);
}
map.putAll(params);
} else {
map.putAll(globalCache.paramMap);
}
return map;
}
public String urlHandle(String url, Map<String, Object> params) {
if (params == null || params.size() <= 0) {
return url;
}
String serializeParams = serializeParams(params);
String getUrl;
if (!url.contains("?")) {
if (url.endsWith("/")) {
getUrl = url.substring(0, url.length() - 1) + "?" + serializeParams;
} else {
getUrl = url + "?" + serializeParams;
}
} else {
if (url.endsWith("?")) {
getUrl = url + serializeParams;
} else {
getUrl = url + "&" + serializeParams;
}
}
return getUrl;
}
private String serializeParams(Map<String, Object> params) {
if (params != null && params.size() > 0) {
StringBuilder builder = new StringBuilder();
for (Map.Entry<String, Object> entry : params.entrySet()) {
builder.append("&");
builder.append(entry.getKey());
builder.append("=");
builder.append(entry.getValue());
}
return removeSeparator(builder);
}
return "";
}
private String removeSeparator(StringBuilder sqlBuilder) {
String str = sqlBuilder.toString().trim();
String removeSeparator = "&";
if (str.endsWith(removeSeparator)) {
// 如果以分&号结尾,则去除&号
str = str.substring(0, str.length() - 1);
}
if (str.trim().startsWith(removeSeparator)) {
// 如果以&开头,则去除&
str = str.substring(1);
}
return str;
}
}