java 利用httpclient 3.1 和 httpclient4.1.2发送post请求

ttpclient3和httpclient4都有连接池的概念，但两个版本的接口相差较大。

使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可。

1. 创建HttpClient对象。

2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。

3. 如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HetpParams params)方法来添加请求参数；对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)方法来设置请求参数。

4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。

5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

6. 释放连接。无论执行方法是否成功，都必须释放连接

httpclient3

MultiThreadedHttpConnectionManager 是HTTP Client中用来复用连接的连接管理类,可以通过以下方法创建一个client实例

 MultiThreadedHttpConnectionManager n =  new MultiThreadedHttpConnectionManager();
 HttpClient client = new HttpClient(n);

以下是httpclient整体类

 public class HttpClientUtils {
     /**
      * 日志处理类
      */
     private static final Log logger = LogFactory.getLog(HttpClientUtils.class);

     // 读取超时
     private final static int SOCKET_TIMEOUT = 30000;
     // 连接超时
     private final static int CONNECTION_TIMEOUT = 30000;
     // 每个HOST的最大连接数量(连接至目的主机的线程数)
     private final static int MAX_CONN_PRE_HOST = 2;
     // 连接池的最大连接数(相当于线程数)
     private final static int MAX_CONN = 2;
     // 连接池
     private final static HttpConnectionManager httpConnectionManager;

     HttpClient httpClient;

     static {
         httpConnectionManager = new MultiThreadedHttpConnectionManager();
         HttpConnectionManagerParams params = httpConnectionManager.getParams();
         params.setConnectionTimeout(CONNECTION_TIMEOUT);
         params.setSoTimeout(SOCKET_TIMEOUT);
         params.setDefaultMaxConnectionsPerHost(MAX_CONN_PRE_HOST);
         params.setMaxTotalConnections(MAX_CONN);
         httpClient = new HttpClient(httpConnectionManager);

  }

     /**
      * 发送主要方法,异常捕获
      *
      * @param post
      * @param code
      * @return
      */
     public static String doHttpPostRequest(PostMethod post) {
         String resultString = "";
         try {
             httpClient.executeMethod(post);
             if (post.getStatusCode() == HttpStatus.SC_OK) {
                 resultString = post.getResponseBodyAsString();
             }
         } catch (HttpException e) {
             logger.error("http请求超时", e);
         } catch (IOException e) {
             logger.error("IO超时", e);
         } finally {
             post.releaseConnection();
         }
         return resultString;
     }

     /**
      * 设置一下返回错误的通用提示,可以自定义格式.
      *
      * @param reason
      * @return
      */
     public static String returnError(String reason) {
         StringBuffer buffer = new StringBuffer();
         buffer.append("");
         buffer.append("");
         buffer.append("false");
         buffer.append("");
         buffer.append(reason);
         buffer.append("");
         buffer.append("");
         return buffer.toString();
     }

     public final static String REQUEST_HEADER = "x-forwarded-for";

     /**
      * 将客户IP写入请求头 这个设置可以伪装IP请求,注意使用
      *
      * @param client
      * @param ip
      * @return
      */
     public static void resetRequestHeader(HttpClient client, String ip) {
         List headers = new ArrayList();
         headers.add(new Header(REQUEST_HEADER, ip));
         client.getHostConfiguration().getParams().setParameter("http.default-headers", headers);
     }
 }

以下是测试程序

 public class HttpClientTest {

     /**
      * 组装参数,这里用Map,一键一值比较通用,可以当做共用方法
      * @param params
      * @return
      */
     private NameValuePair[] buildNameValuePairs(Map params) {
         Object[] keys = params.keySet().toArray();
         NameValuePair[] pairs = new NameValuePair[keys.length];

         for (int i = 0; i < keys.length; i++) {
             String key = (String) keys[i];
             pairs[i] = new NameValuePair(key, params.get(key));
         }

         return pairs;
     }

     /**
      * 执行一个HTTP POST请求，返回请求响应的HTML
      *
      * @param url
      *            请求的URL地址
      * @param params
      *            请求的查询参数,可以为null
      * @return 返回请求响应的string
      */
     public String doPost(String url, Map params){
         String response = "";
         if (null == url || "".equals(url.trim())) {
             return HttpClientUtil.returnError("推送地址错误[url=" + url + "]");
         }
         if (null == code || "".equals(code.trim())) {
             return HttpClientUtil.returnError("编码错误[code=" + code + "]");
         }

         if (null == params || params.size() == 0) {
             return HttpClientUtil.returnError("无传递参数[params.size = 0]");
         }
         PostMethod postMethod = new PostMethod(url);
         postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "utf-8");
         //设置失败重复提交次数
         postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(5, true));

         postMethod.setRequestBody(buildNameValuePairs(params));
         response = HttpClientUtils.doHttpPostRequest(postMethod);
         return response;
     }

     public static void main(String[] args) {
         String url = "http://localhost/serlvet";
         String xml = "xxxxxxxxxxxxxxxxxxxxxxx";
         HashMap params = new HashMap();
         params.put("aaaa", xml);
         params.put("bbbb", "bbbxxxx");
         String r = new HttpClientTest().doPost(url,params);
         System.out.println(r);

     }

 }

