JAVA发送HttpClient

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中获取到。

1. @Controller
2. public class HelloController {
3. private static Logger logger = LoggerFactory.getLogger(HelloController.class);
4. @Autowired
5. private HelloService helloService;
6. @RequestMapping("/greeting")
7. public ModelAndView greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
8. Map<String, Object> map = new HashMap<String, Object>();
9. try {
10. //由于浏览器会把中文直接换成ISO-8859-1编码格式,如果用户在地址打入中文,需要进行如下转换处理
11. String tempName = new String(name.getBytes("ISO-8859-1"), "utf-8");
12. logger.trace("tempName:" + tempName);
13. logger.info(tempName);
14. String userName = helloService.processService(tempName);
15. map.put("userName", userName);
16. logger.trace("运行结果:" + map);
17. } catch (UnsupportedEncodingException e) {
18. logger.error("HelloController greeting方法发生UnsupportedEncodingException异常:" + e);
19. } catch (Exception e) {
20. logger.error("HelloController greeting方法发生Exception异常:" + e);
21. }
22. return new ModelAndView("/hello", map);
23. }
24. @RequestMapping(value="/processing", method = RequestMethod.POST)
25. public ModelAndView processing(HttpServletRequest request, HttpServletResponse response) {
26. Enumeration en = request.getParameterNames();
27. while (en.hasMoreElements()) {
28. String paramName = (String) en.nextElement();
29. String paramValue = request.getParameter(paramName);
30. }
31. String name = request.getParameter("name");
32. String age = request.getParameter("age");
33. UserDTO userDTO = new UserDTO();
34. userDTO.setName(name);
35. userDTO.setAge(Integer.valueOf(age));
36. logger.info("process param is :{}" + userDTO);
37. Map<String, Object> map = new HashMap<String, Object>();
38. try {
39. userDTO = helloService.processService(userDTO);
40. //返回请求结果
41. map.put("name", userDTO.getName());
42. map.put("age", userDTO.getAge());
43. } catch (Exception e) {
44. logger.info("请求处理异常:" + e);
45. }
46. return new ModelAndView("/user", map);
47. }
48. /**
49. * @responseBody表示该方法的返回结果直接写入HTTP response body中
50. * 一般在异步获取数据时使用，在使用@RequestMapping后，返回值通常解析为跳转路径
51. * 加上@responseBody后返回结果不会被解析为跳转路径，而是直接写入HTTP response body中。
52. * 比如异步获取json数据，加上@responsebody后，会直接返回json数据。
53. */
54. @ResponseBody
55. @RequestMapping(value="/greet",method = RequestMethod.GET)
56. public Map<String, Object> greet(HttpServletRequest request, HttpServletResponse response,
57. @RequestParam(value = "name", defaultValue = "World") String name) {
58. Map<String, Object> map = null;
59. try {
60. //由于浏览器会把中文直接换成ISO-8859-1编码格式,如果用户在地址打入中文,需要进行如下转换处理
61. String tempName = new String(name.getBytes("ISO-8859-1"), "utf-8");
62. logger.trace("tempName:" + tempName);
63. logger.info(tempName);
64. String userName = helloService.processService(tempName);
65. map = new HashMap<String, Object>();
66. map.put("userName", userName);
67. logger.trace("运行结果:" + map);
68. } catch (UnsupportedEncodingException e) {
69. logger.error("HelloController greet方法发生UnsupportedEncodingException异常:" + e);
70. } catch (Exception e) {
71. logger.error("HelloController greet方法发生Exception异常:" + e);
72. }
73. return map;
74. }
75. @ResponseBody
76. @RequestMapping(value="/process",method = RequestMethod.POST)
77. public String process(HttpServletRequest request, @RequestBody String requestBody) {
78. logger.info("process param is :{}" + requestBody);
79. JSONObject result = new JSONObject();
80. try {
81. JSONObject jsonObject = JSONObject.fromObject(requestBody);
82. UserDTO userDTO = (UserDTO) JSONObject.toBean(jsonObject, UserDTO.class);
83. userDTO = helloService.processService(userDTO);
84. //返回请求结果
85. result.put("status", "SUCCESS");
86. result.put("userDTO", userDTO);
87. } catch (Exception e) {
88. logger.info("请求处理异常！ params is:{}", requestBody);
89. result.put("status", "FAIL");
90. }
91. return result.toString();
92. }
93. }

