Java使用httpclient封装post请求和get请求

谁借莪１个温暖的怀抱￠ 2022-03-14 10:44 578阅读 0赞 
  1. package com.marco.common;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.net.URI;
  7. import java.util.ArrayList;
  8. import java.util.Iterator;
  9. import java.util.List;
  10. import java.util.Map;
  12. import org.apache.http.HttpEntity;
  13. import org.apache.http.HttpResponse;
  14. import org.apache.http.HttpStatus;
  15. import org.apache.http.NameValuePair;
  16. import org.apache.http.StatusLine;
  17. import org.apache.http.client.HttpClient;
  18. import org.apache.http.client.entity.UrlEncodedFormEntity;
  19. import org.apache.http.client.methods.CloseableHttpResponse;
  20. import org.apache.http.client.methods.HttpGet;
  21. import org.apache.http.client.methods.HttpPost;
  22. import org.apache.http.entity.StringEntity;
  23. import org.apache.http.impl.client.CloseableHttpClient;
  24. import org.apache.http.impl.client.DefaultHttpClient;
  25. import org.apache.http.impl.client.HttpClients;
  26. import org.apache.http.message.BasicNameValuePair;
  27. import org.apache.http.protocol.HTTP;
  28. import org.apache.http.util.EntityUtils;
  29. import org.apache.log4j.Logger;
  31. /**
  32.  * @author 马弦
  33.  * @date 2017年10月23日 下午2:49
  34.  * HttpClient工具类
  35.  */
  36. public class HttpUtil {
  38.     private static Logger logger = Logger.getLogger(HttpUtil.class);
  40.     /**
  41.      * get请求
  42.      * @return
  43.      */
  44.     public static String doGet(String url) {
  45.         try {
  46.             HttpClient client = new DefaultHttpClient();
  47.             //发送get请求
  48.             HttpGet request = new HttpGet(url);
  49.             HttpResponse response = client.execute(request);
  51.             /**请求发送成功，并得到响应**/
  52.             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
  53.                 /**读取服务器返回过来的json字符串数据**/
  54.                 String strResult = EntityUtils.toString(response.getEntity());
  56.                 return strResult;
  57.             }
  58.         } 
  59.         catch (IOException e) {
  60.             e.printStackTrace();
  61.         }
  63.         return null;
  64.     }
  66.     /**
  67.      * post请求(用于key-value格式的参数)
  68.      * @param url
  69.      * @param params
  70.      * @return
  71.      */
  72.     public static String doPost(String url, Map params){
  74.         BufferedReader in = null;  
  75.         try {  
  76.             // 定义HttpClient  
  77.             HttpClient client = new DefaultHttpClient();  
  78.             // 实例化HTTP方法  
  79.             HttpPost request = new HttpPost();  
  80.             request.setURI(new URI(url));
  82.             //设置参数
  83.             List<NameValuePair> nvps = new ArrayList<NameValuePair>(); 
  84.             for (Iterator iter = params.keySet().iterator(); iter.hasNext();) {
  85.                 String name = (String) iter.next();
  86.                 String value = String.valueOf(params.get(name));
  87.                 nvps.add(new BasicNameValuePair(name, value));
  89.                 //System.out.println(name +"-"+value);
  90.             }
  91.             request.setEntity(new UrlEncodedFormEntity(nvps,HTTP.UTF_8));
  93.             HttpResponse response = client.execute(request);  
  94.             int code = response.getStatusLine().getStatusCode();
  95.             if(code == 200){    //请求成功
  96.                 in = new BufferedReader(new InputStreamReader(response.getEntity()  
  97.                         .getContent(),"utf-8"));
  98.                 StringBuffer sb = new StringBuffer("");  
  99.                 String line = "";  
  100.                 String NL = System.getProperty("line.separator");  
  101.                 while ((line = in.readLine()) != null) {  
  102.                     sb.append(line + NL);  
  103.                 }
  105.                 in.close();  
  107.                 return sb.toString();
  108.             }
  109.             else{    //
  110.                 System.out.println("状态码：" + code);
  111.                 return null;
  112.             }
  113.         }
  114.         catch(Exception e){
  115.             e.printStackTrace();
  117.             return null;
  118.         }
  119.     }
  121.     /**
  122.      * post请求（用于请求json格式的参数）
  123.      * @param url
  124.      * @param params
  125.      * @return
  126.      */
  127.     public static String doPost(String url, String params) throws Exception {
  129.         CloseableHttpClient httpclient = HttpClients.createDefault();
  130.         HttpPost httpPost = new HttpPost(url);// 创建httpPost   
  131.         httpPost.setHeader("Accept", "application/json"); 
  132.         httpPost.setHeader("Content-Type", "application/json");
  133.         String charSet = "UTF-8";
  134.         StringEntity entity = new StringEntity(params, charSet);
  135.         httpPost.setEntity(entity);        
  136.         CloseableHttpResponse response = null;
  138.         try {
  140.             response = httpclient.execute(httpPost);
  141.             StatusLine status = response.getStatusLine();
  142.             int state = status.getStatusCode();
  143.             if (state == HttpStatus.SC_OK) {
  144.                 HttpEntity responseEntity = response.getEntity();
  145.                 String jsonString = EntityUtils.toString(responseEntity);
  146.                 return jsonString;
  147.             }
  148.             else{
  149.                  logger.error("请求返回:"+state+"("+url+")");
  150.             }
  151.         }
  152.         finally {
  153.             if (response != null) {
  154.                 try {
  155.                     response.close();
  156.                 } catch (IOException e) {
  157.                     e.printStackTrace();
  158.                 }
  159.             }
  160.             try {
  161.                 httpclient.close();
  162.             } catch (IOException e) {
  163.                 e.printStackTrace();
  164.             }
  165.         }
  166.         return null;
  167.     }
  169. }

