HttpClientUtils.java

  1. package utils;
  3. import java.io.IOException;
  4. import java.io.Serializable;
  5. import java.io.UnsupportedEncodingException;
  6. import java.util.ArrayList;
  7. import java.util.HashMap;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.Map.Entry;
  11. import java.util.Set;
  13. import org.apache.http.HttpStatus;
  14. import org.apache.http.NameValuePair;
  15. import org.apache.http.client.config.RequestConfig;
  16. import org.apache.http.client.entity.UrlEncodedFormEntity;
  17. import org.apache.http.client.methods.CloseableHttpResponse;
  18. import org.apache.http.client.methods.HttpDelete;
  19. import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
  20. import org.apache.http.client.methods.HttpGet;
  21. import org.apache.http.client.methods.HttpPost;
  22. import org.apache.http.client.methods.HttpPut;
  23. import org.apache.http.client.methods.HttpRequestBase;
  24. import org.apache.http.client.utils.URIBuilder;
  25. import org.apache.http.impl.client.CloseableHttpClient;
  26. import org.apache.http.impl.client.HttpClients;
  27. import org.apache.http.message.BasicNameValuePair;
  28. import org.apache.http.util.EntityUtils;
  31. /**
  32.  * Description: httpClient工具类
  33.  *
  34.  * @author twx 
  35.  */
  36. public class HttpClientUtils {
  38.     /**
  39.      * 编码格式。发送编码格式统一用UTF-8
  40.      */
  41.     private static final String ENCODING = "UTF-8";
  43.     /* 设置连接超时时间，单位毫秒。 */
  44.     private static final int CONNECT_TIMEOUT = 6000;
  46.     /* 请求获取数据的超时时间(即响应时间)，单位毫秒。 */
  47.     private static final int SOCKET_TIMEOUT = 6000;
  49.     /**
  50.      * 发送get请求；不带请求头和请求参数
  51.      *
  52.      * @param url 请求地址
  53.      * @return
  54.      * @throws Exception
  55.      */
  56.     public static HttpClientUtils.Result doGet(String url) throws Exception {
  57.         return doGet(url, null, null);
  58.     }
  60.     /**
  61.      * 发送get请求；带请求参数
  62.      *
  63.      * @param url 请求地址
  64.      * @param params 请求参数集合
  65.      * @return
  66.      * @throws Exception
  67.      */
  68.     public static HttpClientUtils.Result doGet(String url, Map<String, String> params) throws Exception {
  69.         return doGet(url, null, params);
  70.     }
  72.     /**
  73.      * 发送get请求；带请求头和请求参数
  74.      *
  75.      * @param url 请求地址
  76.      * @param headers 请求头集合
  77.      * @param params 请求参数集合
  78.      * @return
  79.      * @throws Exception
  80.      */
  81.     public static HttpClientUtils.Result doGet(String url, Map<String, String> headers, Map<String, String> params) throws Exception {
  82.         // 创建httpClient对象
  83.         CloseableHttpClient httpClient = HttpClients.createDefault();
  85.         // 创建访问的地址
  86.         URIBuilder uriBuilder = new URIBuilder(url);
  87.         if (params != null) {
  88.             Set<Entry<String, String>> entrySet = params.entrySet();
  89.             for (Entry<String, String> entry : entrySet) {
  90.                 uriBuilder.setParameter(entry.getKey(), entry.getValue());
  91.             }
  92.         }
  94.         // 创建http对象
  95.         HttpGet httpGet = new HttpGet(uriBuilder.build());
  96.         /**
  97.          * setConnectTimeout：设置连接超时时间，单位毫秒。
  98.          * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
  99.          * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
  100.          * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
  101.          */
  102.         RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
  103.         httpGet.setConfig(requestConfig);
  105.         // 设置请求头
  106.         packageHeader(headers, httpGet);
  108.         // 创建httpResponse对象
  109.         CloseableHttpResponse httpResponse = null;
  111.         try {
  112.             // 执行请求并获得响应结果
  113.             return getHttpClientResult(httpResponse, httpClient, httpGet);
  114.         } finally {
  115.             // 释放资源
  116.             release(httpResponse, httpClient);
  117.         }
  118.     }
  120.     /**
  121.      * 发送post请求；不带请求头和请求参数
  122.      *
  123.      * @param url 请求地址
  124.      * @return
  125.      * @throws Exception
  126.      */
  127.     public static HttpClientUtils.Result doPost(String url) throws Exception {
  128.         return doPost(url, null, null);
  129.     }
  131.     /**
  132.      * 发送post请求；带请求参数
  133.      *
  134.      * @param url 请求地址
  135.      * @param params 参数集合
  136.      * @return
  137.      * @throws Exception
  138.      */
  139.     public static HttpClientUtils.Result doPost(String url, Map<String, String> params) throws Exception {
  140.         return doPost(url, null, params);
  141.     }
  143.     /**
  144.      * 发送post请求；带请求头和请求参数
  145.      *
  146.      * @param url 请求地址
  147.      * @param headers 请求头集合
  148.      * @param params 请求参数集合
  149.      * @return
  150.      * @throws Exception
  151.      */
  152.     public static HttpClientUtils.Result doPost(String url, Map<String, String> headers, Map<String, String> params) throws Exception {
  153.         // 创建httpClient对象
  154.         CloseableHttpClient httpClient = HttpClients.createDefault();
  156.         // 创建http对象
  157.         HttpPost httpPost = new HttpPost(url);
  158.         /**
  159.          * setConnectTimeout：设置连接超时时间，单位毫秒。
  160.          * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
  161.          * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
  162.          * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
  163.          */
  164.         RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
  165.         httpPost.setConfig(requestConfig);
  167.         packageHeader(headers, httpPost);
  169.         // 封装请求参数
  170.         packageParam(params, httpPost);
  172.         // 创建httpResponse对象
  173.         CloseableHttpResponse httpResponse = null;
  175.         try {
  176.             // 执行请求并获得响应结果
  177.             return getHttpClientResult(httpResponse, httpClient, httpPost);
  178.         } finally {
  179.             // 释放资源
  180.             release(httpResponse, httpClient);
  181.         }
  182.     }
  184.     /**
  185.      * 发送put请求；不带请求参数
  186.      *
  187.      * @param url 请求地址
  188.      * @return
  189.      * @throws Exception
  190.      */
  191.     public static HttpClientUtils.Result doPut(String url) throws Exception {
  192.         return doPut(url);
  193.     }
  195.     /**
  196.      * 发送put请求；带请求参数
  197.      *
  198.      * @param url 请求地址
  199.      * @param params 参数集合
  200.      * @return
  201.      * @throws Exception
  202.      */
  203.     public static HttpClientUtils.Result doPut(String url, Map<String, String> params) throws Exception {
  204.         CloseableHttpClient httpClient = HttpClients.createDefault();
  205.         HttpPut httpPut = new HttpPut(url);
  206.         RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
  207.         httpPut.setConfig(requestConfig);
  209.         packageParam(params, httpPut);
  211.         CloseableHttpResponse httpResponse = null;
  213.         try {
  214.             return getHttpClientResult(httpResponse, httpClient, httpPut);
  215.         } finally {
  216.             release(httpResponse, httpClient);
  217.         }
  218.     }
  220.     /**
  221.      * 发送delete请求；不带请求参数
  222.      *
  223.      * @param url 请求地址
  224.      * @return
  225.      * @throws Exception
  226.      */
  227.     public static HttpClientUtils.Result doDelete(String url) throws Exception {
  228.         CloseableHttpClient httpClient = HttpClients.createDefault();
  229.         HttpDelete httpDelete = new HttpDelete(url);
  230.         RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
  231.         httpDelete.setConfig(requestConfig);
  233.         CloseableHttpResponse httpResponse = null;
  234.         try {
  235.             return getHttpClientResult(httpResponse, httpClient, httpDelete);
  236.         } finally {
  237.             release(httpResponse, httpClient);
  238.         }
  239.     }
  241.     /**
  242.      * 发送delete请求；带请求参数
  243.      *
  244.      * @param url 请求地址
  245.      * @param params 参数集合
  246.      * @return
  247.      * @throws Exception
  248.      */
  249.     public static HttpClientUtils.Result doDelete(String url, Map<String, String> params) throws Exception {
  250.         if (params == null) {
  251.             params = new HashMap<String, String>();
  252.         }
  254.         params.put("_method", "delete");
  255.         return doPost(url, params);
  256.     }
  258.     /**
  259.      * Description: 封装请求头
  260.      * @param params
  261.      * @param httpMethod
  262.      */
  263.     public static void packageHeader(Map<String, String> params, HttpRequestBase httpMethod) {
  264.         // 封装请求头
  265.         if (params != null) {
  266.             Set<Entry<String, String>> entrySet = params.entrySet();
  267.             for (Entry<String, String> entry : entrySet) {
  268.                 // 设置到请求头到HttpRequestBase对象中
  269.                 httpMethod.setHeader(entry.getKey(), entry.getValue());
  270.             }
  271.         }
  272.     }
  274.     /**
  275.      * Description: 封装请求参数
  276.      *
  277.      * @param params
  278.      * @param httpMethod
  279.      * @throws UnsupportedEncodingException
  280.      */
  281.     public static void packageParam(Map<String, String> params, HttpEntityEnclosingRequestBase httpMethod)
  282.             throws UnsupportedEncodingException {
  283.         // 封装请求参数
  284.         if (params != null) {
  285.             List<NameValuePair> nvps = new ArrayList<NameValuePair>();
  286.             Set<Entry<String, String>> entrySet = params.entrySet();
  287.             for (Entry<String, String> entry : entrySet) {
  288.                 nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
  289.             }
  291.             // 设置到请求的http对象中
  292.             httpMethod.setEntity(new UrlEncodedFormEntity(nvps, ENCODING));
  293.         }
  294.     }
  296.     /**
  297.      * Description: 获得响应结果
  298.      *
  299.      * @param httpResponse
  300.      * @param httpClient
  301.      * @param httpMethod
  302.      * @return
  303.      * @throws Exception
  304.      */
  305.     public static HttpClientUtils.Result getHttpClientResult(CloseableHttpResponse httpResponse,
  306.                                                        CloseableHttpClient httpClient, HttpRequestBase httpMethod) throws Exception {
  307.         // 执行请求
  308.         httpResponse = httpClient.execute(httpMethod);
  310.         // 获取返回结果
  311.         if (httpResponse != null && httpResponse.getStatusLine() != null) {
  312.             String content = "";
  313.             if (httpResponse.getEntity() != null) {
  314.                 content = EntityUtils.toString(httpResponse.getEntity(), ENCODING);
  315.             }
  316.             return new HttpClientUtils.Result(httpResponse.getStatusLine().getStatusCode(), content);
  317.         }
  318.         return new HttpClientUtils.Result(HttpStatus.SC_INTERNAL_SERVER_ERROR);
  319.     }
  321.     /**
  322.      * Description: 释放资源
  323.      *
  324.      * @param httpResponse
  325.      * @param httpClient
  326.      * @throws IOException
  327.      */
  328.     public static void release(CloseableHttpResponse httpResponse, CloseableHttpClient httpClient) throws IOException {
  329.         // 释放资源
  330.         if (httpResponse != null) {
  331.             httpResponse.close();
  332.         }
  333.         if (httpClient != null) {
  334.             httpClient.close();
  335.         }
  336.     }
  339.     /**
  340.      * Description: 封装httpClient响应结果
  341.      *
  342.      * @author JourWon
  343.      * @date Created on 2018年4月19日
  344.      */
  345.     public static class Result implements Serializable {
  347.         private static final long serialVersionUID = 2168152194164783950L;
  349.         /**
  350.          * 响应状态码
  351.          */
  352.         private int code;
  354.         /**
  355.          * 响应数据
  356.          */
  357.         private String content;
  359.         public Result() {
  360.         }
  362.         public Result(int code) {
  363.             this.code = code;
  364.         }
  366.         public Result(String content) {
  367.             this.content = content;
  368.         }
  370.         public Result(int code, String content) {
  371.             this.code = code;
  372.             this.content = content;
  373.         }
  375.         public int getCode() {
  376.             return code;
  377.         }
  379.         public void setCode(int code) {
  380.             this.code = code;
  381.         }
  383.         public String getContent() {
  384.             return content;
  385.         }
  387.         public void setContent(String content) {
  388.             this.content = content;
  389.         }
  391.         @Override
  392.         public String toString() {
  393.             return "HttpClientResult [code=" + code + ", content=" + content + "]";
  394.         }
  396.     }
  398. }