apache.httpclient工具包HTTP连接池请求例子

在工作中有用到HTTP请求外部地址传递数据.

用Url这个类明显效率低下,所以改用连接池概念的URL请求,这将大大提高了请求效率.

主发送类

[java]  view plain copy

1. package com.cdg.test;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5.   
6. import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;  
7. import org.apache.commons.httpclient.NameValuePair;  
8. import org.apache.commons.httpclient.methods.PostMethod;  
9. import org.apache.commons.httpclient.params.HttpMethodParams;  
10.   
11. public class HttpClientTest {  
12.   
13.     /** 
14.      * 组装参数,这里用Map,一键一值比较通用,可以当做共用方法 
15.      * @param params 
16.      * @return 
17.      */  
18.     private NameValuePair[] buildNameValuePairs(Map<String, String> params) {  
19.         Object[] keys = params.keySet().toArray();  
20.         NameValuePair[] pairs = new NameValuePair[keys.length];  
21.   
22.         for (int i = 0; i < keys.length; i++) {  
23.             String key = (String) keys[i];  
24.             pairs[i] = new NameValuePair(key, params.get(key));  
25.         }  
26.   
27.         return pairs;  
28.     }  
29.   
30.     /** 
31.      * 发送HTTP请求 
32.      * @param bean 
33.      * @return 
34.      */  
35.     public String lscmToOutsideService(PushData bean) {  
36.   
37.         String url = bean.getUrl();  
38.         HashMap<String, String> params = bean.getParams();  
39.         String code = bean.getEncode();  
40.         if (null == url || "".equals(url.trim())) {  
41.             return HttpClientUtil.returnError("推送地址错误[url=" + url + "]");  
42.         }  
43.         if (null == code || "".equals(code.trim())) {  
44.             return HttpClientUtil.returnError("编码错误[code=" + code + "]");  
45.         }  
46.           
47.         if (null == params || params.size() == 0) {  
48.             return HttpClientUtil.returnError("无传递参数[params.size = 0]");  
49.         }  
50.         NameValuePair[] pairs = buildNameValuePairs(params);//组装参数  
51.         PostMethod postMethod = new PostMethod(url);//放地址  
52.         postMethod.setRequestHeader("Content-type",  
53.                 "application/x-www-form-urlencoded; charset=" + code);  
54.         postMethod.setRequestBody(pairs);  
55.         postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,  
56.                 new DefaultHttpMethodRetryHandler());  
57.   
58.         return HttpClientUtil.doHttpRequest(postMethod, code);  
59.     }  
60.   
61.     /** 
62.      * 测试一下 
63.      * @param args 
64.      */  
65.     public static void main(String[] args) {  
66.   
67.         String url = "http://10.0.2.241:8080/xxx/XxxServlet";  
68.           
69.         String xml = "xxxxxxxxxxxxxxxxxxxxxxx";  
70.         PushData bean = new PushData();  
71.         bean.setEncode("UTF-8");  
72.         bean.setUrl(url);  
73.         HashMap<String, String> params = new HashMap<String, String>();  
74.         params.put("aaaa", xml);  
75.         params.put("bbbb", "bbbxxxx");  
76.         bean.setParams(params);  
77.         String r = new HttpClientTest().lscmToOutsideService(bean);  
78.         System.out.println(r);  
79.           
80.     }  
81. }  

工具类

[java]  view plain copy

