httputil

作者: 洪君_ | 来源:发表于2020-07-17 00:48 被阅读0次

 

https://blog.csdn.net/lchq1995/article/details/88293047

      // 设置请求参数

Map<String, String> param = new HashMap<String, String>();

param.put("test", "test");

// 设置请求头信息

Map<String, String> headMap =new HashMap<String, String>();

headMap.put("Authorization", token);

        headMap.put("Content-type", "application/json");

        // 判断token获取的user信息

    String tkJson = HttpClientUtils.connectPost(ssoGetUserURL, headMap, param);

        JSONObject resultJson = JSONObject.fromObject(tkJson);

        String employeeNo=json.getString("EmployeeNo");

import java.io.BufferedReader;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.net.HttpURLConnection;

import java.net.URI;

import java.net.URL;

import java.net.URLConnection;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.security.cert.CertificateException;

import java.security.cert.X509Certificate;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.net.ssl.SSLContext;

import javax.net.ssl.SSLException;

import javax.net.ssl.SSLSession;

import javax.net.ssl.SSLSocket;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.http.Consts;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.HttpStatus;

import org.apache.http.NameValuePair;

import org.apache.http.ParseException;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.config.RequestConfig;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.client.methods.RequestBuilder;

import org.apache.http.client.utils.URIBuilder;

import org.apache.http.client.utils.URLEncodedUtils;

import org.apache.http.conn.scheme.Scheme;

import org.apache.http.conn.ssl.SSLSocketFactory;

import org.apache.http.conn.ssl.X509HostnameVerifier;

import org.apache.http.entity.ByteArrayEntity;

import org.apache.http.entity.ContentType;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.impl.client.HttpClients;

import org.apache.http.message.BasicHeader;

import org.apache.http.message.BasicNameValuePair;

import org.apache.http.params.BasicHttpParams;

import org.apache.http.params.HttpConnectionParams;

import org.apache.http.params.HttpParams;

import org.apache.http.protocol.HTTP;

import org.apache.http.util.ByteArrayBuffer;

import org.apache.http.util.EntityUtils;

/**

* 封装了一些采用HttpClient发送HTTP请求的方法

*

* @see 本工具所采用的是最新的HttpComponents-Client-4.2.1

*/

public class HttpClientUtils {

private static Log logger = LogFactory.getLog(HttpClientUtils.class);

/**

* 设置请求头和参数 post提交

*

* @param urlStr

*            地址

* @param headMap

*            请求头

* @param paramMap

*            内容参数

* @return

*/

public static String connectPost(String urlStr, Map<String, String> headMap, Map<String, String> paramMap) {

logger.info("========设置请求头和参数并以 post提交=======");

URL url;

String sCurrentLine = "";

String sTotalString = "";

DataOutputStream out = null;

try {

url = new URL(urlStr);

logger.info("请求地址:" + urlStr);

URLConnection URLconnection = url.openConnection();

HttpURLConnection httpConnection = (HttpURLConnection) URLconnection;

// httpConnection.setRequestProperty("Content-type", "application/json");

httpConnection.setRequestProperty("Accept-Charset", "utf-8");

httpConnection.setRequestProperty("contentType", "utf-8");

if (headMap != null && !headMap.isEmpty()) {

for (String key : headMap.keySet()) {

logger.info("头部信息key:" + key + "===值: " + headMap.get(key));

httpConnection.setRequestProperty(key, headMap.get(key));

}

}

httpConnection.setRequestMethod("POST");

httpConnection.setDoOutput(true);

httpConnection.setDoInput(true);

StringBuffer params = new StringBuffer();

// 表单参数与get形式一样

if (paramMap != null && !paramMap.isEmpty()) {

for (String key : paramMap.keySet()) {

if (params.length() > 1) {

params.append("&");

}

params.append(key).append("=").append(paramMap.get(key).trim());

}

logger.info("请求参数: " + params.toString());

}

//System.out.println("params = " + params.toString());

out = new DataOutputStream(httpConnection.getOutputStream());

// 发送请求参数

if (params!=null) {

out.writeBytes(params.toString());

}

// flush输出流的缓冲

out.flush();

// int responseCode = httpConnection.getResponseCode();

// if (responseCode == HttpURLConnection.HTTP_OK) {

InputStream urlStream = httpConnection.getInputStream();

BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(urlStream));

while ((sCurrentLine = bufferedReader.readLine()) != null) {

sTotalString += sCurrentLine;

}

// //System.out.println(sTotalString);

// 假设该url页面输出为"OK"

// }else{

// System.err.println("FIAL");

// }

} catch (Exception e) {

logger.info("请求错误: " + e.getMessage());

logger.error("系统错误:",e);

} finally {

}

logger.info("响应信息: " + sTotalString);

return sTotalString;

}

