碼上歡樂
相關內容    簡體    繁體

JAVA發送HttpClient請求及接收請求完整代碼實例

本文轉載自   查看原文   2017-12-08 00:30   20328 

http://bijian1013.iteye.com/blog/2310211

 

    在發送HTTP請求的時候會使用到POST和GET兩種方式，如果是傳送普通的表單數據，我們直接將參數到一個Key-value形式的Map中即可，隨着JSON的應用越來越廣，我們在很多場合需要傳送JSON格式的參數。

        下面我使用HttpClient類庫提供的功能來實現這個，以便以后參考。

一.完善SpringMVC工程

        完善SpringMVC工程（修改之前的Spring工程地址：http://bijian1013.iteye.com/blog/2307353），使其不僅支持GET、POST兩種方式的請求，且支持普通表單數據請求和JSON格式的兩種請求數據，完整工程代碼見附件《SpringMVC.zip》，日志相關的依賴jar包可直接從HttpClient.zip中獲取到。

Java代碼   收藏代碼
  1. @Controller  
  2. public class HelloController {  
  3.   
  4.     private static Logger logger = LoggerFactory.getLogger(HelloController.class);  
  5.   
  6.     @Autowired  
  7.     private HelloService helloService;  
  8.   
  9.     @RequestMapping("/greeting")  
  10.     public ModelAndView greeting(@RequestParam(value = "name", defaultValue = "World") String name) {  
  11.   
  12.         Map<String, Object> map = new HashMap<String, Object>();  
  13.         try {  
  14.             //由於瀏覽器會把中文直接換成ISO-8859-1編碼格式,如果用戶在地址打入中文,需要進行如下轉換處理  
  15.             String tempName = new String(name.getBytes("ISO-8859-1"), "utf-8");  
  16.   
  17.             logger.trace("tempName:" + tempName);  
  18.             logger.info(tempName);  
  19.   
  20.             String userName = helloService.processService(tempName);  
  21.   
  22.             map.put("userName", userName);  
  23.               
  24.             logger.trace("運行結果:" + map);  
  25.         } catch (UnsupportedEncodingException e) {  
  26.             logger.error("HelloController greeting方法發生UnsupportedEncodingException異常:" + e);  
  27.         } catch (Exception e) {  
  28.             logger.error("HelloController greeting方法發生Exception異常:" + e);  
  29.         }  
  30.         return new ModelAndView("/hello", map);  
  31.     }  
  32.       
  33.     @RequestMapping(value="/processing", method = RequestMethod.POST)  
  34.     public ModelAndView processing(HttpServletRequest request, HttpServletResponse response) {  
  35.   
  36.         Enumeration en = request.getParameterNames();  
  37.         while (en.hasMoreElements()) {  
  38.             String paramName = (String) en.nextElement();  
  39.             String paramValue = request.getParameter(paramName);  
  40.         }  
  41.           
  42.         String name = request.getParameter("name");  
  43.         String age = request.getParameter("age");  
  44.           
  45.         UserDTO userDTO = new UserDTO();  
  46.         userDTO.setName(name);  
  47.         userDTO.setAge(Integer.valueOf(age));  
  48.           
  49.         logger.info("process param is :{}" + userDTO);  
  50.           
  51.         Map<String, Object> map = new HashMap<String, Object>();  
  52.         try {  
  53.             userDTO = helloService.processService(userDTO);  
  54.             //返回請求結果  
  55.             map.put("name", userDTO.getName());  
  56.             map.put("age", userDTO.getAge());  
  57.         } catch (Exception e) {  
  58.             logger.info("請求處理異常:" + e);  
  59.         }  
  60.         return new ModelAndView("/user", map);  
  61.     }  
  62.   
  63.     /** 
  64.      * @responseBody表示該方法的返回結果直接寫入HTTP response body中 
  65.      * 一般在異步獲取數據時使用，在使用@RequestMapping后，返回值通常解析為跳轉路徑 
  66.      * 加上@responseBody后返回結果不會被解析為跳轉路徑，而是直接寫入HTTP response body中。 
  67.      * 比如異步獲取json數據，加上@responsebody后，會直接返回json數據。 
  68.      */  
  69.     @ResponseBody  
  70.     @RequestMapping(value="/greet",method = RequestMethod.GET)  
  71.     public Map<String, Object> greet(HttpServletRequest request, HttpServletResponse response,   
  72.             @RequestParam(value = "name", defaultValue = "World") String name) {  
  73.   
  74.         Map<String, Object> map = null;  
  75.         try {  
  76.             //由於瀏覽器會把中文直接換成ISO-8859-1編碼格式,如果用戶在地址打入中文,需要進行如下轉換處理  
  77.             String tempName = new String(name.getBytes("ISO-8859-1"), "utf-8");  
  78.               
  79.             logger.trace("tempName:" + tempName);  
  80.             logger.info(tempName);  
  81.   
  82.             String userName = helloService.processService(tempName);  
  83.   
  84.             map = new HashMap<String, Object>();  
  85.             map.put("userName", userName);  
  86.               
  87.             logger.trace("運行結果:" + map);  
  88.         } catch (UnsupportedEncodingException e) {  
  89.             logger.error("HelloController greet方法發生UnsupportedEncodingException異常:" + e);  
  90.         } catch (Exception e) {  
  91.             logger.error("HelloController greet方法發生Exception異常:" + e);  
  92.         }  
  93.         return map;  
  94.     }  
  95.   
  96.     @ResponseBody  
  97.     @RequestMapping(value="/process",method = RequestMethod.POST)  
  98.     public String process(HttpServletRequest request, @RequestBody String requestBody) {  
  99.   
  100.         logger.info("process param is :{}" + requestBody);  
  101.         JSONObject result = new JSONObject();  
  102.         try {  
  103.             JSONObject jsonObject = JSONObject.fromObject(requestBody);  
  104.             UserDTO userDTO = (UserDTO) JSONObject.toBean(jsonObject, UserDTO.class);  
  105.   
  106.             userDTO = helloService.processService(userDTO);  
  107.   
  108.             //返回請求結果  
  109.             result.put("status", "SUCCESS");  
  110.             result.put("userDTO", userDTO);  
  111.         } catch (Exception e) {  
  112.             logger.info("請求處理異常！ params is:{}", requestBody);  
  113.             result.put("status", "FAIL");  
  114.         }  
  115.         return result.toString();  
  116.     }  
  117. }  

 