上述方法已过时， 下边为新的封装类

  1. /**
  2.  * <p>Title: HttpUtil.java</p> 
  3.  * @author xiatian
  4.  * @date 2019年3月4日
  5.  */
  6. package com.weixin.util;
  8. import java.io.IOException;
  9. import java.net.URLEncoder;
  10. import java.util.Iterator;
  11. import java.util.Map;
  13. import org.apache.http.HttpEntity;
  14. import org.apache.http.HttpStatus;
  15. import org.apache.http.client.config.RequestConfig;
  16. import org.apache.http.client.methods.CloseableHttpResponse;
  17. import org.apache.http.client.methods.HttpGet;
  18. import org.apache.http.client.methods.HttpPost;
  19. import org.apache.http.entity.StringEntity;
  20. import org.apache.http.impl.client.CloseableHttpClient;
  21. import org.apache.http.impl.client.HttpClients;
  22. import org.apache.http.util.EntityUtils;
  23. import org.slf4j.Logger;
  24. import org.slf4j.LoggerFactory;
  26. /**
  27.  * @author xl
  28.  *
  29.  */
  30. public class HttpUtil {
  32.     private static Logger logger = LoggerFactory.getLogger(HttpUtil.class);
  34.     private static final CloseableHttpClient httpClient;
  35.     static {
  36.         httpClient = HttpClients.createDefault();
  37.     }
  39.     /**
  40.      * get请求
  41.      * 
  42.      * @return
  43.      */
  44.     public static String doGet(String url) {
  45.         CloseableHttpResponse response = null;
  46.         try {
  47.             // 发送get请求
  48.             HttpGet httpGet = new HttpGet(url);
  49.             // 配置请求参数
  50.             RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000)
  51.                     .setConnectionRequestTimeout(1000).setSocketTimeout(6000).build();
  52.             httpGet.setConfig(requestConfig);
  53.             // 执行请求
  54.             response = httpClient.execute(httpGet);
  55.             // 建立的http连接，仍旧被response保持着，允许我们从网络socket中获取返回的数据
  56.             // 为了释放资源，我们必须手动消耗掉response或者取消连接（使用CloseableHttpResponse类的close方法）
  57.             /** 请求发送成功，并得到响应 **/
  58.             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
  59.                 /** 读取服务器返回过来的json字符串数据 **/
  60.                 HttpEntity entity = response.getEntity();
  61.                 if (entity != null) {
  62.                     String strResult = EntityUtils.toString(entity, "UTF-8");
  63.                     /** 消耗掉entity对象 **/
  64.                     EntityUtils.consume(entity);
  65.                     return strResult;
  66.                 }
  67.             }
  68.         } catch (Exception e) {
  69.             e.printStackTrace();
  70.         } finally {
  71.             if (response != null) {
  72.                 try {
  73.                     response.close();
  74.                 } catch (IOException e) {
  75.                     e.printStackTrace();
  76.                 }
  77.             }
  78.         }
  79.         return null;
  80.     }
  82.     /**
  83.      * post请求(请求参数是 name1=value1&name2=value2 的形式)
  84.      * 
  85.      * @param url
  86.      * @param params
  87.      * @return
  88.      */
  89.     public static String doPost(String url, String params) {
  90.         // 创建httpPost
  91.         HttpPost httpPost = new HttpPost(url);
  92.         httpPost.setHeader("Accept", "*/*");
  93.         httpPost.setHeader("Accept-Charset", "UTF-8");
  94.         httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
  95.         StringEntity entity = new StringEntity(params, "UTF-8");
  96.         httpPost.setEntity(entity);
  97.         // 配置请求参数
  98.         RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000)
  99.                 .setConnectionRequestTimeout(1000).setSocketTimeout(6000).build();
  100.         httpPost.setConfig(requestConfig);
  101.         // 执行请求
  102.         CloseableHttpResponse response = null;
  103.         try {
  104.             response = httpClient.execute(httpPost);
  105.             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
  106.                 HttpEntity responseEntity = response.getEntity();
  107.                 if (responseEntity != null) {
  108.                     String jsonString = EntityUtils.toString(responseEntity, "UTF-8");
  109.                     /** 消耗掉entity对象 **/
  110.                     EntityUtils.consume(responseEntity);
  111.                     return jsonString;
  112.                 }
  113.             }
  114.         } catch (Exception e) {
  115.             e.printStackTrace();
  116.         } finally {
  117.             if (response != null) {
  118.                 try {
  119.                     response.close();
  120.                 } catch (IOException e) {
  121.                     e.printStackTrace();
  122.                 }
  123.             }
  124.         }
  125.         return null;
  126.     }
  128.     /**
  129.      * post请求（用于请求json格式的参数）
  130.      * 
  131.      * @param url
  132.      * @param params
  133.      * @return
  134.      */
  135.     public static String doJsonPost(String url, String params) throws Exception {
  136.         // 创建httpPost
  137.         HttpPost httpPost = new HttpPost(url);
  138.         httpPost.setHeader("Accept", "application/json");
  139.         httpPost.setHeader("Content-Type", "application/json");
  140.         StringEntity entity = new StringEntity(params, "UTF-8");
  141.         httpPost.setEntity(entity);
  142.         // 配置请求参数
  143.         RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000)
  144.                 .setConnectionRequestTimeout(1000).setSocketTimeout(6000).build();
  145.         httpPost.setConfig(requestConfig);
  146.         // 执行请求
  147.         CloseableHttpResponse response = null;
  148.         try {
  149.             response = httpClient.execute(httpPost);
  150.             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
  151.                 HttpEntity responseEntity = response.getEntity();
  152.                 if (responseEntity != null) {
  153.                     String jsonString = EntityUtils.toString(responseEntity, "UTF-8");
  154.                     /** 消耗掉entity对象 **/
  155.                     EntityUtils.consume(responseEntity);
  156.                     return jsonString;
  157.                 }
  158.             }
  159.         } catch (Exception e) {
  160.             e.printStackTrace();
  161.         } finally {
  162.             if (response != null) {
  163.                 try {
  164.                     response.close();
  165.                 } catch (IOException e) {
  166.                     e.printStackTrace();
  167.                 }
  168.             }
  169.         }
  170.         return null;
  171.     }
  173.     /**
  174.      * 将map对象转换为URL参数格式
  175.      * 
  176.      * @param params
  177.      * @return
  178.      */
  179.     public static String buildParam(Map<String, Object> params) {
  180.         if (params.isEmpty()) {
  181.             return "";
  182.         }
  183.         StringBuilder param = new StringBuilder();
  184.         Iterator<String> keyItor = params.keySet().iterator();
  185.         try {
  186.             while (keyItor.hasNext()) {
  187.                 String key = keyItor.next();
  188.                 Object o = params.get(key);
  189.                 if (o == null) {
  190.                     param.append(key + "=&");
  191.                 } else {
  192.                     param.append(key + "=" + URLEncoder.encode(String.valueOf(o), "UTF-8") + "&");
  193.                 }
  194.             }
  195.             if (param.length() != 0) {
  196.                 param.deleteCharAt(param.length() - 1);
  197.             }
  198.         } catch (Exception ex) {
  199.             logger.error(ex.getMessage());
  200.         }
  201.         return param.toString();
  202.     }
  204. }

完！！！

发表评论

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

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

相关阅读