HttpClient发送Post请求

痛定思痛。 2022-09-11 15:19 390阅读 0赞

一.HttpClientUtil类，提供三个方法，分别是sendPostByForm，sendPostByJson，sendPostByXml

（1）sendPostByForm 处理 application/x-www-form-urlencoded格式报文的请求
（2）sendPostByJson 处理 application/json 格式报文的请求
（3）sendPostByXml 处理 text/xml 格式报文的请求
1.

  1. package com.harara.fund.util.http;
  3. import com.montnets.fund.constant.HttpConstant;
  4. import com.montnets.fund.factory.LogFactory;
  5. import com.montnets.fund.factory.service.LogService;
  6. import org.apache.http.Header;
  7. import org.apache.http.HttpEntity;
  8. import org.apache.http.HttpResponse;
  9. import org.apache.http.NameValuePair;
  10. import org.apache.http.client.HttpClient;
  11. import org.apache.http.client.entity.UrlEncodedFormEntity;
  12. import org.apache.http.client.methods.HttpPost;
  13. import org.apache.http.entity.StringEntity;
  14. import org.apache.http.message.BasicHeader;
  15. import org.apache.http.message.BasicNameValuePair;
  16. import org.apache.http.util.EntityUtils;
  18. import java.io.IOException;
  19. import java.util.ArrayList;
  20. import java.util.Iterator;
  21. import java.util.List;
  22. import java.util.Map;
  24. /** * @author : chenlinyan * @version : 2.0 * @date : 2019/9/27 9:40 */
  25. public class HttpClientUtil { 
  27.     private static LogService logger = LogFactory.getLogger();
  28.     /** * 通过post方式调用http接口 * @param url url路径 * @param jsonParam json格式的参数 * @param reSend 重发次数 * @return * @throws Exception */
  29.     public static String sendPostByJson(String url, String jsonParam,int reSend) { 
  30.         //声明返回结果
  31.         String result = "";
  32.         //开始请求API接口时间
  33.         long startTime=System.currentTimeMillis();
  34.         //请求API接口的响应时间
  35.         long endTime= 0L;
  36.         HttpEntity httpEntity = null;
  37.         HttpResponse httpResponse = null;
  38.         HttpClient httpClient = null;
  39.         try { 
  40.             // 创建连接
  41.             httpClient = HttpClientFactory.getInstance().getHttpClient();
  42.             // 设置请求头和报文
  43.             HttpPost httpPost = HttpClientFactory.getInstance().httpPost(url);
  44.             Header header=new BasicHeader("Accept-Encoding",null);
  45.             httpPost.setHeader(header);
  46.             // 设置报文和通讯格式
  47.             StringEntity stringEntity = new StringEntity(jsonParam,HttpConstant.UTF8_ENCODE);
  48.             stringEntity.setContentEncoding(HttpConstant.UTF8_ENCODE);
  49.             stringEntity.setContentType(HttpConstant.APPLICATION_JSON);
  50.             httpPost.setEntity(stringEntity);
  51.             logger.info("请求{}接口的参数为{}",url,jsonParam);
  52.             //执行发送，获取相应结果
  53.             httpResponse = httpClient.execute(httpPost);
  54.             httpEntity= httpResponse.getEntity();
  55.             result = EntityUtils.toString(httpEntity);
  56.         } catch (Exception e) { 
  57.             logger.error("请求{}接口出现异常",url,e);
  58.             if (reSend > 0) { 
  59.                 logger.info("请求{}出现异常:{}，进行重发。进行第{}次重发",url,e.getMessage(),(HttpConstant.REQ_TIMES-reSend +1));
  60.                 result = sendPostByJson(url, jsonParam, reSend - 1);
  61.                 if (result != null && !"".equals(result)) { 
  62.                     return result;
  63.                 }
  64.             }
  65.         }finally { 
  66.             try { 
  67.                 EntityUtils.consume(httpEntity);
  68.             } catch (IOException e) { 
  69.                 logger.error("http请求释放资源异常",e);
  70.             }
  71.         }
  72.         //请求接口的响应时间
  73.         endTime=System.currentTimeMillis();
  74.         logger.info("请求{}接口的响应报文内容为{},本次请求API接口的响应时间为:{}毫秒",url,result,(endTime-startTime));
  75.         return result;
  77.     }
  80.     /** * 通过post方式调用http接口 * @param url url路径 * @param map json格式的参数 * @param reSend 重发次数 * @return * @throws Exception */
  81.     public static String sendPostByForm(String url, Map<String,String> map,int reSend) { 
  82.         //声明返回结果
  83.         String result = "";
  84.         //开始请求API接口时间
  85.         long startTime=System.currentTimeMillis();
  86.         //请求API接口的响应时间
  87.         long endTime= 0L;
  88.         HttpEntity httpEntity = null;
  89.         UrlEncodedFormEntity entity = null;
  90.         HttpResponse httpResponse = null;
  91.         HttpClient httpClient = null;
  92.         try { 
  93.             // 创建连接
  94.             httpClient = HttpClientFactory.getInstance().getHttpClient();
  95.             // 设置请求头和报文
  96.             HttpPost httpPost = HttpClientFactory.getInstance().httpPost(url);
  97.             //设置参数
  98.             List<NameValuePair> list = new ArrayList<NameValuePair>();
  99.             Iterator iterator = map.entrySet().iterator();
  100.             while(iterator.hasNext()){ 
  101.                 Map.Entry<String,String> elem = (Map.Entry<String, String>) iterator.next();
  102.                 list.add(new BasicNameValuePair(elem.getKey(),elem.getValue()));
  103.             }
  104.             entity = new UrlEncodedFormEntity(list,HttpConstant.UTF8_ENCODE);
  105.             httpPost.setEntity(entity);
  106.             logger.info("请求{}接口的参数为{}",url,map);
  107.             //执行发送，获取相应结果
  108.             httpResponse = httpClient.execute(httpPost);
  109.             httpEntity= httpResponse.getEntity();
  110.             result = EntityUtils.toString(httpEntity);
  111.         } catch (Exception e) { 
  112.             logger.error("请求{}接口出现异常",url,e);
  113.             if (reSend > 0) { 
  114.                 logger.info("请求{}出现异常:{}，进行重发。进行第{}次重发",url,e.getMessage(),(HttpConstant.REQ_TIMES-reSend +1));
  115.                 result = sendPostByForm(url, map, reSend - 1);
  116.                 if (result != null && !"".equals(result)) { 
  117.                     return result;
  118.                 }
  119.             }
  120.         }finally { 
  121.             try { 
  122.                 EntityUtils.consume(httpEntity);
  123.             } catch (IOException e) { 
  124.                 logger.error("http请求释放资源异常",e);
  125.             }
  126.         }
  127.         //请求接口的响应时间
  128.         endTime=System.currentTimeMillis();
  129.         logger.info("请求{}接口的响应报文内容为{},本次请求API接口的响应时间为:{}毫秒",url,result,(endTime-startTime));
  130.         return result;
  132.     }
  133.     /** * 通过post方式调用http接口 * @param url url路径 * @param xmlParam json格式的参数 * @param reSend 重发次数 * @return * @throws Exception */
  134.     public static String sendPostByXml(String url, String xmlParam,int reSend) { 
  135.         //声明返回结果
  136.         String result = "";
  137.         //开始请求API接口时间
  138.         long startTime = System.currentTimeMillis();
  139.         //请求API接口的响应时间
  140.         long endTime = 0L;
  141.         HttpEntity httpEntity = null;
  142.         HttpResponse httpResponse = null;
  143.         HttpClient httpClient = null;
  144.         try { 
  145.             // 创建连接
  146.             httpClient = HttpClientFactory.getInstance().getHttpClient();
  147.             // 设置请求头和报文
  148.             HttpPost httpPost = HttpClientFactory.getInstance().httpPost(url);
  149.             StringEntity stringEntity = new StringEntity(xmlParam, HttpConstant.UTF8_ENCODE);
  150.             stringEntity.setContentEncoding(HttpConstant.UTF8_ENCODE);
  151.             stringEntity.setContentType(HttpConstant.TEXT_XML);
  152.             httpPost.setEntity(stringEntity);
  153.             logger.info("请求{}接口的参数为{}", url, xmlParam);
  154.             //执行发送，获取相应结果
  155.             httpResponse = httpClient.execute(httpPost);
  156.             httpEntity = httpResponse.getEntity();
  157.             result = EntityUtils.toString(httpEntity,HttpConstant.UTF8_ENCODE);
  158.         } catch (Exception e) { 
  159.             logger.error("请求{}接口出现异常", url, e);
  160.             if (reSend > 0) { 
  161.                 logger.info("请求{}出现异常:{}，进行重发。进行第{}次重发", url, e.getMessage(), (HttpConstant.REQ_TIMES - reSend + 1));
  162.                 result = sendPostByJson(url, xmlParam, reSend - 1);
  163.                 if (result != null && !"".equals(result)) { 
  164.                     return result;
  165.                 }
  166.             }
  167.         } finally { 
  168.             try { 
  169.                 EntityUtils.consume(httpEntity);
  170.             } catch (IOException e) { 
  171.                 logger.error("http请求释放资源异常", e);
  172.             }
  173.             //请求接口的响应时间
  174.             endTime = System.currentTimeMillis();
  175.             logger.info("请求{}接口的响应报文内容为{},本次请求API接口的响应时间为:{}毫秒", url, result, (endTime - startTime));
  176.             return result;
  177.         }
  179.     }
  180. }