二.HttpClient请求普通的表单数据，返回HTML页面

1. package com.bijian.study;
2. import java.io.BufferedReader;
3. import java.io.IOException;
4. import java.io.InputStreamReader;
5. import java.util.Map;
6. import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
7. import org.apache.commons.httpclient.Header;
8. import org.apache.commons.httpclient.HttpClient;
9. import org.apache.commons.httpclient.HttpException;
10. import org.apache.commons.httpclient.HttpMethod;
11. import org.apache.commons.httpclient.HttpStatus;
12. import org.apache.commons.httpclient.NameValuePair;
13. import org.apache.commons.httpclient.methods.GetMethod;
14. import org.apache.commons.httpclient.methods.PostMethod;
15. import org.apache.commons.httpclient.params.HttpMethodParams;
16. import org.apache.http.client.methods.HttpPost;
17. /**
18. * Http请求工具类
19. * 请求的是普通的表单数据，返回HTML页面
20. *
21. * 需要导入commons-codec-1.3.jar
22. */
23. public class HttpClientUtil {
24. /**
25. * httpClient的get请求方式
26. *
27. * @param url
28. * @param charset
29. * @return
30. * @throws Exception
31. */
32. public static String doGet(String url, String charset) throws Exception {
33. HttpClient client = new HttpClient();
34. GetMethod method = new GetMethod(url);
35. if (null == url || !url.startsWith("http")) {
36. throw new Exception("请求地址格式不对");
37. }
38. // 设置请求的编码方式
39. if (null != charset) {
40. method.addRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=" + charset);
41. } else {
42. method.addRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=" + "utf-8");
43. }
44. int statusCode = client.executeMethod(method);
45. if (statusCode != HttpStatus.SC_OK) {// 打印服务器返回的状态
46. System.out.println("Method failed: " + method.getStatusLine());
47. }
48. // 返回响应消息
49. byte[] responseBody = method.getResponseBodyAsString().getBytes(method.getResponseCharSet());
50. // 在返回响应消息使用编码(utf-8或gb2312)
51. String response = new String(responseBody, "utf-8");
52. System.out.println("------------------response:" + response);
53. // 释放连接
54. method.releaseConnection();
55. return response;
56. }
57. /**
58. * httpClient的get请求方式2
59. *
60. * @param url
61. * @param charset
62. * @return
63. * @throws Exception
64. */
65. public static String doGet2(String url, String charset) throws Exception {
66. /*
67. * 使用 GetMethod 来访问一个 URL 对应的网页,实现步骤: 1:生成一个 HttpClinet 对象并设置相应的参数。
68. * 2:生成一个 GetMethod 对象并设置响应的参数。 3:用 HttpClinet 生成的对象来执行 GetMethod 生成的Get
69. * 方法。 4:处理响应状态码。 5:若响应正常，处理 HTTP 响应内容。 6:释放连接。
70. */
71. /* 1 生成 HttpClinet 对象并设置参数 */
72. HttpClient httpClient = new HttpClient();
73. // 设置 Http 连接超时为5秒
74. httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
75. /* 2 生成 GetMethod 对象并设置参数 */
76. GetMethod getMethod = new GetMethod(url);
77. // 设置 get 请求超时为 5 秒
78. getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);
79. // 设置请求重试处理，用的是默认的重试处理：请求三次
80. getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
81. String response = "";
82. /* 3 执行 HTTP GET 请求 */
83. try {
84. int statusCode = httpClient.executeMethod(getMethod);
85. /* 4 判断访问的状态码 */
86. if (statusCode != HttpStatus.SC_OK) {
87. System.err.println("Method failed: " + getMethod.getStatusLine());
88. }
89. /* 5 处理 HTTP 响应内容 */
90. // HTTP响应头部信息，这里简单打印
91. Header[] headers = getMethod.getResponseHeaders();
92. for (Header h : headers)
93. System.out.println(h.getName() + "------------ " + h.getValue());
94. // 读取 HTTP 响应内容，这里简单打印网页内容
95. byte[] responseBody = getMethod.getResponseBody();// 读取为字节数组
96. response = new String(responseBody, charset);
97. System.out.println("----------response:" + response);
98. // 读取为 InputStream，在网页内容数据量大时候推荐使用
99. // InputStream response = getMethod.getResponseBodyAsStream();
100. } catch (HttpException e) {
101. // 发生致命的异常，可能是协议不对或者返回的内容有问题
102. System.out.println("Please check your provided http address!");
103. e.printStackTrace();
104. } catch (IOException e) {
105. // 发生网络异常
106. e.printStackTrace();
107. } finally {
108. /* 6 .释放连接 */
109. getMethod.releaseConnection();
110. }
111. return response;
112. }
113. /**
114. * 执行一个HTTP POST请求，返回请求响应的HTML
115. *
116. * @param url  请求的URL地址
117. * @param params  请求的查询参数,可以为null
118. * @param charset 字符集
119. * @param pretty 是否美化
120. * @return 返回请求响应的HTML
121. */
122. public static String doPost(String url, Map<String, Object> _params, String charset, boolean pretty) {
123. StringBuffer response = new StringBuffer();
124. HttpClient client = new HttpClient();
125. PostMethod method = new PostMethod(url);
126. // 设置Http Post数据
127. if (_params != null) {
128. for (Map.Entry<String, Object> entry : _params.entrySet()) {
129. method.setParameter(entry.getKey(), String.valueOf(entry.getValue()));
130. }
131. }
132. // 设置Http Post数据  方法二
133. //        if(_params != null) {
134. //            NameValuePair[] pairs = new NameValuePair[_params.size()];//纯参数了，键值对
135. //            int i = 0;
136. //            for (Map.Entry<String, Object> entry : _params.entrySet()) {
137. //                pairs[i] = new NameValuePair(entry.getKey(), String.valueOf(entry.getValue()));
138. //                i++;
139. //            }
140. //            method.addParameters(pairs);
141. //        }
142. try {
143. client.executeMethod(method);
144. if (method.getStatusCode() == HttpStatus.SC_OK) {
145. // 读取为 InputStream，在网页内容数据量大时候推荐使用
146. BufferedReader reader = new BufferedReader(new InputStreamReader(method.getResponseBodyAsStream(),
147. charset));
148. String line;
149. while ((line = reader.readLine()) != null) {
150. if (pretty)
151. response.append(line).append(System.getProperty("line.separator"));
152. else
153. response.append(line);
154. }
155. reader.close();
156. }
157. } catch (IOException e) {
158. System.out.println("执行HTTP Post请求" + url + "时，发生异常！");
159. e.printStackTrace();
160. } finally {
161. method.releaseConnection();
162. }
163. System.out.println("--------------------" + response.toString());
164. return response.toString();
165. }
166. }