二.HttpClient請求普通的表單數據，返回HTML頁面

Java代碼   收藏代碼
  1. package com.bijian.study;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.IOException;  
  5. import java.io.InputStreamReader;  
  6. import java.util.Map;  
  7.   
  8. import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;  
  9. import org.apache.commons.httpclient.Header;  
  10. import org.apache.commons.httpclient.HttpClient;  
  11. import org.apache.commons.httpclient.HttpException;  
  12. import org.apache.commons.httpclient.HttpMethod;  
  13. import org.apache.commons.httpclient.HttpStatus;  
  14. import org.apache.commons.httpclient.NameValuePair;  
  15. import org.apache.commons.httpclient.methods.GetMethod;  
  16. import org.apache.commons.httpclient.methods.PostMethod;  
  17. import org.apache.commons.httpclient.params.HttpMethodParams;  
  18. import org.apache.http.client.methods.HttpPost;  
  19.   
  20. /** 
  21.  * Http請求工具類 
  22.  * 請求的是普通的表單數據，返回HTML頁面 
  23.  *  
  24.  * 需要導入commons-codec-1.3.jar 
  25.  */  
  26. public class HttpClientUtil {  
  27.   
  28.     /** 
  29.      * httpClient的get請求方式 
  30.      *  
  31.      * @param url 
  32.      * @param charset 
  33.      * @return 
  34.      * @throws Exception 
  35.      */  
  36.     public static String doGet(String url, String charset) throws Exception {  
  37.   
  38.         HttpClient client = new HttpClient();  
  39.         GetMethod method = new GetMethod(url);  
  40.   
  41.         if (null == url || !url.startsWith("http")) {  
  42.             throw new Exception("請求地址格式不對");  
  43.         }  
  44.         // 設置請求的編碼方式  
  45.         if (null != charset) {  
  46.             method.addRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=" + charset);  
  47.         } else {  
  48.             method.addRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=" + "utf-8");  
  49.         }  
  50.         int statusCode = client.executeMethod(method);  
  51.   
  52.         if (statusCode != HttpStatus.SC_OK) {// 打印服務器返回的狀態  
  53.             System.out.println("Method failed: " + method.getStatusLine());  
  54.         }  
  55.         // 返回響應消息  
  56.         byte[] responseBody = method.getResponseBodyAsString().getBytes(method.getResponseCharSet());  
  57.         // 在返回響應消息使用編碼(utf-8或gb2312)  
  58.         String response = new String(responseBody, "utf-8");  
  59.         System.out.println("------------------response:" + response);  
  60.         // 釋放連接  
  61.         method.releaseConnection();  
  62.         return response;  
  63.     }  
  64.   
  65.     /** 
  66.      * httpClient的get請求方式2 
  67.      *  
  68.      * @param url 
  69.      * @param charset 
  70.      * @return 
  71.      * @throws Exception 
  72.      */  
  73.     public static String doGet2(String url, String charset) throws Exception {  
  74.         /* 
  75.          * 使用 GetMethod 來訪問一個 URL 對應的網頁,實現步驟: 1:生成一個 HttpClinet 對象並設置相應的參數。 
  76.          * 2:生成一個 GetMethod 對象並設置響應的參數。 3:用 HttpClinet 生成的對象來執行 GetMethod 生成的Get 
  77.          * 方法。 4:處理響應狀態碼。 5:若響應正常，處理 HTTP 響應內容。 6:釋放連接。 
  78.          */  
  79.         /* 1 生成 HttpClinet 對象並設置參數 */  
  80.         HttpClient httpClient = new HttpClient();  
  81.         // 設置 Http 連接超時為5秒  
  82.         httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);  
  83.   
  84.         /* 2 生成 GetMethod 對象並設置參數 */  
  85.         GetMethod getMethod = new GetMethod(url);  
  86.         // 設置 get 請求超時為 5 秒  
  87.         getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);  
  88.         // 設置請求重試處理，用的是默認的重試處理：請求三次  
  89.         getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());  
  90.         String response = "";  
  91.         /* 3 執行 HTTP GET 請求 */  
  92.         try {  
  93.             int statusCode = httpClient.executeMethod(getMethod);  
  94.             /* 4 判斷訪問的狀態碼 */  
  95.             if (statusCode != HttpStatus.SC_OK) {  
  96.                 System.err.println("Method failed: " + getMethod.getStatusLine());  
  97.             }  
  98.             /* 5 處理 HTTP 響應內容 */  
  99.             // HTTP響應頭部信息，這里簡單打印  
  100.             Header[] headers = getMethod.getResponseHeaders();  
  101.             for (Header h : headers)  
  102.                 System.out.println(h.getName() + "------------ " + h.getValue());  
  103.             // 讀取 HTTP 響應內容，這里簡單打印網頁內容  
  104.             byte[] responseBody = getMethod.getResponseBody();// 讀取為字節數組  
  105.             response = new String(responseBody, charset);  
  106.             System.out.println("----------response:" + response);  
  107.             // 讀取為 InputStream，在網頁內容數據量大時候推薦使用  
  108.             // InputStream response = getMethod.getResponseBodyAsStream();  
  109.   
  110.         } catch (HttpException e) {  
  111.             // 發生致命的異常，可能是協議不對或者返回的內容有問題  
  112.             System.out.println("Please check your provided http address!");  
  113.             e.printStackTrace();  
  114.         } catch (IOException e) {  
  115.             // 發生網絡異常  
  116.             e.printStackTrace();  
  117.         } finally {  
  118.             /* 6 .釋放連接 */  
  119.             getMethod.releaseConnection();  
  120.         }  
  121.         return response;  
  122.     }  
  123.   
  124.     /** 
  125.      * 執行一個HTTP POST請求，返回請求響應的HTML 
  126.      *  
  127.      * @param url  請求的URL地址 
  128.      * @param params  請求的查詢參數,可以為null 
  129.      * @param charset 字符集 
  130.      * @param pretty 是否美化 
  131.      * @return 返回請求響應的HTML 
  132.      */  
  133.     public static String doPost(String url, Map<String, Object> _params, String charset, boolean pretty) {  
  134.           
  135.         StringBuffer response = new StringBuffer();  
  136.         HttpClient client = new HttpClient();  
  137.         PostMethod method = new PostMethod(url);  
  138.           
  139.         // 設置Http Post數據  
  140.         if (_params != null) {  
  141.             for (Map.Entry<String, Object> entry : _params.entrySet()) {  
  142.                 method.setParameter(entry.getKey(), String.valueOf(entry.getValue()));  
  143.             }  
  144.         }  
  145.           
  146.         // 設置Http Post數據  方法二  
  147. //        if(_params != null) {  
  148. //            NameValuePair[] pairs = new NameValuePair[_params.size()];//純參數了，鍵值對  
  149. //            int i = 0;  
  150. //            for (Map.Entry<String, Object> entry : _params.entrySet()) {  
  151. //                pairs[i] = new NameValuePair(entry.getKey(), String.valueOf(entry.getValue()));  
  152. //                i++;  
  153. //            }  
  154. //            method.addParameters(pairs);  
  155. //        }  
  156.           
  157.         try {  
  158.             client.executeMethod(method);  
  159.             if (method.getStatusCode() == HttpStatus.SC_OK) {  
  160.                 // 讀取為 InputStream，在網頁內容數據量大時候推薦使用  
  161.                 BufferedReader reader = new BufferedReader(new InputStreamReader(method.getResponseBodyAsStream(),  
  162.                         charset));  
  163.                 String line;  
  164.                 while ((line = reader.readLine()) != null) {  
  165.                     if (pretty)  
  166.                         response.append(line).append(System.getProperty("line.separator"));  
  167.                     else  
  168.                         response.append(line);  
  169.                 }  
  170.                 reader.close();  
  171.             }  
  172.         } catch (IOException e) {  
  173.             System.out.println("執行HTTP Post請求" + url + "時，發生異常！");  
  174.             e.printStackTrace();  
  175.         } finally {  
  176.             method.releaseConnection();  
  177.         }  
  178.         System.out.println("--------------------" + response.toString());  
  179.         return response.toString();  
  180.     }  
  181. }  

        測試類HttpClientTest.java

