HttpClient工具类(包含请求头设置及请求示例)

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 headMap, Map 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 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 headMap,Map 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 headers,Map 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 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 该方法为sendPostRequest(String,String,boolean,String,String)的简化方法
	 * @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
	 * @see 当isEncoder=true时,其会自动对sendData中的[中文][|][
	 *      ]等特殊字符进行URLEncoder.encode(string,"UTF-8")
	 * @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 当isEncoder=true时,其会自动对sendData中的[中文][|][
	 *      ]等特殊字符进行URLEncoder.encode(string,encodeCharset)
	 * @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 formParams = new ArrayList();
				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 该方法会自动对params中的[中文][|][
	 *      ]等特殊字符进行URLEncoder.encode(string,encodeCharset)
	 * @param reqURL
	 *            请求地址
	 * @param params
	 *            请求参数
	 * @param encodeCharset
	 *            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
	 * @param decodeCharset
	 *            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
	 * @return 远程主机响应正文
	 */
	public static String sendPostRequest(String reqURL, Map params, String encodeCharset,
			String decodeCharset) {
		String responseContent = null;
		HttpClient httpClient = new DefaultHttpClient();

		HttpPost httpPost = new HttpPost(reqURL);
		List formParams = new ArrayList(); // 创建参数队列
		for (Map.Entry 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 该方法为sendPostSSLRequest(String,Map,String,String)方法的简化方法
	 * @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
	 * @see 该方法会自动对params中的[中文][|][
	 *      ]等特殊字符进行URLEncoder.encode(string,"UTF-8")
	 */
	public static String sendPostSSLRequest(String reqURL, Map params) {
		return sendPostSSLRequest(reqURL, params, null, null);
	}

	/**
	 * 发送HTTPS_POST请求
	 * 
	 * @see 该方法会自动关闭连接,释放资源
	 * @see 该方法会自动对params中的[中文][|][
	 *      ]等特殊字符进行URLEncoder.encode(string,encodeCharset)
	 * @param reqURL
	 *            请求地址
	 * @param params
	 *            请求参数
	 * @param encodeCharset
	 *            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
	 * @param decodeCharset
	 *            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
	 * @return 远程主机响应正文
	 */
	public static String sendPostSSLRequest(String reqURL, Map 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 formParams = new ArrayList();
			for (Map.Entry 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 若发送的params中含有中文,记得按照双方约定的字符集将中文URLEncoder.encode(string,encodeCharset)
	 * @see 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒
	 * @param reqURL
	 *            请求地址
	 * @param params
	 *            发送到远程主机的正文数据,其数据类型为java.util.Map
	 * @return 远程主机响应正文`HTTP状态码,如"SUCCESS`200"
* 若通信过程中发生异常则返回"Failed`HTTP状态码",如"Failed`500" */ public static String sendPostRequestByJava(String reqURL, Map params) { StringBuilder sendData = new StringBuilder(); for (Map.Entry 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 若发送的sendData中含有中文,记得按照双方约定的字符集将中文URLEncoder.encode(string,encodeCharset) * @see 本方法默认的连接超时时间为30秒,默认的读取超时时间为30秒 * @param reqURL * 请求地址 * @param sendData * 发送到远程主机的正文数据 * @return 远程主机响应正文`HTTP状态码,如"SUCCESS`200"
* 若通信过程中发生异常则返回"Failed`HTTP状态码",如"Failed`500" */ 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 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 formParams = new ArrayList(); // 构建POST请求的表单参数 for (Map.Entry 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 headers, Map 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 keys = headers.keySet(); for (Map.Entry 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 headmap = new HashMap(); headmap.put("Access-Token", "sund2f3bf3e7ecea902bcdb7027e9139a02"); Map paramap = new HashMap(); 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); } } }

请求示例:

        // 设置请求参数
		Map param = new HashMap();
		param.put("test", "test");
		// 设置请求头信息
		Map headMap =new HashMap();
		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");

 

你可能感兴趣的:(#,Java基础,JavaWeb开发基础)