测试类HttpClientTest.java

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

三.HttpClient请求json数据返回json数据

1. package com.bijian.study;
2. import java.io.IOException;
3. import java.net.URLDecoder;
4. import net.sf.json.JSONObject;
5. import org.apache.http.HttpResponse;
6. import org.apache.http.HttpStatus;
7. import org.apache.http.client.methods.HttpGet;
8. import org.apache.http.client.methods.HttpPost;
9. import org.apache.http.entity.StringEntity;
10. import org.apache.http.impl.client.DefaultHttpClient;
11. import org.apache.http.util.EntityUtils;
12. import org.slf4j.Logger;
13. import org.slf4j.LoggerFactory;
14. /**
15. * Http请求工具类,发送json返回json
16. *
17. * 除了要导入json-lib-2.1.jar之外，还必须有其它几个依赖包：
18. * commons-beanutils.jar
19. * commons-httpclient.jar
20. * commons-lang.jar
21. * ezmorph.jar
22. * morph-1.0.1.jar
23. * 另外，commons-collections.jar也需要导入
24. */
25. public class HttpRequestUtil {
26. private static Logger logger = LoggerFactory.getLogger(HttpRequestUtil.class);
27. /**
28. * 发送get请求
29. * @param url 路径
30. * @return
31. */
32. public static JSONObject httpGet(String url){
33. //get请求返回结果
34. JSONObject jsonResult = null;
35. try {
36. DefaultHttpClient client = new DefaultHttpClient();
37. //发送get请求
38. HttpGet request = new HttpGet(url);
39. HttpResponse response = client.execute(request);
40. /**请求发送成功，并得到响应**/
41. if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
42. /**读取服务器返回过来的json字符串数据**/
43. String strResult = EntityUtils.toString(response.getEntity());
44. /**把json字符串转换成json对象**/
45. jsonResult = JSONObject.fromObject(strResult);
46. url = URLDecoder.decode(url, "UTF-8");
47. } else {
48. logger.error("get请求提交失败:" + url);
49. }
50. } catch (IOException e) {
51. logger.error("get请求提交失败:" + url, e);
52. }
53. return jsonResult;
54. }
55. /**
56. * httpPost
57. * @param url  路径
58. * @param jsonParam 参数
59. * @return
60. */
61. public static JSONObject httpPost(String url,JSONObject jsonParam){
62. return httpPost(url, jsonParam, false);
63. }
64. /**
65. * post请求
66. * @param url         url地址
67. * @param jsonParam     参数
68. * @param noNeedResponse    不需要返回结果
69. * @return
70. */
71. public static JSONObject httpPost(String url,JSONObject jsonParam, boolean noNeedResponse){
72. //post请求返回结果
73. DefaultHttpClient httpClient = new DefaultHttpClient();
74. JSONObject jsonResult = null;
75. HttpPost method = new HttpPost(url);
76. try {
77. if (null != jsonParam) {
78. //解决中文乱码问题
79. StringEntity entity = new StringEntity(jsonParam.toString(), "utf-8");
80. entity.setContentEncoding("UTF-8");
81. entity.setContentType("application/json");
82. method.setEntity(entity);
83. }
84. HttpResponse result = httpClient.execute(method);
85. url = URLDecoder.decode(url, "UTF-8");
86. /**请求发送成功，并得到响应**/
87. if (result.getStatusLine().getStatusCode() == 200) {
88. String str = "";
89. try {
90. /**读取服务器返回过来的json字符串数据**/
91. str = EntityUtils.toString(result.getEntity());
92. if (noNeedResponse) {
93. return null;
94. }
95. /**把json字符串转换成json对象**/
96. jsonResult = JSONObject.fromObject(str);
97. } catch (Exception e) {
98. logger.error("post请求提交失败:" + url, e);
99. }
100. }
101. } catch (IOException e) {
102. logger.error("post请求提交失败:" + url, e);
103. }
104. return jsonResult;
105. }
106. }