2.HttpClient工厂类HttpClientFactory，从工厂类获取HttpClient连接

  1. package com.harara.fund.util.http;
  3. import com.montnets.fund.constant.HttpConstant;
  4. import org.apache.http.client.HttpClient;
  5. import org.apache.http.client.config.RequestConfig;
  6. import org.apache.http.client.methods.HttpPost;
  7. import org.apache.http.config.Registry;
  8. import org.apache.http.config.RegistryBuilder;
  9. import org.apache.http.conn.socket.ConnectionSocketFactory;
  10. import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
  11. import org.apache.http.conn.socket.PlainConnectionSocketFactory;
  12. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  13. import org.apache.http.impl.client.HttpClients;
  14. import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  16. import javax.net.ssl.SSLContext;
  17. import java.security.NoSuchAlgorithmException;
  19. /** * @author : harara * @version : 2.0 * @date : 2019/9/27 10:12 */
  20. public class HttpClientFactory { 
  23.     private static HttpClientFactory instance = null;
  25.     private HttpClientFactory()
  26.     { 
  27.     }
  29.     public synchronized static HttpClientFactory getInstance()
  30.     { 
  31.         if (instance == null)
  32.         { 
  33.             instance = new HttpClientFactory();
  34.         }
  35.         return instance;
  36.     }
  39.     public synchronized HttpClient getHttpClient()
  40.     { 
  41.         HttpClient httpClient = null;
  42.         if (HttpConstant.IS_KEEP_ALIVE)
  43.         { 
  44.             //获取长连接
  45.             httpClient = new KeepAliveHttpClientBuilder().getKeepAliveHttpClient();
  46.         } else
  47.         { 
  48.             // 获取短连接
  49.             httpClient = new HttpClientBuilder().getHttpClient();
  50.         }
  51.         return httpClient;
  52.     }
  54.     public HttpPost httpPost(String httpUrl)
  55.     { 
  56.         HttpPost httpPost = null;
  57.         httpPost = new HttpPost(httpUrl);
  58.         if (HttpConstant.IS_KEEP_ALIVE)
  59.         { 
  60.             // 设置为长连接，服务端判断有此参数就不关闭连接。
  61.             httpPost.setHeader("Connection", "Keep-Alive");
  62.         }
  63.         return httpPost;
  64.     }
  68.     private  static class  KeepAliveHttpClientBuilder{ 
  70.         private  static HttpClient httpClient;
  72.         /** * 获取http长连接 */
  73.         private synchronized HttpClient getKeepAliveHttpClient()
  74.         { 
  75.             if (httpClient == null)
  76.             { 
  77.                 LayeredConnectionSocketFactory sslsf = null;
  78.                 try { 
  79.                     sslsf = new SSLConnectionSocketFactory(SSLContext.getDefault());
  80.                 } catch (NoSuchAlgorithmException e) { 
  81.                     e.printStackTrace();
  82.                 }
  84.                 Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
  85.                         .<ConnectionSocketFactory> create().register("https", sslsf)
  86.                         .register("http", new PlainConnectionSocketFactory()).build();
  87.                 PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
  88.                 cm.setMaxTotal(HttpConstant.MAX_TOTAL);
  89.                 cm.setDefaultMaxPerRoute(HttpConstant.MAX_CONN_PER_ROUTE);
  91.                 RequestConfig requestConfig = RequestConfig.custom()
  92.                         .setConnectTimeout(HttpConstant.CONNECT_TIMEOUT)
  93.                         .setSocketTimeout(HttpConstant.SOCKET_TIMEOUT).build();
  94.                 // 创建连接
  95.                 httpClient =  HttpClients.custom().setDefaultRequestConfig(requestConfig).setConnectionManager(cm).build();
  96.             }
  98.             return httpClient;
  99.         }
  100.     }
  103.     private  static class  HttpClientBuilder{ 
  104.         private  HttpClient httpClient;
  105.         /** * 获取http短连接 */
  106.         private synchronized HttpClient getHttpClient()
  107.         { 
  108.             if(httpClient == null){ 
  109.                 RequestConfig requestConfig = RequestConfig.custom()
  110.                         // 设置请求超时时间
  111.                         .setConnectTimeout(HttpConstant.CONNECT_TIMEOUT)
  112.                         // 设置响应超时时间
  113.                         .setSocketTimeout(HttpConstant.SOCKET_TIMEOUT).build();
  114.                 // 创建连接
  115.                 httpClient = HttpClients.custom().setDefaultRequestConfig(requestConfig).build();
  116.             }
  117.             return httpClient;
  118.         }
  119.     }
  120. }