public static void test() throws Exception{

        String url = "http://******/api/hdfs/proxy/create?username=******&password=*****&uri=/test/test-xx.txt";

        byte[] bytes = "1".getBytes();

        HttpClient client = HttpClients.createDefault();

        RequestBuilder requestBuilder = RequestBuilder.post();

        requestBuilder.setEntity(new ByteArrayEntity(bytes));

        requestBuilder.setUri(url);

        HttpResponse response = client.execute(requestBuilder.build());

        HttpEntity entity = response.getEntity();

        //获得响应流

        InputStream is = entity.getContent();

        //读取流中内容

        ByteArrayBuffer buffer = new ByteArrayBuffer(4096);

        byte[] tmp = new byte[4096];

        int count;

        try {

            while ((count = is.read(tmp)) != -1) {

                buffer.append(tmp, 0, count);

            }

        } catch (EOFException e) {

            logger.error("系统错误:",e);

        }

        //System.out.println(new String(buffer.toByteArray()));

    }

/**

* Http Get方法

*

* @param url

* @param param

* @return

*/

public static String doGet(String url, Map<String, String> param) {

// 创建Httpclient对象

CloseableHttpClient httpclient = HttpClients.createDefault();

String resultString = "";

CloseableHttpResponse response = null;

try {

// 创建uri

URIBuilder builder = new URIBuilder(url);

if (param != null) {

for (String key : param.keySet()) {

builder.addParameter(key, param.get(key));

}

}

URI uri = builder.build();

// 创建http GET请求

HttpGet httpGet = new HttpGet(uri);

// 执行请求

response = httpclient.execute(httpGet);

// 判断返回状态是否为200

if (response.getStatusLine().getStatusCode() == 200) {

resultString = EntityUtils.toString(response.getEntity(), "UTF-8");

}

} catch (Exception e) {

logger.error("系统错误:",e);

} finally {

try {

if (response != null) {

response.close();

}

httpclient.close();

} catch (IOException e) {

logger.error("系统错误:",e);

}

}

return resultString;

}

/**

* Http Get方法

*

* @param url

* @param param

* @return

*/

public static String doGet(String url,Map<String, String> headMap,Map<String, String> param) {

// 创建Httpclient对象

CloseableHttpClient httpclient = HttpClients.createDefault();

String resultString = "";

CloseableHttpResponse response = null;

try {

// 创建uri

URIBuilder builder = new URIBuilder(url);

if (param != null) {

for (String key : param.keySet()) {

builder.addParameter(key, param.get(key));

}

}

URI uri = builder.build();

// 创建http GET请求

HttpGet httpGet = new HttpGet(uri);

if (headMap != null && !headMap.isEmpty()) {

for (String key : headMap.keySet()) {

logger.info("头部信息key:" + key + "===值: " + headMap.get(key));

httpGet.addHeader(key, headMap.get(key));

}

}

// 执行请求

response = httpclient.execute(httpGet);

// 判断返回状态是否为200

if (response.getStatusLine().getStatusCode() == 200) {

resultString = EntityUtils.toString(response.getEntity(), "UTF-8");

}

} catch (Exception e) {

logger.error("系统错误:",e);

} finally {

try {

if (response != null) {

response.close();

}

httpclient.close();

} catch (IOException e) {

logger.error("系统错误:",e);

}

}

return resultString;

}