测试类HttpRequestTest.java

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

完整的工程代码请下载附件《HttpClient.zip》。

四.补充说明

1.如果会出现异常：java.lang.NoClassDefFoundError: net/sf/ezmorph/Morpher，原因是少了JAR包，造成类找不到，除了要导入JSON网站上面下载的json-lib-2.1.jar包之外，还必须有其它几个依赖包：

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.在实际使用当中，我们可能需要随机变换请求数据，甚至随机请求不同的服务器，可以参考如下方式。

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. JSONObject jsonMsg = JSONObject.fromObject(obj);
9. String ret = HttpRequestUtil.doPost(requestUrl, jsonMsg);
10. System.out.println(ret);
11. Thread.sleep(50);
12. }
13. }

Constant.java

1. public class Constant {
2. public static final String URL_1 = PropertiesFileUtil.getPropValue("url1", "config");
3. public static final String URL_2 = PropertiesFileUtil.getPropValue("url2", "config");
4. }

PropertiesFileUtil.java

1. import java.util.ResourceBundle;
2. import org.apache.commons.lang.StringUtils;
3. public final class PropertiesFileUtil {
4. public static String getPropValue(String keyName, String propsName) {
5. ResourceBundle resource = ResourceBundle.getBundle(propsName);
6. String value = resource.getString(keyName);
7. return value;
8. }
9. /**
10. * 获取配置文件中keyName对应的value
11. */
12. public static String getPropValue(String keyName, String propsName, String defaultValue) {
13. ResourceBundle resource = ResourceBundle.getBundle(propsName);
14. String value = resource.getString(keyName);
15. if (StringUtils.isEmpty(value)) {
16. value = defaultValue;
17. }
18. return value;
19. }
20. }

config.properties

1. url1=http://localhost:8080/SpringMVC/greet?name=lisi
2. url2=http://127.0.0.1:8080/SpringMVC/greet?name=zhangshan