Java代碼   收藏代碼
  1. package com.bijian.study;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5.   
  6. import org.slf4j.Logger;  
  7. import org.slf4j.LoggerFactory;  
  8.   
  9. public class HttpClientTest {  
  10.   
  11.     private static Logger logger = LoggerFactory.getLogger(HttpRequestTest.class);  
  12.   
  13.     public static void main(String[] args) {  
  14.   
  15.         getRequestTest();  
  16.         getRequestTest2();  
  17.         postRequestTest();  
  18.     }  
  19.   
  20.     private static void getRequestTest() {  
  21.   
  22.         String url = "http://localhost:8080/SpringMVC/greeting?name=lisi";  
  23.         try {  
  24.             String str = HttpClientUtil.doGet(url, "UTF-8");  
  25.             if (str != null) {  
  26.                 logger.info("http Get request result:" + str);  
  27.             } else {  
  28.                 logger.info("http Get request process fail");  
  29.             }  
  30.         } catch (Exception e) {  
  31.             e.printStackTrace();  
  32.         }  
  33.     }  
  34.   
  35.     private static void getRequestTest2() {  
  36.   
  37.         String url = "http://localhost:8080/SpringMVC/greeting?name=lisi";  
  38.         try {  
  39.             String str = HttpClientUtil.doGet2(url, "UTF-8");  
  40.             if (str != null) {  
  41.                 logger.info("http Get request result:" + str);  
  42.             } else {  
  43.                 logger.info("http Get request process fail");  
  44.             }  
  45.         } catch (Exception e) {  
  46.             e.printStackTrace();  
  47.         }  
  48.     }  
  49.   
  50.     private static void postRequestTest() {  
  51.   
  52.         String url = "http://localhost:8080/SpringMVC/processing";  
  53.   
  54.         Map<String, Object> _params = new HashMap<String, Object>();  
  55.         _params.put("name", "zhangshang");  
  56.         _params.put("age", 25);  
  57.         String str = HttpClientUtil.doPost(url, _params, "UTF-8", true);  
  58.         if (str != null) {  
  59.             logger.info("http Post request result:" + str);  
  60.         } else {  
  61.             logger.info("http Post request process fail");  
  62.         }  
  63.     }  
  64. }  

 

