get/post请求工具类

以下代码仅为个人记录的工具类
HttpClientResult ：
package com.example.demo.utils;

import java.io.Serializable;

public class HttpClientResult implements Serializable {
/**
* 响应状态码
*/
private int code;

/**
 * 响应数据
 */
private String data;

public HttpClientResult() {
}

public HttpClientResult(int code) {
	this.code = code;
}

public HttpClientResult(int code, String data) {
	this.code = code;
	this.data = data;
}

public int getCode() {
	return code;
}

public void setCode(int code) {
	this.code = code;
}

public String getData() {
	return data;
}

public void setData(String data) {
	this.data = data;
}

@Override
public String toString() {
	return "HttpClientResult [code=" + code + ", data=" + data + "]";
}

}

HttpClientUtils ：
package com.example.zhwj.utils;

import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.*;

public class HttpClientUtils {

// 编码格式。发送编码格式统一用UTF-8
private static final String ENCODING = "GBK";

// 设置连接超时时间，单位毫秒。
private static final int CONNECT_TIMEOUT = 6000;

// 请求获取数据的超时时间(即响应时间)，单位毫秒。
private static final int SOCKET_TIMEOUT = 6000;

/**
 * 发送get请求；不带请求头和请求参数
 *
 * @param url 请求地址
 * @return
 * @throws Exception
 */
public static HttpClientResult doGet(String url) throws Exception {
	return doGet(url, null, null);
}

/**
 * 发送get请求；带请求参数
 *
 * @param url 请求地址
 * @param params 请求参数集合
 * @return
 * @throws Exception
 */
public static HttpClientResult doGet(String url, Map<String, String> params) throws Exception {
	return doGet(url, null, params);
}

/**
 * 发送get请求；带请求头和请求参数
 *
 * @param url 请求地址
 * @param headers 请求头集合
 * @param params 请求参数集合
 * @return
 * @throws Exception
 */
public static HttpClientResult doGet(String url, Map<String, String> headers, Map<String, String> params) throws Exception {
	// 创建httpClient对象
	CloseableHttpClient httpClient = HttpClients.createDefault();

	// 创建访问的地址
	URIBuilder uriBuilder = new URIBuilder(url);
	if (params != null) {
		Set<Map.Entry<String, String>> entrySet = params.entrySet();
		for (Map.Entry<String, String> entry : entrySet) {
			uriBuilder.setParameter(entry.getKey(), entry.getValue());
		}
	}

	// 创建http对象
	HttpGet httpGet = new HttpGet(uriBuilder.build());
	/**
	 * setConnectTimeout：设置连接超时时间，单位毫秒。
	 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
	 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
	 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
	 */
	RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
	httpGet.setConfig(requestConfig);

	// 设置请求头
	packageHeader(headers, httpGet);

	// 创建httpResponse对象
	CloseableHttpResponse httpResponse = null;

	try {
		// 执行请求并获得响应结果
		return getHttpClientResult(httpResponse, httpClient, httpGet);
	} finally {
		// 释放资源
		release(httpResponse, httpClient);
	}
}

/**
 * 发送post请求；不带请求头和请求参数
 *
 * @param url 请求地址
 * @return
 * @throws Exception
 */
public static HttpClientResult doPost(String url) throws Exception {
	return doPost(url, null, null);
}

/**
 * 发送post请求；带请求参数
 *
 * @param url 请求地址
 * @param params 参数集合
 * @return
 * @throws Exception
 */
public static HttpClientResult doPost(String url, Map<String, String> params) throws Exception {
	return doPost(url, null, params);
}

/**
 * 发送post请求；带请求头和请求参数
 *
 * @param url 请求地址
 * @param headers 请求头集合
 * @param params 请求参数集合
 * @return
 * @throws Exception
 */
public static HttpClientResult doPost(String url, Map<String, String> headers, Map<String, String> params) throws Exception {
	// 创建httpClient对象
	CloseableHttpClient httpClient = HttpClients.createDefault();

	// 创建http对象
	HttpPost httpPost = new HttpPost(url);
	/**
	 * setConnectTimeout：设置连接超时时间，单位毫秒。
	 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
	 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
	 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
	 */
	RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
	httpPost.setConfig(requestConfig);
	// 设置请求头
	/*httpPost.setHeader("Cookie", "");
	httpPost.setHeader("Connection", "keep-alive");
	httpPost.setHeader("Accept", "application/json");
	httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
	httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
	httpPost.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36");*/
	packageHeader(headers, httpPost);

	// 封装请求参数
	packageParam(params, httpPost);
	// 创建httpResponse对象
	CloseableHttpResponse httpResponse = null;

	try {
		// 执行请求并获得响应结果
		return getHttpClientResult(httpResponse, httpClient, httpPost);
	} finally {
		// 释放资源
		release(httpResponse, httpClient);
	}
}

public static String doPostWithJson(String url,String json) {
	return doPostWithJson(url,null,json);
}

public static String doPostWithJson(String url,Map<String, String> headers,String json) {
	String returnValue = "";
	CloseableHttpClient httpClient = HttpClients.createDefault();
	ResponseHandler<String> responseHandler = new BasicResponseHandler();
	try{
		httpClient = HttpClients.createDefault();
		HttpPost httpPost = new HttpPost(url);
		StringEntity requestEntity = new StringEntity(json,"utf-8");
		requestEntity.setContentEncoding("UTF-8");
		httpPost.setHeader("Content-type", "application/json");
		packageHeader(headers,httpPost);
		httpPost.setEntity(requestEntity);

		//第四步：发送HttpPost请求，获取返回值
		returnValue = httpClient.execute(httpPost,responseHandler); //调接口获取返回值时，必须用此方法

	}
	catch(Exception e)
	{
		e.printStackTrace();
	}

	finally {
		try {
			httpClient.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//第五步：处理返回值
	return returnValue;
}

public static String doPostWithXml(String url,String xml) {
	CloseableHttpClient client = null;
	CloseableHttpResponse resp = null;
	try {
		HttpPost httpPost = new HttpPost(url);
		httpPost.setHeader("Content-Type", "text/xml; charset=UTF-8");
		client = HttpClients.createDefault();
		StringEntity entityParams = new StringEntity(xml, "utf-8");
		httpPost.setEntity(entityParams);
		client = HttpClients.createDefault();
		resp = client.execute(httpPost);
		String resultMsg = EntityUtils.toString(resp.getEntity(), "utf-8");
		return resultMsg;
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		try {
			if (client != null) {
				client.close();
			}
			if (resp != null) {
				resp.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	return null;
}

/**
 * 发送put请求；不带请求参数
 *
 * @param url 请求地址
 * @return
 * @throws Exception
 */
public static HttpClientResult doPut(String url) throws Exception {
	return doPut(url);
}

/**
 * 发送put请求；带请求参数
 *
 * @param url 请求地址
 * @param params 参数集合
 * @return
 * @throws Exception
 */
public static HttpClientResult doPut(String url, Map<String, String> params) throws Exception {
	CloseableHttpClient httpClient = HttpClients.createDefault();
	HttpPut httpPut = new HttpPut(url);
	RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
	httpPut.setConfig(requestConfig);

	packageParam(params, httpPut);
	CloseableHttpResponse httpResponse = null;

	try {
		return getHttpClientResult(httpResponse, httpClient, httpPut);
	} finally {
		release(httpResponse, httpClient);
	}
}

/**
 * 发送delete请求；不带请求参数
 *
 * @param url 请求地址
 * @return
 * @throws Exception
 */
public static HttpClientResult doDelete(String url) throws Exception {
	CloseableHttpClient httpClient = HttpClients.createDefault();
	HttpDelete httpDelete = new HttpDelete(url);
	RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
	httpDelete.setConfig(requestConfig);

	CloseableHttpResponse httpResponse = null;
	try {
		return getHttpClientResult(httpResponse, httpClient, httpDelete);
	} finally {
		release(httpResponse, httpClient);
	}
}

/**
 * 发送delete请求；带请求参数
 *
 * @param url 请求地址
 * @param params 参数集合
 * @return
 * @throws Exception
 */
public static HttpClientResult doDelete(String url, Map<String, String> params) throws Exception {
	if (params == null) {
		params = new HashMap<String, String>();
	}

	params.put("_method", "delete");
	return doPost(url, params);
}

/**
 * Description: 封装请求头
 * @param params
 * @param httpMethod
 */
public static void packageHeader(Map<String, String> params, HttpRequestBase httpMethod) {
	// 封装请求头
	if (params != null) {
		Set<Map.Entry<String, String>> entrySet = params.entrySet();
		for (Map.Entry<String, String> entry : entrySet) {
			// 设置到请求头到HttpRequestBase对象中
			httpMethod.setHeader(entry.getKey(), entry.getValue());
		}
	}
}

/**
 * Description: 封装请求参数
 *
 * @param params
 * @param httpMethod
 * @throws UnsupportedEncodingException
 */
public static void packageParam(Map<String, String> params, HttpEntityEnclosingRequestBase httpMethod)
		throws UnsupportedEncodingException {
	// 封装请求参数
	if (params != null) {
		List<NameValuePair> nvps = new ArrayList<NameValuePair>();
		Set<Map.Entry<String, String>> entrySet = params.entrySet();
		for (Map.Entry<String, String> entry : entrySet) {
			nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
		}

		// 设置到请求的http对象中
		httpMethod.setEntity(new UrlEncodedFormEntity(nvps, ENCODING));
	}
}

/**
 * Description: 获得响应结果
 *
 * @param httpResponse
 * @param httpClient
 * @param httpMethod
 * @return
 * @throws Exception
 */
public static HttpClientResult getHttpClientResult(CloseableHttpResponse httpResponse,
                                                                        CloseableHttpClient httpClient, HttpRequestBase httpMethod) throws Exception {
	// 执行请求
	httpResponse = httpClient.execute(httpMethod);

	// 获取返回结果
	if (httpResponse != null && httpResponse.getStatusLine() != null) {
		String content = "";
		if (httpResponse.getEntity() != null) {
			content = EntityUtils.toString(httpResponse.getEntity(), ENCODING);
		}
		return new HttpClientResult(httpResponse.getStatusLine().getStatusCode(), content);
	}
	return new HttpClientResult(HttpStatus.SC_INTERNAL_SERVER_ERROR);
}

/**
 * Description: 释放资源
 *
 * @param httpResponse
 * @param httpClient
 * @throws IOException
 */
public static void release(CloseableHttpResponse httpResponse, CloseableHttpClient httpClient) throws IOException {
	// 释放资源
	if (httpResponse != null) {
		httpResponse.close();
	}
	if (httpClient != null) {
		httpClient.close();
	}
}

}