public static String doGet(String url) {

return doGet(url, null);

}

/**

* httpclient post方法

*

* @param url

* @param param

* @return

*/

public static String doPost(String url,Map<String, String> headers,Map<String, String> param) {

// 创建Httpclient对象

CloseableHttpClient httpClient = HttpClients.createDefault();

CloseableHttpResponse response = null;

String resultString = "";

try {

// 创建Http Post请求

HttpPost httpPost = new HttpPost(url);

if(headers != null) {

for (String key : headers.keySet()) {

httpPost.setHeader(key, headers.get(key));

}

}

// 创建参数列表

if (param != null) {

List<NameValuePair> paramList = new ArrayList<>();

for (String key : param.keySet()) {

paramList.add(new BasicNameValuePair(key, param.get(key)));

}

// 模拟表单

UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");

httpPost.setEntity(entity);

}

// 执行http请求

response = httpClient.execute(httpPost);

resultString = EntityUtils.toString(response.getEntity(), "utf-8");

} catch (Exception e) {

logger.error("系统错误:",e);

} finally {

try {

if (response!=null) {

response.close();

}

} catch (IOException e) {

logger.error("系统错误:",e);

}

}

return resultString;

}

public static String doPost(String url) {

return doPost(url,null,null);

}

/**

* 请求的参数类型为json

*

* @param url

* @param json

* @return {username:"",pass:""}

*/

public static String doPostJson(String url, String json) {

logger.info("=====请求地址:"+url);

// 创建Httpclient对象

CloseableHttpClient httpClient = HttpClients.createDefault();

CloseableHttpResponse response = null;

String resultString = "";

try {

// 创建Http Post请求

HttpPost httpPost = new HttpPost(url);

// 创建请求内容

logger.info("=====请求参数:"+json);

StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);

httpPost.setEntity(entity);

// 执行http请求

response = httpClient.execute(httpPost);

logger.info("=====响应参数:"+response);

resultString = EntityUtils.toString(response.getEntity(), "utf-8");

} catch (Exception e) {

logger.error("系统错误:",e);

} finally {

try {

if (response!=null) {

response.close();

}

} catch (IOException e) {

logger.error("系统错误:",e);

}

}

return resultString;

}

/**

* 发送HTTP_GET请求

*

* @see 该方法会自动关闭连接,释放资源

* @param requestURL

*            请求地址(含参数)

* @param decodeCharset

*            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码

* @return 远程主机响应正文

*/

public static String sendGetRequest(String reqURL, String decodeCharset) {

long responseLength = 0; // 响应长度

String responseContent = null; // 响应内容

HttpClient httpClient = new DefaultHttpClient(); // 创建默认的httpClient实例

HttpGet httpGet = new HttpGet(reqURL); // 创建org.apache.http.client.methods.HttpGet

try {

HttpResponse response = httpClient.execute(httpGet); // 执行GET请求

HttpEntity entity = response.getEntity(); // 获取响应实体

if (null != entity) {

responseLength = entity.getContentLength();

responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);

EntityUtils.consume(entity); // Consume response content

}

//System.out.println("请求地址: " + httpGet.getURI());

//System.out.println("响应状态: " + response.getStatusLine());

//System.out.println("响应长度: " + responseLength);

//System.out.println("响应内容: " + responseContent);

} catch (ClientProtocolException e) {

logger.debug("该异常通常是协议错误导致,比如构造HttpGet对象时传入的协议不对(将'http'写成'htp')或者服务器端返回的内容不符合HTTP协议要求等,堆栈信息如下", e);

} catch (ParseException e) {

logger.debug(e.getMessage(), e);

} catch (IOException e) {

logger.debug("该异常通常是网络原因引起的,如HTTP服务器未启动等,堆栈信息如下", e);

} finally {

httpClient.getConnectionManager().shutdown(); // 关闭连接,释放资源

}

return responseContent;

}