3.HttpClient请求常量类

  1. package com.harara.fund.constant;
  3. /** * @author : harara * @version : 2.0 * @date : 2019/9/27 9:39 */
  4. public class HttpConstant { 
  6.     /**httpClient连接超时时间,单位毫秒 */
  7.     public static final int CONNECT_TIMEOUT = 3*1000;
  9.     /**httpClient请求获取数据的超时时间(即响应时间) 单位毫秒*/
  10.     public static final int SOCKET_TIMEOUT = 10*1000;
  12.     /**http连接池大小*/
  13.     public static final int MAX_TOTAL = 10;
  15.     /**分配给同一个route(路由)最大的并发连接数*/
  16.     public static final int MAX_CONN_PER_ROUTE = 2;
  18.     /**http连接是否是长连接*/
  19.     public static final boolean IS_KEEP_ALIVE = true;
  21.     /**调用接口失败默认重新调用次数*/
  22.     public static final int REQ_TIMES = 3;
  24.     /**utf-8编码*/
  25.     public static final String UTF8_ENCODE = "UTF-8";
  27.     /** application/json */
  28.     public static final String APPLICATION_JSON = "application/json";
  30.     /** text/xml */
  31.     public static final String TEXT_XML = "text/xml";
  33. }
  35. > 通过一系列的操作，完成固定的功能。
  36. > 一系列的操作也是固定的，包括使用哪些类，哪些类的方法。

发表评论

表情：
评论列表 （有 0 条评论，390人围观）

还没有评论，来说两句吧...

相关阅读