使用HTTP协议发送POST请求
HTTP发送POST请求常用的类是HttpClientUtil类，这个类提供三个方法，分别是sendPostByForm，sendPostByJson，sendPostByXml
- sendPostByForm 处理 application/x-www-form-urlencoded格式报文的请求
- sendPostByJson 处理 application/json 格式报文的请求
- sendPostByXml 处理 text/xml 格式报文的请求
具体用法见网友分享的比较经典的代码，粘贴出来
package com.harara.fund.util.http;
import com.montnets.fund.constant.HttpConstant;
import com.montnets.fund.factory.LogFactory;
import com.montnets.fund.factory.service.LogService;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* @author : chenlinyan
* @version : 2.0
* @date : 2019/9/27 9:40
*/
public class HttpClientUtil {
private static LogService logger = LogFactory.getLogger();
/**
* 通过post方式调用http接口
* @param url url路径
* @param jsonParam json格式的参数
* @param reSend 重发次数
* @return
* @throws Exception
*/
public static String sendPostByJson(String url, String jsonParam,int reSend) {
//声明返回结果
String result = "";
//开始请求API接口时间
long startTime=System.currentTimeMillis();
//请求API接口的响应时间
long endTime= 0L;
HttpEntity httpEntity = null;
HttpResponse httpResponse = null;
HttpClient httpClient = null;
try {
// 创建连接
httpClient = HttpClientFactory.getInstance().getHttpClient();
// 设置请求头和报文
HttpPost httpPost = HttpClientFactory.getInstance().httpPost(url);
Header header=new BasicHeader("Accept-Encoding",null);
httpPost.setHeader(header);
// 设置报文和通讯格式
StringEntity stringEntity = new StringEntity(jsonParam,HttpConstant.UTF8_ENCODE);
stringEntity.setContentEncoding(HttpConstant.UTF8_ENCODE);
stringEntity.setContentType(HttpConstant.APPLICATION_JSON);
httpPost.setEntity(stringEntity);
logger.info("请求{}接口的参数为{}",url,jsonParam);
//执行发送，获取相应结果
httpResponse = httpClient.execute(httpPost);
httpEntity= httpResponse.getEntity();
result = EntityUtils.toString(httpEntity);
} catch (Exception e) {
logger.error("请求{}接口出现异常",url,e);
if (reSend > 0) {
logger.info("请求{}出现异常:{}，进行重发。进行第{}次重发",url,e.getMessage(),(HttpConstant.REQ_TIMES-reSend +1));
result = sendPostByJson(url, jsonParam, reSend - 1);
if (result != null && !"".equals(result)) {
return result;
}
}
}finally {
try {
EntityUtils.consume(httpEntity);
} catch (IOException e) {
logger.error("http请求释放资源异常",e);
}
}
//请求接口的响应时间
endTime=System.currentTimeMillis();
logger.info("请求{}接口的响应报文内容为{},本次请求API接口的响应时间为:{}毫秒",url,result,(endTime-startTime));
return result;
}
/**
* 通过post方式调用http接口
* @param url url路径
* @param map json格式的参数
* @param reSend 重发次数
* @return
* @throws Exception
*/
public static String sendPostByForm(String url, Map<String,String> map,int reSend) {
//声明返回结果
String result = "";
//开始请求API接口时间
long startTime=System.currentTimeMillis();
//请求API接口的响应时间
long endTime= 0L;
HttpEntity httpEntity = null;
UrlEncodedFormEntity entity = null;
HttpResponse httpResponse = null;
HttpClient httpClient = null;
try {
// 创建连接
httpClient = HttpClientFactory.getInstance().getHttpClient();
// 设置请求头和报文
HttpPost httpPost = HttpClientFactory.getInstance().httpPost(url);
//设置参数
List<NameValuePair> list = new ArrayList<NameValuePair>();
Iterator iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String,String> elem = (Map.Entry<String, String>) iterator.next();
list.add(new BasicNameValuePair(elem.getKey(),elem.getValue()));
}
entity = new UrlEncodedFormEntity(list,HttpConstant.UTF8_ENCODE);
httpPost.setEntity(entity);
logger.info("请求{}接口的参数为{}",url,map);
//执行发送，获取相应结果
httpResponse = httpClient.execute(httpPost);
httpEntity= httpResponse.getEntity();
result = EntityUtils.toString(httpEntity);
} catch (Exception e) {
logger.error("请求{}接口出现异常",url,e);
if (reSend > 0) {
logger.info("请求{}出现异常:{}，进行重发。进行第{}次重发",url,e.getMessage(),(HttpConstant.REQ_TIMES-reSend +1));
result = sendPostByForm(url, map, reSend - 1);
if (result != null && !"".equals(result)) {
return result;
}
}
}finally {
try {
EntityUtils.consume(httpEntity);
} catch (IOException e) {
logger.error("http请求释放资源异常",e);
}
}
//请求接口的响应时间
endTime=System.currentTimeMillis();
logger.info("请求{}接口的响应报文内容为{},本次请求API接口的响应时间为:{}毫秒",url,result,(endTime-startTime));
return result;
}
/**
* 通过post方式调用http接口
* @param url url路径
* @param xmlParam json格式的参数
* @param reSend 重发次数
* @return
* @throws Exception
*/
public static String sendPostByXml(String url, String xmlParam,int reSend) {
//声明返回结果
String result = "";
//开始请求API接口时间
long startTime = System.currentTimeMillis();
//请求API接口的响应时间
long endTime = 0L;
HttpEntity httpEntity = null;
HttpResponse httpResponse = null;
HttpClient httpClient = null;
try {
// 创建连接
httpClient = HttpClientFactory.getInstance().getHttpClient();
// 设置请求头和报文
HttpPost httpPost = HttpClientFactory.getInstance().httpPost(url);
StringEntity stringEntity = new StringEntity(xmlParam, HttpConstant.UTF8_ENCODE);
stringEntity.setContentEncoding(HttpConstant.UTF8_ENCODE);
stringEntity.setContentType(HttpConstant.TEXT_XML);
httpPost.setEntity(stringEntity);
logger.info("请求{}接口的参数为{}", url, xmlParam);
//执行发送，获取相应结果
httpResponse = httpClient.execute(httpPost);
httpEntity = httpResponse.getEntity();
result = EntityUtils.toString(httpEntity,HttpConstant.UTF8_ENCODE);
} catch (Exception e) {
logger.error("请求{}接口出现异常", url, e);
if (reSend > 0) {
logger.info("请求{}出现异常:{}，进行重发。进行第{}次重发", url, e.getMessage(), (HttpConstant.REQ_TIMES - reSend + 1));
result = sendPostByJson(url, xmlParam, reSend - 1);
if (result != null && !"".equals(result)) {
return result;
}
}
} finally {
try {
EntityUtils.consume(httpEntity);
} catch (IOException e) {
logger.error("http请求释放资源异常", e);
}
//请求接口的响应时间
endTime = System.currentTimeMillis();
logger.info("请求{}接口的响应报文内容为{},本次请求API接口的响应时间为:{}毫秒", url, result, (endTime - startTime));
return result;
}
}
}
还可以通过HttpClient工厂类HttpClientFactory，从工厂类获取HttpClient连接
package com.harara.fund.util.http;
import com.montnets.fund.constant.HttpConstant;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import javax.net.ssl.SSLContext;
import java.security.NoSuchAlgorithmException;
/**
* @author : harara
* @version : 2.0
* @date : 2019/9/27 10:12
*/
public class HttpClientFactory {
private static HttpClientFactory instance = null;
private HttpClientFactory()
{
}
public synchronized static HttpClientFactory getInstance()
{
if (instance == null)
{
instance = new HttpClientFactory();
}
return instance;
}
public synchronized HttpClient getHttpClient()
{
HttpClient httpClient = null;
if (HttpConstant.IS_KEEP_ALIVE)
{
//获取长连接
httpClient = new KeepAliveHttpClientBuilder().getKeepAliveHttpClient();
} else
{
// 获取短连接
httpClient = new HttpClientBuilder().getHttpClient();
}
return httpClient;
}
public HttpPost httpPost(String httpUrl)
{
HttpPost httpPost = null;
httpPost = new HttpPost(httpUrl);
if (HttpConstant.IS_KEEP_ALIVE)
{
// 设置为长连接，服务端判断有此参数就不关闭连接。
httpPost.setHeader("Connection", "Keep-Alive");
}
return httpPost;
}
private static class KeepAliveHttpClientBuilder{
private static HttpClient httpClient;
/**
* 获取http长连接
*/
private synchronized HttpClient getKeepAliveHttpClient()
{
if (httpClient == null)
{
LayeredConnectionSocketFactory sslsf = null;
try {
sslsf = new SSLConnectionSocketFactory(SSLContext.getDefault());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
.<ConnectionSocketFactory> create().register("https", sslsf)
.register("http", new PlainConnectionSocketFactory()).build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
cm.setMaxTotal(HttpConstant.MAX_TOTAL);
cm.setDefaultMaxPerRoute(HttpConstant.MAX_CONN_PER_ROUTE);
RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(HttpConstant.CONNECT_TIMEOUT)
.setSocketTimeout(HttpConstant.SOCKET_TIMEOUT).build();
// 创建连接
httpClient = HttpClients.custom().setDefaultRequestConfig(requestConfig).setConnectionManager(cm).build();
}
return httpClient;
}
}
private static class HttpClientBuilder{
private HttpClient httpClient;
/**
* 获取http短连接
*/
private synchronized HttpClient getHttpClient()
{
if(httpClient == null){
RequestConfig requestConfig = RequestConfig.custom()
// 设置请求超时时间
.setConnectTimeout(HttpConstant.CONNECT_TIMEOUT)
// 设置响应超时时间
.setSocketTimeout(HttpConstant.SOCKET_TIMEOUT).build();
// 创建连接
httpClient = HttpClients.custom().setDefaultRequestConfig(requestConfig).build();
}
return httpClient;
}
}
}
HttpClient请求常量类
package com.harara.fund.constant;
/**
* @author : harara
* @version : 2.0
* @date : 2019/9/27 9:39
*/
public class HttpConstant {
/**httpClient连接超时时间,单位毫秒 */
public static final int CONNECT_TIMEOUT = 3*1000;
/**httpClient请求获取数据的超时时间(即响应时间) 单位毫秒*/
public static final int SOCKET_TIMEOUT = 10*1000;
/**http连接池大小*/
public static final int MAX_TOTAL = 10;
/**分配给同一个route(路由)最大的并发连接数*/
public static final int MAX_CONN_PER_ROUTE = 2;
/**http连接是否是长连接*/
public static final boolean IS_KEEP_ALIVE = true;
/**调用接口失败默认重新调用次数*/
public static final int REQ_TIMES = 3;
/**utf-8编码*/
public static final String UTF8_ENCODE = "UTF-8";
/** application/json */
public static final String APPLICATION_JSON = "application/json";
/** text/xml */
public static final String TEXT_XML = "text/xml";
}
感谢网友博文，原链接供参考