/**

* 发送HTTP_POST请求

*

* @see 该方法为<code>sendPostRequest(String,String,boolean,String,String)</code>的简化方法

* @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8

* @see 当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][

*      ]等特殊字符进行<code>URLEncoder.encode(string,"UTF-8")</code>

* @param isEncoder

*            用于指明请求数据是否需要UTF-8编码,true为需要

*/

public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder) {

return sendPostRequest(reqURL, sendData, isEncoder, null, null);

}

/**

* 发送HTTP_POST请求

*

* @see 该方法会自动关闭连接,释放资源

* @see 当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][

*      ]等特殊字符进行<code>URLEncoder.encode(string,encodeCharset)</code>

* @param reqURL

*            请求地址

* @param sendData

*            请求参数,若有多个参数则应拼接成param11=value11&22=value22&33=value33的形式后,传入该参数中

* @param isEncoder

*            请求数据是否需要encodeCharset编码,true为需要

* @param encodeCharset

*            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码

* @param decodeCharset

*            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码

* @return 远程主机响应正文

*/

public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder, String encodeCharset,

String decodeCharset) {

String responseContent = null;

HttpClient httpClient = new DefaultHttpClient();

HttpPost httpPost = new HttpPost(reqURL);

// httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded;

// charset=UTF-8");

httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");

try {

if (isEncoder) {

List<NameValuePair> formParams = new ArrayList<NameValuePair>();

for (String str : sendData.split("&")) {

formParams.add(new BasicNameValuePair(str.substring(0, str.indexOf("=")),

str.substring(str.indexOf("=") + 1)));

}

httpPost.setEntity(new StringEntity(

URLEncodedUtils.format(formParams, encodeCharset == null ? "UTF-8" : encodeCharset)));

} else {

httpPost.setEntity(new StringEntity(sendData));

}

HttpResponse response = httpClient.execute(httpPost);

HttpEntity entity = response.getEntity();

if (null != entity) {

responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);

EntityUtils.consume(entity);

}

} catch (Exception e) {

logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下", e);

} finally {

httpClient.getConnectionManager().shutdown();

}

return responseContent;

}

/**

* 发送HTTP_POST请求

*

* @see 该方法会自动关闭连接,释放资源

* @see 该方法会自动对<code>params</code>中的[中文][|][

*      ]等特殊字符进行<code>URLEncoder.encode(string,encodeCharset)</code>

* @param reqURL

*            请求地址

* @param params

*            请求参数

* @param encodeCharset

*            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码

* @param decodeCharset

*            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码

* @return 远程主机响应正文

*/

public static String sendPostRequest(String reqURL, Map<String, String> params, String encodeCharset,

String decodeCharset) {

String responseContent = null;

HttpClient httpClient = new DefaultHttpClient();

HttpPost httpPost = new HttpPost(reqURL);

List<NameValuePair> formParams = new ArrayList<NameValuePair>(); // 创建参数队列

for (Map.Entry<String, String> entry : params.entrySet()) {

formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));

}

try {

httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset == null ? "UTF-8" : encodeCharset));

HttpResponse response = httpClient.execute(httpPost);

HttpEntity entity = response.getEntity();

if (null != entity) {

responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);

EntityUtils.consume(entity);

}

} catch (Exception e) {

logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下", e);

} finally {

httpClient.getConnectionManager().shutdown();

}

return responseContent;

}

/**

* 发送HTTPS_POST请求

*

* @see 该方法为<code>sendPostSSLRequest(String,Map<String,String>,String,String)</code>方法的简化方法

* @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8

* @see 该方法会自动对<code>params</code>中的[中文][|][

*      ]等特殊字符进行<code>URLEncoder.encode(string,"UTF-8")</code>

*/

public static String sendPostSSLRequest(String reqURL, Map<String, String> params) {

return sendPostSSLRequest(reqURL, params, null, null);

}

/**

* 发送HTTPS_POST请求

*

* @see 该方法会自动关闭连接,释放资源

* @see 该方法会自动对<code>params</code>中的[中文][|][

*      ]等特殊字符进行<code>URLEncoder.encode(string,encodeCharset)</code>

* @param reqURL

*            请求地址

* @param params

*            请求参数

* @param encodeCharset

*            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码

* @param decodeCharset

*            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码

* @return 远程主机响应正文

*/

