Apache HttpClient发送HttpGet请求

我会带着你远行 2022-08-27 13:44 312阅读 0赞

利用Apache Http Client模拟发送Http请求，并获取返回结果，注意版本区分。

  1. /**
  2.  * 
  3.  */
  4. package com.xxx.httputil;
  6. import java.io.IOException;
  7. import java.io.UnsupportedEncodingException;
  8. import java.net.URI;
  9. import java.net.URISyntaxException;
  10. import java.nio.charset.Charset;
  11. import java.util.List;
  13. import org.apache.commons.logging.Log;
  14. import org.apache.commons.logging.LogFactory;
  15. import org.apache.http.HttpEntity;
  16. import org.apache.http.HttpResponse;
  17. import org.apache.http.HttpStatus;
  18. import org.apache.http.NameValuePair;
  19. import org.apache.http.ParseException;
  20. import org.apache.http.client.HttpClient;
  21. import org.apache.http.client.entity.UrlEncodedFormEntity;
  22. import org.apache.http.client.methods.HttpGet;
  23. import org.apache.http.client.methods.HttpPost;
  24. import org.apache.http.impl.client.DefaultHttpClient;
  25. import org.apache.http.params.CoreConnectionPNames;
  26. import org.apache.http.util.EntityUtils;
  28. import com.xxx.pojo.MyHttpResponse;
  30. /**
  31.  * 项目名称：xxx
  32.  * 
  33.  * @description:
  34.  * 
  35.  * @author Wind-spg
  36.  * 
  37.  * @create_time：2014年12月2日 下午2:29:41
  38.  * 
  39.  * @version V1.0.0
  40.  * 
  41.  */
  42. public class MyHttpUtil
  43. {
  45.     private static final Log LOGGER = LogFactory.getLog(MyHttpUtil.class);
  47.     /**
  48.      * @description: httpget请求
  49.      * @author: Wind-spg
  50.      * @param url
  51.      * @param params
  52.      * @param connectionTimeout
  53.      *            {@link org.apache.http.params.CoreConnectionPNames#CONNECTION_TIMEOUT}
  54.      * @param soTimeout
  55.      *            {@link org.apache.http.params.CoreConnectionPNames#SO_TIMEOUT}
  56.      * @return
  57.      * @throws URISyntaxException
  58.      * @throws IOException
  59.      */
  60.     public static MyHttpResponse doHttpGet(String url, List<NameValuePair> params, int connectionTimeout,
  61.             int soTimeout) throws URISyntaxException, IOException
  62.     {
  63.         LOGGER.debug(String.format("enter function, %s, %s", url, params));
  65.         LOGGER.info(String.format("do http get start:%s", System.currentTimeMillis()));
  66.         // for version 4.3+
  67.         // HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
  68.         // CloseableHttpClient httpClient = httpClientBuilder.build();
  70.         HttpClient httpClient = new DefaultHttpClient();
  71.         // 连接时间
  72.         httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, connectionTimeout);
  73.         // 数据传输时间
  74.         httpClient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, soTimeout);
  75.         // Get请求
  76.         HttpGet httpget = new HttpGet(url);
  77.         try
  78.         {
  79.             // for version 4.3+ 设置请求和传输超时时间
  80.             // RequestConfig requestConfig =
  81.             // RequestConfig.custom().setSocketTimeout(2000)
  82.             // .setConnectTimeout(2000).build();
  83.             // httpget.setConfig(requestConfig);
  85.             // 设置参数
  86.             String str = EntityUtils.toString(new UrlEncodedFormEntity(params, Charset.forName("UTF-8")));
  87.             httpget.setURI(new URI(httpget.getURI().toString() + "?" + str));
  88.             // 发送请求
  89.             HttpResponse httpResponse = httpClient.execute(httpget);
  91.             int statusCode = httpResponse.getStatusLine().getStatusCode();
  92.             if (statusCode != HttpStatus.SC_OK)
  93.             {
  94.                 LOGGER.error("Method failed:" + httpResponse.getStatusLine());
  95.             }
  97.             // 获取返回数据
  98.             HttpEntity entity = httpResponse.getEntity();
  99.             String body = EntityUtils.toString(entity, Charset.forName("UTF-8"));
  100.             if (entity != null)
  101.             {
  102.                 EntityUtils.consume(entity);
  103.             }
  104.             LOGGER.info(String.format("do http get end:%s", System.currentTimeMillis()));
  105.             LOGGER.debug(String.format("http get response:%s", body));
  106.             return new MyHttpResponse(statusCode, body, httpget.getURI().toString());
  107.         } catch (ParseException e)
  108.         {
  109.             LOGGER.error("do http get error!", e);
  110.             throw e;
  111.         } catch (UnsupportedEncodingException e)
  112.         {
  113.             LOGGER.error("do http get error!", e);
  114.             throw e;
  115.         } catch (IOException e)
  116.         {
  117.             LOGGER.error("do http get error!", e);
  118.             throw e;
  119.         } catch (URISyntaxException e)
  120.         {
  121.             LOGGER.error("do http get error!", e);
  122.             throw e;
  123.         } finally
  124.         {
  125.             // try
  126.             // {
  127.             // // for 4.3+
  128.             // httpClient.close();
  129.             // } catch (IOException e)
  130.             // {
  131.             // LOGGER.error("close httpclient error!", e);
  132.             // }
  133.             httpget.releaseConnection();
  134.             httpClient.getConnectionManager().shutdown();
  135.         }
  136.     }
  138.     /**
  139.      * @description: 发送httpPost请求
  140.      * @author: Wind-spg
  141.      * @param url
  142.      * @param params
  143.      * @param connectionTimeout
  144.      *            {@link org.apache.http.params.CoreConnectionPNames#CONNECTION_TIMEOUT}
  145.      * @param soTimeout
  146.      *            {@link org.apache.http.params.CoreConnectionPNames#SO_TIMEOUT}
  147.      * @return
  148.      * @throws IOException
  149.      */
  150.     public static MyHttpResponse doHttpPost(String url, List<NameValuePair> params, int connectionTimeout,
  151.             int soTimeout) throws IOException
  152.     {
  153.         LOGGER.debug(String.format("enter function, %s, %s", url, params));
  154.         // // 创建HttpClientBuilder
  155.         // HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
  156.         // // HttpClient
  157.         // CloseableHttpClient client = httpClientBuilder.build();
  159.         LOGGER.info(String.format("do http post start:%s", System.currentTimeMillis()));
  160.         // 直接创建client
  161.         // for version4.3+
  162.         // CloseableHttpClient client = HttpClients.createDefault();
  163.         HttpClient httpClient = new DefaultHttpClient();
  165.         // 连接时间
  166.         httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, connectionTimeout);
  167.         // 数据传输时间
  168.         httpClient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, soTimeout);
  170.         HttpPost httpPost = new HttpPost(url);
  171.         UrlEncodedFormEntity postEntity = new UrlEncodedFormEntity(params, Charset.forName("UTF-8"));
  172.         httpPost.setEntity(postEntity);
  173.         LOGGER.debug(String.format("request line:%s", httpPost.getRequestLine()));
  174.         try
  175.         {
  176.             // 执行post请求
  177.             HttpResponse httpResponse = httpClient.execute(httpPost);
  179.             int statusCode = httpResponse.getStatusLine().getStatusCode();
  180.             if (statusCode != HttpStatus.SC_OK)
  181.             {
  182.                 LOGGER.error("Method failed:" + httpResponse.getStatusLine());
  183.             }
  185.             HttpEntity entity = httpResponse.getEntity();
  186.             String result = EntityUtils.toString(entity, Charset.forName("UTF-8"));
  187.             if (entity != null)
  188.             {
  189.                 EntityUtils.consume(entity);
  190.             }
  191.             LOGGER.debug(String.format("http post response:%s", result));
  192.             LOGGER.info(String.format("do http post end:%s", System.currentTimeMillis()));
  193.             return new MyHttpResponse(statusCode, result, httpPost.getURI().toString());
  194.         } catch (IOException e)
  195.         {
  196.             LOGGER.error("do http post error!", e);
  197.             throw e;
  198.         } finally
  199.         {
  200.             // try
  201.             // {
  202.             // // 关闭流并释放资源,for version4.3+
  203.             // client.close();
  204.             // } catch (IOException e)
  205.             // {
  206.             // LOGGER.error("close httpclient error!", e);
  207.             // }
  208.             httpPost.releaseConnection();
  209.             httpClient.getConnectionManager().shutdown();
  210.         }
  211.     }
  212. }