三.HttpClient請求json數據返回json數據

Java代碼   收藏代碼
  1. package com.bijian.study;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.URLDecoder;  
  5.   
  6. import net.sf.json.JSONObject;  
  7.   
  8. import org.apache.http.HttpResponse;  
  9. import org.apache.http.HttpStatus;  
  10. import org.apache.http.client.methods.HttpGet;  
  11. import org.apache.http.client.methods.HttpPost;  
  12. import org.apache.http.entity.StringEntity;  
  13. import org.apache.http.impl.client.DefaultHttpClient;  
  14. import org.apache.http.util.EntityUtils;  
  15. import org.slf4j.Logger;  
  16. import org.slf4j.LoggerFactory;  
  17.   
  18. /** 
  19.  * Http請求工具類,發送json返回json 
  20.  *  
  21.  * 除了要導入json-lib-2.1.jar之外，還必須有其它幾個依賴包： 
  22.  * commons-beanutils.jar 
  23.  * commons-httpclient.jar 
  24.  * commons-lang.jar 
  25.  * ezmorph.jar 
  26.  * morph-1.0.1.jar 
  27.  * 另外，commons-collections.jar也需要導入 
  28.  */  
  29. public class HttpRequestUtil {  
  30.       
  31.     private static Logger logger = LoggerFactory.getLogger(HttpRequestUtil.class);      
  32.   
  33.     /** 
  34.      * 發送get請求 
  35.      * @param url 路徑 
  36.      * @return 
  37.      */  
  38.     public static JSONObject httpGet(String url){  
  39.           
  40.         //get請求返回結果  
  41.         JSONObject jsonResult = null;  
  42.         try {  
  43.             DefaultHttpClient client = new DefaultHttpClient();  
  44.             //發送get請求  
  45.             HttpGet request = new HttpGet(url);  
  46.             HttpResponse response = client.execute(request);  
  47.   
  48.             /**請求發送成功，並得到響應**/  
  49.             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {  
  50.                 /**讀取服務器返回過來的json字符串數據**/  
  51.                 String strResult = EntityUtils.toString(response.getEntity());  
  52.                 /**把json字符串轉換成json對象**/  
  53.                 jsonResult = JSONObject.fromObject(strResult);  
  54.                 url = URLDecoder.decode(url, "UTF-8");  
  55.             } else {  
  56.                 logger.error("get請求提交失敗:" + url);  
  57.             }  
  58.         } catch (IOException e) {  
  59.             logger.error("get請求提交失敗:" + url, e);  
  60.         }  
  61.         return jsonResult;  
  62.     }  
  63.       
  64.     /** 
  65.      * httpPost 
  66.      * @param url  路徑 
  67.      * @param jsonParam 參數 
  68.      * @return 
  69.      */  
  70.     public static JSONObject httpPost(String url,JSONObject jsonParam){  
  71.         return httpPost(url, jsonParam, false);  
  72.     }  
  73.   
  74.     /** 
  75.      * post請求 
  76.      * @param url         url地址 
  77.      * @param jsonParam     參數 
  78.      * @param noNeedResponse    不需要返回結果 
  79.      * @return 
  80.      */  
  81.     public static JSONObject httpPost(String url,JSONObject jsonParam, boolean noNeedResponse){  
  82.           
  83.         //post請求返回結果  
  84.         DefaultHttpClient httpClient = new DefaultHttpClient();  
  85.         JSONObject jsonResult = null;  
  86.         HttpPost method = new HttpPost(url);  
  87.         try {  
  88.             if (null != jsonParam) {  
  89.                 //解決中文亂碼問題  
  90.                 StringEntity entity = new StringEntity(jsonParam.toString(), "utf-8");  
  91.                 entity.setContentEncoding("UTF-8");  
  92.                 entity.setContentType("application/json");  
  93.                 method.setEntity(entity);  
  94.             }  
  95.             HttpResponse result = httpClient.execute(method);  
  96.             url = URLDecoder.decode(url, "UTF-8");  
  97.             /**請求發送成功，並得到響應**/  
  98.             if (result.getStatusLine().getStatusCode() == 200) {  
  99.                 String str = "";  
  100.                 try {  
  101.                     /**讀取服務器返回過來的json字符串數據**/  
  102.                     str = EntityUtils.toString(result.getEntity());  
  103.                     if (noNeedResponse) {  
  104.                         return null;  
  105.                     }  
  106.                     /**把json字符串轉換成json對象**/  
  107.                     jsonResult = JSONObject.fromObject(str);  
  108.                 } catch (Exception e) {  
  109.                     logger.error("post請求提交失敗:" + url, e);  
  110.                 }  
  111.             }  
  112.         } catch (IOException e) {  
  113.             logger.error("post請求提交失敗:" + url, e);  
  114.         }  
  115.         return jsonResult;  
  116.     }  
  117. }  

        測試類HttpRequestTest.java