public static String sendPostSSLRequest(String reqURL, Map<String, String> params, String encodeCharset,

String decodeCharset) {

String responseContent = "";

HttpClient httpClient = new DefaultHttpClient();

X509TrustManager xtm = new X509TrustManager() {

public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {

}

public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {

}

public X509Certificate[] getAcceptedIssuers() {

return null;

}

};

try {

SSLContext ctx = SSLContext.getInstance("TLS");

ctx.init(null, new TrustManager[] { xtm }, null);

SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);

httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 443, socketFactory));

HttpPost httpPost = new HttpPost(reqURL);

List<NameValuePair> formParams = new ArrayList<NameValuePair>();

for (Map.Entry<String, String> entry : params.entrySet()) {

formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));

}

httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset == null ? "UTF-8" : encodeCharset));

HttpResponse response = httpClient.execute(httpPost);

HttpEntity entity = response.getEntity();

if (null != entity) {

responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);

EntityUtils.consume(entity);

}

} catch (Exception e) {

logger.debug("与[" + reqURL + "]通信过程中发生异常,堆栈信息为", e);

} finally {

httpClient.getConnectionManager().shutdown();

}

return responseContent;

}

/**

* 发送HTTP_POST请求

*

* @see 若发送的<code>params</code>中含有中文,记得按照双方约定的字符集将中文<code>URLEncoder.encode(string,encodeCharset)</code>

* @see 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒

* @param reqURL

*            请求地址

* @param params

*            发送到远程主机的正文数据,其数据类型为<code>java.util.Map<String, String></code>

* @return 远程主机响应正文`HTTP状态码,如<code>"SUCCESS`200"</code><br>

*        若通信过程中发生异常则返回"Failed`HTTP状态码",如<code>"Failed`500"</code>

*/

public static String sendPostRequestByJava(String reqURL, Map<String, String> params) {

StringBuilder sendData = new StringBuilder();

for (Map.Entry<String, String> entry : params.entrySet()) {

sendData.append(entry.getKey()).append("=").append(entry.getValue()).append("&");

}

if (sendData.length() > 0) {

sendData.setLength(sendData.length() - 1); // 删除最后一个&符号

}

return sendPostRequestByJava(reqURL, sendData.toString());

}

/**

* 发送HTTP_POST请求

*

* @see 若发送的<code>sendData</code>中含有中文,记得按照双方约定的字符集将中文<code>URLEncoder.encode(string,encodeCharset)</code>

* @see 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒

* @param reqURL

*            请求地址

* @param sendData

*            发送到远程主机的正文数据

* @return 远程主机响应正文`HTTP状态码,如<code>"SUCCESS`200"</code><br>

*        若通信过程中发生异常则返回"Failed`HTTP状态码",如<code>"Failed`500"</code>

*/

public static String sendPostRequestByJava(String reqURL, String sendData) {

HttpURLConnection httpURLConnection = null;

OutputStream out = null; // 写

InputStream in = null; // 读

int httpStatusCode = 0; // 远程主机响应的HTTP状态码

try {

URL sendUrl = new URL(reqURL);

httpURLConnection = (HttpURLConnection) sendUrl.openConnection();

httpURLConnection.setRequestMethod("POST");

httpURLConnection.setDoOutput(true); // 指示应用程序要将数据写入URL连接,其值默认为false

httpURLConnection.setUseCaches(false);

httpURLConnection.setConnectTimeout(30000); // 30秒连接超时

httpURLConnection.setReadTimeout(30000); // 30秒读取超时

out = httpURLConnection.getOutputStream();

out.write(sendData.toString().getBytes());

// 清空缓冲区,发送数据

out.flush();

// 获取HTTP状态码

httpStatusCode = httpURLConnection.getResponseCode();

in = httpURLConnection.getInputStream();

byte[] byteDatas = new byte[in.available()];

in.read(byteDatas);

return new String(byteDatas) + "`" + httpStatusCode;

} catch (Exception e) {

logger.debug(e.getMessage());

return "Failed`" + httpStatusCode;

} finally {

if (out != null) {

try {

out.close();

} catch (Exception e) {

logger.debug("关闭输出流时发生异常,堆栈信息如下", e);

}

}

if (in != null) {

try {

in.close();

} catch (Exception e) {

logger.debug("关闭输入流时发生异常,堆栈信息如下", e);

}

}

if (httpURLConnection != null) {

httpURLConnection.disconnect();

httpURLConnection = null;

}

}

}