MyHttpResponse

  1. /**
  2.  * 
  3.  */
  4. package com.xxx.pojo;
  6. import java.io.Serializable;
  8. /**
  9.  * 项目名称：xxx
  10.  * 
  11.  * @description:
  12.  * 
  13.  * @author Wind-spg
  14.  * 
  15.  * @create_time：2014年12月12日 上午9:41:58
  16.  * 
  17.  * @version V1.0.0
  18.  * 
  19.  */
  20. public class MyHttpResponse implements Serializable
  21. {
  22.     /**
  23.      * {变量说明}
  24.      */
  25.     private static final long serialVersionUID = 6381662550803520971L;
  27.     // private static final Log LOGGER = LogFactory.getLog(MyHttpResponse.class);
  29.     private int responseStatus;
  31.     private String responseBody;
  33.     private String requetUrl;
  35.     public MyHttpResponse()
  36.     {
  38.     }
  40.     public MyHttpResponse(int resonseStatus, String responseBody)
  41.     {
  42.         this.responseStatus = resonseStatus;
  43.         this.responseBody = responseBody;
  44.     }
  46.     public MyHttpResponse(int resonseStatus, String responseBody, String requestUrl)
  47.     {
  48.         this.responseStatus = resonseStatus;
  49.         this.responseBody = responseBody;
  50.         this.requetUrl = requestUrl;
  51.     }
  53.     public int getResponseStatus()
  54.     {
  55.         return responseStatus;
  56.     }
  58.     public void setResponseStatus(int responseStatus)
  59.     {
  60.         this.responseStatus = responseStatus;
  61.     }
  63.     public String getResponseBody()
  64.     {
  65.         return responseBody;
  66.     }
  68.     public void setResponseBody(String responseBody)
  69.     {
  70.         this.responseBody = responseBody;
  71.     }
  73.     public String getRequetUrl()
  74.     {
  75.         return requetUrl;
  76.     }
  78.     public void setRequetUrl(String requetUrl)
  79.     {
  80.         this.requetUrl = requetUrl;
  81.     }
  83.     @Override
  84.     public String toString()
  85.     {
  86.         return "MyHttpResponse [responseStatus=" + responseStatus + ", responseBody=" + responseBody + ", requetUrl="
  87.                 + requetUrl + "]";
  88.     }
  90. }

附：如何正确关闭你的http请求链接，并释放资源

http://seanhe.iteye.com/blog/234759

发表评论

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

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

相关阅读