Java代碼   收藏代碼
  1. package com.bijian.study;  
  2.   
  3. import org.slf4j.Logger;  
  4. import org.slf4j.LoggerFactory;  
  5.   
  6. import net.sf.json.JSONObject;  
  7.   
  8. import com.bijian.study.dto.UserDTO;  
  9.   
  10. /** 
  11.  * Http請求測試類 
  12.  */  
  13. public class HttpRequestTest {  
  14.   
  15.     private static Logger logger = LoggerFactory.getLogger(HttpRequestTest.class);  
  16.       
  17.     public static void main(String[] args) {  
  18.           
  19.         getRequestTest();  
  20.         postRequestTest();  
  21.     }  
  22.   
  23.     private static void getRequestTest() {  
  24.           
  25.         String url = "http://localhost:8080/SpringMVC/greet?name=lisi";  
  26.         JSONObject jsonObject = HttpRequestUtil.httpGet(url);  
  27.         if(jsonObject != null) {  
  28.             String userName = (String) jsonObject.get("userName");  
  29.             logger.info("http Get request process sucess");  
  30.             logger.info("userName:" + userName);  
  31.         }else {  
  32.             logger.info("http Get request process fail");  
  33.         }  
  34.     }  
  35.   
  36.     private static void postRequestTest() {  
  37.           
  38.         String url = "http://localhost:8080/SpringMVC/process";  
  39.           
  40.         UserDTO userDTO = new UserDTO();  
  41.         userDTO.setName("zhangshang");  
  42.         userDTO.setAge(25);  
  43.         JSONObject jsonParam = JSONObject.fromObject(userDTO);  
  44.           
  45.         JSONObject responseJSONObject = HttpRequestUtil.httpPost(url, jsonParam);  
  46.         if(responseJSONObject != null && "SUCCESS".equals(responseJSONObject.get("status"))) {  
  47.             JSONObject userStr = (JSONObject) responseJSONObject.get("userDTO");  
  48.             userDTO = (UserDTO) JSONObject.toBean(userStr, UserDTO.class);  
  49.               
  50.             logger.info("http Post request process sucess");  
  51.             logger.info("userDTO:" + userDTO);  
  52.         }else {  
  53.             logger.info("http Post request process fail");  
  54.         }  
  55.     }  
  56. }  

        完整的工程代碼請下載附件《HttpClient.zip》。

 