1. package com.cdg.test;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6. import java.net.SocketTimeoutException;  
7. import java.net.UnknownHostException;  
8. import java.util.ArrayList;  
9. import java.util.List;  
10.   
11. import org.apache.commons.httpclient.Header;  
12. import org.apache.commons.httpclient.HttpClient;  
13. import org.apache.commons.httpclient.HttpConnectionManager;  
14. import org.apache.commons.httpclient.HttpException;  
15. import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;  
16. import org.apache.commons.httpclient.methods.PostMethod;  
17. import org.apache.commons.httpclient.params.HttpConnectionManagerParams;  
18. import org.apache.commons.logging.Log;  
19. import org.apache.commons.logging.LogFactory;  
20.   
21. public class HttpClientUtil {  
22.     /** 
23.      * 日志处理类 
24.      */  
25.     private static final Log log = LogFactory.getLog(HttpClientUtil.class);  
26.   
27.     // 读取超时  
28.     private final static int SOCKET_TIMEOUT = 10000;  
29.     // 连接超时  
30.     private final static int CONNECTION_TIMEOUT = 10000;  
31.     // 每个HOST的最大连接数量  
32.     private final static int MAX_CONN_PRE_HOST = 20;  
33.     // 连接池的最大连接数  
34.     private final static int MAX_CONN = 60;  
35.     // 连接池  
36.     private final static HttpConnectionManager httpConnectionManager;  
37.   
38.     static {  
39.         httpConnectionManager = new MultiThreadedHttpConnectionManager();  
40.         HttpConnectionManagerParams params = httpConnectionManager.getParams();  
41.         params.setConnectionTimeout(CONNECTION_TIMEOUT);  
42.         params.setSoTimeout(SOCKET_TIMEOUT);  
43.         params.setDefaultMaxConnectionsPerHost(MAX_CONN_PRE_HOST);  
44.         params.setMaxTotalConnections(MAX_CONN);  
45.     }  
46.   
47.     /** 
48.      * 发送主要方法,异常捕获 
49.      * @param post 
50.      * @param code 
51.      * @return 
52.      */  
53.     public static String doHttpRequest(PostMethod post, String code) {  
54.         HttpClient httpClient = new HttpClient(httpConnectionManager);  
55.         resetRequestHeader(httpClient, "10.0.23.178");  
56.         // 设置读取超时时间(单位毫秒)  
57.         // httpClient.getParams().setParameter("http.socket.timeout",socket_timeout);  
58.         // 设置连接超时时间(单位毫秒)  
59.         // httpClient.getParams().setParameter("http.connection.timeout",connection_timeout);  
60.         // httpClient.getParams().setParameter("http.connection-manager.timeout",100000000L);  
61.         BufferedReader in = null;  
62.         String resultString = "";  
63.         try {  
64.             httpClient.executeMethod(post);  
65.             in = new BufferedReader(new InputStreamReader(post  
66.                     .getResponseBodyAsStream(), code));  
67.             StringBuffer buffer = new StringBuffer();  
68.             String line = "";  
69.             while ((line = in.readLine()) != null) {  
70.                 buffer.append(line);  
71.             }  
72.             resultString = buffer.toString();  
73.         } catch (SocketTimeoutException e) {  
74.             log.error("连接超时" + e.toString());  
75.             // throw new CustomException(  
76.             // TmallConstants.TmallExceptionType.CONNECTION_EXCEPTION,  
77.             // "连接超时:" + e.getMessage(), e);  
78.             resultString = returnError("连接超时");  
79.         } catch (HttpException e) {  
80.             log.error("读取外部服务器数据失败" + e.toString());  
81.             // throw new CustomException(  
82.             // TmallConstants.TmallExceptionType.SOCKET_EXCEPTION,  
83.             // "读取天猫服务器数据失败:" + e.getMessage(), e);  
84.             resultString = returnError("读取外部服务器数据失败");  
85.         } catch (UnknownHostException e) {  
86.             log.error("请求的主机地址无效" + e.toString());  
87.             // throw new CustomException(  
88.             // TmallConstants.TmallExceptionType.CONNECTION_EXCEPTION,  
89.             // "请求的主机地址无效：" + e.getMessage(), e);  
90.             resultString = returnError("请求的主机地址无效");  
91.         } catch (IOException e) {  
92.             log.error("向外部接口发送数据失败" + e.toString());  
93.             // throw new CustomException(  
94.             // TmallConstants.TmallExceptionType.INNER_EXCEPTION,  
95.             // "向天猫发送数据失败", e);  
96.             resultString = returnError("向外部接口发送数据失败");  
97.         } finally {  
98.             if (in != null) {  
99.                 try {  
100.                     in.close();  
101.                 } catch (IOException e) {  
102.                     e.printStackTrace();  
103.                 }  
104.             }  
105.             post.releaseConnection();  
106.         }  
107.         return resultString;  
108.     }  
109.   
110.     /** 
111.      * 设置一下返回错误的通用提示,可以自定义格式. 
112.      * @param reason 
113.      * @return 
114.      */  
115.     public static String returnError(String reason) {  
116.         StringBuffer buffer = new StringBuffer();  
117.         buffer.append("<?xml version=\"1.0\" encoding=\"GBK\"?>");  
118.         buffer.append("<Response>");  
119.         buffer.append("<Success>false</Success>");  
120.         buffer.append("<reason>");  
121.         buffer.append(reason);  
122.         buffer.append("</reason>");  
123.         buffer.append("</Response>");  
124.         return buffer.toString();  
125.     }  
126.   
127.       
128.     public final static String REQUEST_HEADER = "x-forwarded-for";  
129.     /** 
130.      * 将客户IP写入请求头 
131.      * 这个设置可以伪装IP请求,注意使用 
132.      * @param client 
133.      * @param ip 
134.      * @return 
135.      */  
136.     public static void resetRequestHeader(HttpClient client, String ip) {  
137.         List<Header> headers = new ArrayList<Header>();  
138.         headers.add(new Header(REQUEST_HEADER, ip));  
139.         client.getHostConfiguration().getParams().setParameter(  
140.                 "http.default-headers", headers);  
141.     }  
142. }  

commons-httpclient-3.1.jar

工具包,请大家到官网下载

调用webservice也有用

java.lang.ThreadLocal<>

这个类的,已空间换时间的方式,用的也不错,使用到可以去研究一下,比直接调用客户端生成要快,比动态CXF更快