/**

* https posp请求,可以绕过证书校验

*

* @param url

* @param params

* @return

*/

public static final String sendHttpsRequestByPost(String url, Map<String, String> params) {

String responseContent = null;

HttpClient httpClient = new DefaultHttpClient();

// 创建TrustManager

X509TrustManager xtm = new X509TrustManager() {

public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {

}

public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {

}

public X509Certificate[] getAcceptedIssuers() {

return null;

}

};

// 这个好像是HOST验证

X509HostnameVerifier hostnameVerifier = new X509HostnameVerifier() {

public boolean verify(String arg0, SSLSession arg1) {

return true;

}

public void verify(String arg0, SSLSocket arg1) throws IOException {

}

public void verify(String arg0, String[] arg1, String[] arg2) throws SSLException {

}

public void verify(String arg0, X509Certificate arg1) throws SSLException {

}

};

try {

// TLS1.0与SSL3.0基本上没有太大的差别,可粗略理解为TLS是SSL的继承者,但它们使用的是相同的SSLContext

SSLContext ctx = SSLContext.getInstance("TLS");

// 使用TrustManager来初始化该上下文,TrustManager只是被SSL的Socket所使用

ctx.init(null, new TrustManager[] { xtm }, null);

// 创建SSLSocketFactory

SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);

socketFactory.setHostnameVerifier(hostnameVerifier);

// 通过SchemeRegistry将SSLSocketFactory注册到我们的HttpClient上

httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", socketFactory, 443));

HttpPost httpPost = new HttpPost(url);

List<NameValuePair> formParams = new ArrayList<NameValuePair>(); // 构建POST请求的表单参数

for (Map.Entry<String, String> entry : params.entrySet()) {

formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));

}

httpPost.setEntity(new UrlEncodedFormEntity(formParams, "UTF-8"));

HttpResponse response = httpClient.execute(httpPost);

HttpEntity entity = response.getEntity(); // 获取响应实体

if (entity != null) {

responseContent = EntityUtils.toString(entity, "UTF-8");

}

} catch (KeyManagementException e) {

logger.error("系统错误:",e);

} catch (NoSuchAlgorithmException e) {

logger.error("系统错误:",e);

} catch (UnsupportedEncodingException e) {

logger.error("系统错误:",e);

} catch (ClientProtocolException e) {

logger.error("系统错误:",e);

} catch (ParseException e) {

logger.error("系统错误:",e);

} catch (IOException e) {

logger.error("系统错误:",e);

} finally {

// 关闭连接,释放资源

httpClient.getConnectionManager().shutdown();

}

return responseContent;

}

/**

* 发送HTTP_POST请求,json格式数据

*

* @param url

* @param body

* @return

* @throws Exception

*/

public static String sendPostByJson(String url, String body) throws Exception {

CloseableHttpClient httpclient = HttpClients.custom().build();

HttpPost post = null;

String resData = null;

CloseableHttpResponse result = null;

try {

post = new HttpPost(url);

HttpEntity entity2 = new StringEntity(body, Consts.UTF_8);

post.setConfig(RequestConfig.custom().setConnectTimeout(30000).setSocketTimeout(30000).build());

post.setHeader("Content-Type", "application/json");

post.setHeader("Access-Token", "sund2f3bf3e7ecea902bcdb7027e9139a02");

post.setEntity(entity2);

result = httpclient.execute(post);

if (HttpStatus.SC_OK == result.getStatusLine().getStatusCode()) {

resData = EntityUtils.toString(result.getEntity());

}

} finally {

if (result != null) {

result.close();

}

if (post != null) {

post.releaseConnection();

}

httpclient.close();

}

return resData;

}