四.補充說明

        1.如果會出現異常：java.lang.NoClassDefFoundError: net/sf/ezmorph/Morpher，原因是少了JAR包，造成類找不到，除了要導入JSON網站上面下載的json-lib-2.1.jar包之外，還必須有其它幾個依賴包：

Text代碼   收藏代碼
  1. commons-beanutils.jar  
  2. commons-httpclient.jar  
  3. commons-lang.jar  
  4. ezmorph.jar  
  5. morph-1.0.1.jar  

        2.@responseBody表示該方法的返回結果直接寫入HTTP response body中。一般在異步獲取數據時使用，在使用@RequestMapping后，返回值通常解析為跳轉路徑，加上@responseBody后返回結果不會被解析為跳轉路徑，而是直接寫入HTTP response body中。比如異步獲取json數據，加上@responsebody后，會直接返回json數據。

        3.關於HttpClient的其它方面的學習使用，可以參考：http://www.iteblog.com/archives/1379。附件《httpclientutil.zip》就是從這里下載的。

        4.在實際使用當中，我們可能需要隨機變換請求數據，甚至隨機請求不同的服務器，可以參考如下方式。

Java代碼   收藏代碼
  1. public static void main(String arg[]) throws Exception {  
  2.     while (true) {  
  3.         String[] urlArray = {Constant.URL_1, Constant.URL_2};  
  4.         int index = new Random().nextInt(2);  
  5.         String requestUrl = urlArray[index];  
  6.         System.out.println(requestUrl);  
  7.           
  8.         ...  
  9.           
  10.         JSONObject jsonMsg = JSONObject.fromObject(obj);  
  11.           
  12.         String ret = HttpRequestUtil.doPost(requestUrl, jsonMsg);  
  13.         System.out.println(ret);  
  14.         Thread.sleep(50);  
  15.     }  
  16. }  