httpclient4.1.2

 public class HttpClientUtils2 implements Runnable{
     private static final Log logger = LogFactory.getLog(HttpClientUtils2.class);
     private static ThreadSafeClientConnManager cm = null;
     static {
         int maxTotal = 20;
         int defaultMaxConnection = 50;
         SchemeRegistry schemeRegistry = new SchemeRegistry();
         schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
         cm = new ThreadSafeClientConnManager(schemeRegistry);
         try {
             cm.setMaxTotal(maxTotal);
             // 每条通道的并发连接数设置（连接池）
             cm.setDefaultMaxPerRoute(defaultMaxConnection);
         } catch (NumberFormatException e) {
             e.printStackTrace();
         }
     }

     public static HttpClient getHttpClient() {
         HttpParams params = new BasicHttpParams();
         params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
         params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 30000); // 3000ms
         params.setParameter(CoreConnectionPNames.SO_TIMEOUT, 30000); // 3000ms
         return new DefaultHttpClient(cm, params);
     }

     public static void release() {
         if (cm != null) {
             cm.shutdown();
         }
     }

     public static void doHttpPostRequest(String url) {
         InputStream in = null;
         HttpResponse response;

         HttpClient client = getHttpClient();
         try {
             response = client.execute(post);
             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                 HttpEntity entity = response.getEntity();
                 long l = entity.getContentLength();
                 //将返回转换成string（方法1）
                 in = entity.getContent();
                 int count = 0;
                 while (count == 0) {
                     count = Integer.parseInt(""+entity.getContentLength());//in.available();
                 }
                 byte[] bytes = new byte[count];
                 int readCount = 0; // 已经成功读取的字节的个数
                 while (readCount <= count) {
                     if(readCount == count)break;
                     readCount += in.read(bytes, readCount, count - readCount);
                 }
                 //将返回转换成string（方法2）
                 //System.out.println(EntityUtils.toString(entity));
             }
             if (in != null) {
                 //关闭连接，否则连接池消耗完
                 in.close();
             }
         } catch (ClientProtocolException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

测试程序

 public class HttpClient2Test {

     /**
      * 执行一个HTTP POST请求，返回请求响应的HTML
      *
      * @param url
      *            请求的URL地址
      * @param params
      *            请求的查询参数,可以为null
      * @return 返回请求响应的string
      */
     public String doPost(String url, Map params){
         String response = "";
         HttpPost post = new HttpPost(url);
         // 设置post编码
         post.getParams().setParameter("http.protocol.content-charset", HTTP.UTF_8);
         post.getParams().setParameter(HTTP.CONTENT_ENCODING, HTTP.UTF_8);
         post.getParams().setParameter(HTTP.CHARSET_PARAM, HTTP.UTF_8);
         post.getParams().setParameter(HTTP.DEFAULT_PROTOCOL_CHARSET, HTTP.UTF_8);
         try {
             post.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
         } catch (UnsupportedEncodingException e1) {
             // TODO Auto-generated catch block
             e1.printStackTrace();
         }
         response = HttpClientUtils2.doHttpPostRequest(postMethod);
         return response;
     }

     public static void main(String[] args) {
         String url = "http://localhost/serlvet";
         String xml = "xxxxxxxxxxxxxxxxxxxxxxx";
         // 设置参数
         List params = new ArrayList();
         params.add(new BasicNameValuePair("abc", "xml"));
         String r = new HttpClientTest().doPost(url,params);
         System.out.println(r);

     }

 }