/**

* HttpPost发送header,Content(json格式)

*

* @param url

* @param json

* @param headers

* @return

*/

public static String post(String url, Map<String, String> headers, Map<String, String> jsonMap) {

HttpClient client = new DefaultHttpClient();

HttpPost post = new HttpPost(url);

logger.info("请求地址:" + url);

// post.setHeader("Content-Type", "application/x-www-form-urlencoded");

logger.info("请求头信息:" + headers);

if (headers != null) {

Set<String> keys = headers.keySet();

for (Map.Entry<String, String> entrdy : headers.entrySet()) {

post.addHeader(entrdy.getKey(), entrdy.getValue());

//System.out.println("headers:" + entrdy.getKey() + ",值" + entrdy.getValue());

}

}

String charset = null;

try {

StringEntity s = new StringEntity(jsonMap.toString(), "utf-8");

logger.info("请求json参数:" + jsonMap);

// s.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));

// s.setContentType("application/json");

// s.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));

post.setEntity(s);

logger.info("请求实体数据:" + post);

// HttpResponse res = client.execute(post);

HttpResponse httpResponse = client.execute(post);

InputStream inStream = httpResponse.getEntity().getContent();

BufferedReader reader = new BufferedReader(new InputStreamReader(inStream, "utf-8"));

StringBuilder strber = new StringBuilder();

String line = null;

while ((line = reader.readLine()) != null)

strber.append(line + "\n");

inStream.close();

logger.info("MobilpriseActivity:" + strber);

if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {

HttpEntity entity = httpResponse.getEntity();

charset = EntityUtils.getContentCharSet(entity);

}

} catch (Exception e) {

logger.info("报错咯:" + e.getMessage());

throw new RuntimeException(e);

}

logger.info("响应参数:" + charset);

return charset;

}

public static void main(String[] args) {

try {

Map<String,String> headmap =  new HashMap<String,String>();

headmap.put("Access-Token", "sund2f3bf3e7ecea902bcdb7027e9139a02");

Map<String,String> paramap =  new HashMap<String,String>();

paramap.put("customerDeptId", "38");

paramap.put("postCode", "qqqq");

System.out.println(doPost("http://10.39.137.100/api/needs/getInfoByCondition",headmap,paramap));

//System.out.println(sendPostByJson("http://10.39.137.100/api/needs/getInfoByCondition","{\"customerDeptId\":38,\"postCode\":\"qqqq\"}"));

} catch (Exception e) {

logger.error("系统错误:",e);

}

}

}

 

相关文章

  • HTTP网络通信工具

    HttpUtil

  • HTTPUTIL

    在网络请求中开启新线程,服务器响应的数据无法进行返回,因为所有耗时的逻辑都是在子线程里进行,请求方法会在服务器没来...

  • httputil

    https://blog.csdn.net/lchq1995/article/details/88293047 ...

  • httputil

    https://blog.csdn.net/lchq1995/article/details/88293047 ...

  • 从国家统计局爬取省市区信息

    Location HttpUtil 爬虫代码

  • oss 上传照片

    impor thttputilfrom'../httputil' export default{ props:{ ...

  • net/httputil

    httputil包提供了HTTP公用函数,是对net/http包的更常见函数的补充 反向代理的实现 Reverse...

  • HttpUtil工具

    HttpUtil工具,http get post请求,https get post请求,ajax response...

  • Http请求工具类

    一、引入架包 二、HttpUtil工具类 三、使用示例

  • HttpClient 的一次Timeout waiting fo

    设置了defaultMaxPerRoute为20。maxTotal设置为100. HttpUtil工具类,主要负责...

网友评论

      本文标题:httputil

      本文链接:https://www.haomeiwen.com/subject/ygwvhktx.html