Constant.java

Java代碼   收藏代碼
  1. public class Constant {  
  2.   
  3.     public static final String URL_1 = PropertiesFileUtil.getPropValue("url1", "config");  
  4.     public static final String URL_2 = PropertiesFileUtil.getPropValue("url2", "config");  
  5. }  
PropertiesFileUtil.java
Java代碼   收藏代碼
  1. import java.util.ResourceBundle;  
  2.   
  3. import org.apache.commons.lang.StringUtils;  
  4.   
  5. public final class PropertiesFileUtil {  
  6.   
  7.     public static String getPropValue(String keyName, String propsName) {  
  8.   
  9.         ResourceBundle resource = ResourceBundle.getBundle(propsName);  
  10.         String value = resource.getString(keyName);  
  11.         return value;  
  12.     }  
  13.   
  14.     /** 
  15.      * 獲取配置文件中keyName對應的value 
  16.      */  
  17.     public static String getPropValue(String keyName, String propsName, String defaultValue) {  
  18.   
  19.         ResourceBundle resource = ResourceBundle.getBundle(propsName);  
  20.         String value = resource.getString(keyName);  
  21.         if (StringUtils.isEmpty(value)) {  
  22.             value = defaultValue;  
  23.         }  
  24.         return value;  
  25.     }  
  26. }  
config.properties
Java代碼   收藏代碼
  1. url1=http://localhost:8080/SpringMVC/greet?name=lisi  
  2. url2=http://127.0.0.1:8080/SpringMVC/greet?name=zhangshan  


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 JAVA發送HttpClient請求及接收請求結果 JAVA發送HttpClient請求及接收請求結果過程 JAVA發送HttpClient請求及接收請求結果過程 java httpclient發送json 請求 ,go服務端接收 [java,2018-01-16] HttpClient發送、接收 json 請求 HttpClient，get請求，發送並接收數據 使用HttpClient發送和接收JSON請求 使用HttpClient發送請求接收響應 使用HttpClient發送請求、接收響應 HttpClient發送請求和接收參數
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM