HttpClient學習整理

時間 2019-11-18

原文原文鏈接

  1 HttpClient簡介
  2 HttpClient 功能介紹
  3 1． 讀取網頁(HTTP/HTTPS)內容
  4 二、使用POST方式提交數據(httpClient3)
  5 3． 處理頁面重定向
  6 4． 模擬登陸開心網
  7 5． 提交XML格式參數
  8 6． 訪問啓用認證的頁面
  9 7． 多線程模式下使用httpclient
 10 httpClient完整封裝
 11

HttpClient簡介

HTTP 協議多是如今 Internet 上使用得最多、最重要的協議了，愈來愈多的 Java 應用程序須要直接經過 HTTP 協議來訪問網絡資源。雖然在 JDK 的 java.net 包中已經提供了訪問 HTTP 協議的基本功能，可是對於大部分應用程序來講，JDK 庫自己提供的功能還不夠豐富和靈活。HttpClient 是 Apache Jakarta Common 下的子項目，用來提供高效的、最新的、功能豐富的支持 HTTP 協議的客戶端編程工具包，而且它支持 HTTP 協議最新的版本和建議。HttpClient 已經應用在不少的項目中，好比 Apache Jakarta 上很著名的另外兩個開源項目 Cactus 和 HTMLUnit 都使用了 HttpClient。更多信息請關注http://hc.apache.org/php

HttpClient 功能介紹

如下列出的是 HttpClient 提供的主要的功能，要知道更多詳細的功能能夠參見 HttpClient 的主頁。html

實現了全部 HTTP 的方法（GET,POST,PUT,HEAD 等）java
支持自動轉向apache
支持 HTTPS 協議編程
支持代理服務器等瀏覽器

應用HttpClient來對付各類頑固的WEB服務器
轉自：http://blog.csdn.net/ambitiontan/archive/2006/01/06/572171.aspx安全

通常的狀況下咱們都是使用IE或者Navigator瀏覽器來訪問一個WEB服務器，用來瀏覽頁面查看信息或者提交一些數據等等。所訪問的這些頁面有的僅僅是一些普通的頁面，有的須要用戶登陸後方可以使用，或者須要認證以及是一些經過加密方式傳輸，例如HTTPS。目前咱們使用的瀏覽器處理這些狀況都不會構成問題。不過你可能在某些時候須要經過程序來訪問這樣的一些頁面，好比從別人的網頁中「偷」一些數據；利用某些站點提供的頁面來完成某種功能，例如說咱們想知道某個手機號碼的歸屬地而咱們本身又沒有這樣的數據，所以只好藉助其餘公司已有的網站來完成這個功能，這個時候咱們須要向網頁提交手機號碼並從返回的頁面中解析出咱們想要的數據來。若是對方僅僅是一個很簡單的頁面，那咱們的程序會很簡單，本文也就沒有必要大張旗鼓的在這裏浪費口舌。可是考慮到一些服務受權的問題，不少公司提供的頁面每每並非能夠經過一個簡單的URL就能夠訪問的，而必須通過註冊而後登陸後方可以使用提供服務的頁面，這個時候就涉及到COOKIE問題的處理。咱們知道目前流行的動態網頁技術例如ASP、JSP無不是經過COOKIE來處理會話信息的。爲了使咱們的程序能使用別人所提供的服務頁面，就要求程序首先登陸後再訪問服務頁面，這過程就須要自行處理cookie，想一想當你用java.net.HttpURLConnection來完成這些功能時是多麼恐怖的事情啊！何況這僅僅是咱們所說的頑固的WEB服務器中的一個很常見的「頑固」！再有如經過HTTP來上傳文件呢？不須要頭疼，這些問題有了「它」就很容易解決了！服務器

咱們不可能列舉全部可能的頑固，咱們會針對幾種最多見的問題進行處理。固然了，正如前面說到的，若是咱們本身使用java.net.HttpURLConnection來搞定這些問題是很恐怖的事情，所以在開始以前咱們先要介紹一下一個開放源碼的項目，這個項目就是Apache開源組織中的httpclient，它隸屬於Jakarta的commons項目，目前的版本是2.0RC2。commons下原本已經有一個net的子項目，可是又把httpclient單獨提出來，可見http服務器的訪問絕非易事。cookie

Commons-httpclient項目就是專門設計來簡化HTTP客戶端與服務器進行各類通信編程。經過它可讓原來很頭疼的事情如今輕鬆的解決，例如你再也不管是HTTP或者HTTPS的通信方式，告訴它你想使用HTTPS方式，剩下的事情交給httpclient替你完成。本文會針對咱們在編寫HTTP客戶端程序時常常碰到的幾個問題進行分別介紹如何使用httpclient來解決它們，爲了讓讀者更快的熟悉這個項目咱們最開始先給出一個簡單的例子來讀取一個網頁的內容，而後按部就班解決掉前進中的全部問題。網絡

1．讀取網頁(HTTP/HTTPS)內容

下面是咱們給出的一個簡單的例子用來訪問某個頁面

  1 /**
 2  *最簡單的HTTP客戶端,用來演示經過GET或者POST方式訪問某個頁面
 3   *@authorLiudong
 4 */
  5 public class SimpleClient {
  6 public static void main(String[] args) throws IOException
  7 {
  8   HttpClient client = new HttpClient();
  9       // 設置代理服務器地址和端口      
 10       //client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port); 
 11       // 使用 GET 方法 ，若是服務器須要經過 HTTPS 鏈接，那隻須要將下面 URL 中的 http 換成 https 
 12          HttpMethod method=new GetMethod("http://java.sun.com");
 13       //使用POST方法
 14       //HttpMethod method = new PostMethod("http://java.sun.com");
 15       client.executeMethod(method);
 16 
 17       //打印服務器返回的狀態
 18       System.out.println(method.getStatusLine());
 19       //打印返回的信息
 20       System.out.println(method.getResponseBodyAsString());
 21       //釋放鏈接
 22       method.releaseConnection();
 23    }
 24 }

在這個例子中首先建立一個HTTP客戶端(HttpClient)的實例，而後選擇提交的方法是GET或者POST，最後在HttpClient實例上執行提交的方法，最後從所選擇的提交方法中讀取服務器反饋回來的結果。這就是使用HttpClient的基本流程。其實用一行代碼也就能夠搞定整個請求的過程，很是的簡單！

二、使用POST方式提交數據(httpClient3)

httpclient使用了單獨的一個HttpMethod子類來處理文件的上傳，這個類就是MultipartPostMethod，該類已經封裝了文件上傳的細節，咱們要作的僅僅是告訴它咱們要上傳文件的全路徑便可，下面這裏將給出關於兩種模擬上傳方式的代碼

第一種：模擬上傳url文件(該方式也適合作普通post請求):

  1 /**
 2      * 上傳url文件到指定URL
 3      * @param fileUrl 上傳圖片url
 4      * @param postUrl 上傳路徑及參數,注意有些中文參數須要使用預先編碼 eg : URLEncoder.encode(appName, "UTF-8")
 5      * @return
 6      * @throws IOException
 7      */
  8     public static String doUploadFile(String postUrl) throws IOException {
  9         if(StringUtils.isEmpty(postUrl))
 10             return null;
 11         String response = "";
 12         PostMethod postMethod = new PostMethod(postUrl);
 13         try {
 14             HttpClient client = new HttpClient();
 15             client.getHttpConnectionManager().getParams()
 16                     .setConnectionTimeout(50000);// 設置鏈接時間
 17             int status = client.executeMethod(postMethod);
 18             if (status == HttpStatus.SC_OK) {
 19                 InputStream inputStream = postMethod.getResponseBodyAsStream();
 20                 BufferedReader br = new BufferedReader(new InputStreamReader(
 21                         inputStream));
 22                 StringBuffer stringBuffer = new StringBuffer();
 23                 String str = "";
 24                 while ((str = br.readLine()) != null) {
 25                     stringBuffer.append(str);
 26                 }
 27                 response = stringBuffer.toString();
 28             } else {
 29                 response = "fail";
 30             }
 31         } catch (Exception e) {
 32             e.printStackTrace();
 33         } finally {
 34             // 釋放鏈接
 35             postMethod.releaseConnection();
 36         }
 37         return response;
 38     }

第二種：模擬文件上傳到指定位置

  1 /**
 2      * 上傳文件到指定URL
 3      * @param file
 4      * @param url
 5      * @return
 6      * @throws IOException
 7      */
  8     public static String doUploadFile(File file, String url) throws IOException {
  9         String response = "";
 10         if (!file.exists()) {
 11             return "file not exists";
 12         }
 13         PostMethod postMethod = new PostMethod(url);
 14         try {
 15             //----------------------------------------------
 16             // FilePart：用來上傳文件的類,file即要上傳的文件
 17             FilePart fp = new FilePart("file", file);
 18             Part[] parts = { fp };
 19 
 20             // 對於MIME類型的請求，httpclient建議全用MulitPartRequestEntity進行包裝
 21             MultipartRequestEntity mre = new MultipartRequestEntity(parts,
 22                     postMethod.getParams());
 23             postMethod.setRequestEntity(mre);
 24             //---------------------------------------------
 25             HttpClient client = new HttpClient();
 26             client.getHttpConnectionManager().getParams()
 27                     .setConnectionTimeout(50000);// 因爲要上傳的文件可能比較大 , 所以在此設置最大的鏈接超時時間
 28             int status = client.executeMethod(postMethod);
 29             if (status == HttpStatus.SC_OK) {
 30                 InputStream inputStream = postMethod.getResponseBodyAsStream();
 31                 BufferedReader br = new BufferedReader(new InputStreamReader(
 32                         inputStream));
 33                 StringBuffer stringBuffer = new StringBuffer();
 34                 String str = "";
 35                 while ((str = br.readLine()) != null) {
 36                     stringBuffer.append(str);
 37                 }
 38                 response = stringBuffer.toString();
 39             } else {
 40                 response = "fail";
 41             }
 42         } catch (Exception e) {
 43             e.printStackTrace();
 44         } finally {
 45             // 釋放鏈接
 46             postMethod.releaseConnection();
 47         }
 48         return response;
 49     }

3．處理頁面重定向

在JSP/Servlet編程中response.sendRedirect方法就是使用HTTP協議中的重定向機制。它與JSP中的<jsp:forward …>的區別在於後者是在服務器中實現頁面的跳轉，也就是說應用容器加載了所要跳轉的頁面的內容並返回給客戶端；而前者是返回一個狀態碼，這些狀態碼的可能值見下表，而後客戶端讀取須要跳轉到的頁面的URL並從新加載新的頁面。就是這樣一個過程，因此咱們編程的時候就要經過HttpMethod.getStatusCode()方法判斷返回值是否爲下表中的某個值來判斷是否須要跳轉。若是已經確認須要進行頁面跳轉了，那麼能夠經過讀取HTTP頭中的location屬性來獲取新的地址。

下面的代碼片斷演示如何處理頁面的重定向

  1 client.executeMethod(post);
  2 System.out.println(post.getStatusLine().toString());
  3 post.releaseConnection();
  4 // 檢查是否重定向
  5 int statuscode = post.getStatusCode();
  6 if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||
  7 (statuscode ==HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
  8 // 讀取新的 URL 地址 
  9    Header header=post.getResponseHeader("location");
 10    if (header!=null){
 11       Stringnewuri=header.getValue();
 12       if((newuri==null)||(newuri.equals("")))
 13          newuri="/";
 14          GetMethodredirect=newGetMethod(newuri);
 15          client.executeMethod(redirect);
 16          System.out.println("Redirect:"+redirect.getStatusLine().toString());
 17          redirect.releaseConnection();
 18    }else
 19     System.out.println("Invalid redirect");
 20 }

咱們能夠自行編寫兩個JSP頁面，其中一個頁面用response.sendRedirect方法重定向到另一個頁面用來測試上面的例子。

4．模擬登陸開心網

本小節應該說是HTTP客戶端編程中最常遇見的問題，不少網站的內容都只是對註冊用戶可見的，這種狀況下就必需要求使用正確的用戶名和口令登陸成功後，方可瀏覽到想要的頁面。由於HTTP協議是無狀態的，也就是鏈接的有效期只限於當前請求，請求內容結束後鏈接就關閉了。在這種狀況下爲了保存用戶的登陸信息必須使用到Cookie機制。以JSP/Servlet爲例，當瀏覽器請求一個JSP或者是Servlet的頁面時，應用服務器會返回一個參數，名爲jsessionid（因不一樣應用服務器而異），值是一個較長的惟一字符串的Cookie，這個字符串值也就是當前訪問該站點的會話標識。瀏覽器在每訪問該站點的其餘頁面時候都要帶上jsessionid這樣的Cookie信息，應用服務器根據讀取這個會話標識來獲取對應的會話信息。

對於須要用戶登陸的網站，通常在用戶登陸成功後會將用戶資料保存在服務器的會話中，這樣當訪問到其餘的頁面時候，應用服務器根據瀏覽器送上的Cookie中讀取當前請求對應的會話標識以得到對應的會話信息，而後就能夠判斷用戶資料是否存在於會話信息中，若是存在則容許訪問頁面，不然跳轉到登陸頁面中要求用戶輸入賬號和口令進行登陸。這就是通常使用JSP開發網站在處理用戶登陸的比較通用的方法。

這樣一來，對於HTTP的客戶端來說，若是要訪問一個受保護的頁面時就必須模擬瀏覽器所作的工做，首先就是請求登陸頁面，而後讀取Cookie值；再次請求登陸頁面並加入登陸頁所需的每一個參數；最後就是請求最終所需的頁面。固然在除第一次請求外其餘的請求都須要附帶上Cookie信息以便服務器能判斷當前請求是否已經經過驗證。說了這麼多，但是若是你使用httpclient的話，你甚至連一行代碼都無需增長，你只須要先傳遞登陸信息執行登陸過程，而後直接訪問想要的頁面，跟訪問一個普通的頁面沒有任何區別，由於類HttpClient已經幫你作了全部該作的事情了，太棒了！下面的例子實現了模擬登錄開心網並向本身好友發送消息的功能。

  1 import java.io.BufferedReader;
  2 import java.io.IOException;
  3 import java.io.InputStream;
  4 import java.io.InputStreamReader;
  5 
  6 import org.apache.commons.httpclient.Cookie;
  7 import org.apache.commons.httpclient.Header;
  8 import org.apache.commons.httpclient.HttpClient;
  9 import org.apache.commons.httpclient.HttpStatus;
 10 import org.apache.commons.httpclient.NameValuePair;
 11 import org.apache.commons.httpclient.cookie.CookiePolicy;
 12 import org.apache.commons.httpclient.methods.GetMethod;
 13 import org.apache.commons.httpclient.methods.PostMethod;
 14 import org.apache.commons.httpclient.params.HttpClientParams;
 15 import org.apache.commons.httpclient.params.HttpMethodParams;
 16 
 17 class Login {
 18     public static String loginurl = "https://security.kaixin001.com/login/login_post.php";
 19     static Cookie[] cookies = {};
 20 
 21     static HttpClient httpClient = new HttpClient();
 22 
 23     static String email = "xxx@qq.com";//你的email
 24     static String psw = "xxx";//你的密碼
 25     // 消息發送的action
 26     String url = "http://www.kaixin001.com/home/";
 27 
 28     public static void getUrlContent()
 29             throws Exception {
 30 
 31         HttpClientParams httparams = new HttpClientParams();
 32         httparams.setSoTimeout(30000);
 33         httpClient.setParams(httparams);
 34 
 35         httpClient.getHostConfiguration().setHost("www.kaixin001.com", 80);
 36 
 37         httpClient.getParams().setParameter(
 38                 HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
 39 
 40         PostMethod login = new PostMethod(loginurl);
 41         login.addRequestHeader("Content-Type",
 42                 "application/x-www-form-urlencoded; charset=UTF-8");
 43 
 44         NameValuePair Email = new NameValuePair("loginemail", email);// 郵箱
 45         NameValuePair password = new NameValuePair("password", psw);// 密碼
 46         // NameValuePair code = new NameValuePair( "code"
 47         // ,"????");//有時候須要驗證碼，暫時未解決
 48 
 49         NameValuePair[] data = { Email, password };
 50         login.setRequestBody(data);
 51 
 52         httpClient.executeMethod(login);
 53         int statuscode = login.getStatusCode();
 54         System.out.println(statuscode + "-----------");
 55         String result = login.getResponseBodyAsString();
 56         System.out.println(result+"++++++++++++");
 57 
 58         cookies = httpClient.getState().getCookies();
 59         System.out.println("==========Cookies============");
 60         int i = 0;
 61         for (Cookie c : cookies) {
 62             System.out.println(++i + ":   " + c);
 63         }
 64         httpClient.getState().addCookies(cookies);
 65 
 66         // 當state爲301或者302說明登錄頁面跳轉了，登錄成功了
 67         if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY)
 68                 || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)
 69                 || (statuscode == HttpStatus.SC_SEE_OTHER)
 70                 || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
 71             // 讀取新的 URL 地址
 72             Header header = login.getResponseHeader("location");
 73             // 釋放鏈接
 74             login.releaseConnection();
 75             System.out.println("獲取到跳轉header>>>" + header);
 76             if (header != null) {
 77                 String newuri = header.getValue();
 78                 if ((newuri == null) || (newuri.equals("")))
 79                     newuri = "/";
 80                 GetMethod redirect = new GetMethod(newuri);
 81                 // ////////////
 82                 redirect.setRequestHeader("Cookie", cookies.toString());
 83                 httpClient.executeMethod(redirect);
 84                 System.out.println("Redirect:"
 85                         + redirect.getStatusLine().toString());
 86                 redirect.releaseConnection();
 87 
 88             } else
 89                 System.out.println("Invalid redirect");
 90         } else {
 91             // 用戶名和密碼沒有被提交，當登錄屢次後須要驗證碼的時候會出現這種未提交狀況
 92             System.out.println("用戶沒登錄");
 93             System.exit(1);
 94         }
 95 
 96     }
 97 
 98     public static void sendMsg() throws Exception {
 99         // 登陸後發消息
100         System.out.println("*************發消息***********");
101 
102         String posturl = "http://www.kaixin001.com/msg/post.php";
103         PostMethod poster = new PostMethod(posturl);
104 
105         poster.addRequestHeader("Content-Type",
106                 "application/x-www-form-urlencoded; charset=UTF-8");
107         poster.setRequestHeader("Cookie", cookies.toString());
108 
109         NameValuePair uids = new NameValuePair("uids", "89600585");// 發送的好友對象的id,此處換成你的好友id
110         NameValuePair content = new NameValuePair("content", "你好啊!");// 須要發送的信息的內容
111         NameValuePair liteeditor_0 = new NameValuePair("liteeditor_0", "你好啊!");// 須要發送的信息的內容
112         NameValuePair texttype = new NameValuePair("texttype", "plain");
113         NameValuePair send_separate = new NameValuePair("send_separate", "0");
114         NameValuePair service = new NameValuePair("service", "0");
115         NameValuePair[] msg = { uids, content, texttype, send_separate, service,liteeditor_0 };
116 
117         poster.setRequestBody(msg);
118         httpClient.executeMethod(poster);
119 
120         String result = poster.getResponseBodyAsString();
121         System.out.println(result+"++++++++++++");
122         //System.out.println(StreamOut(result, "iso8859-1"));
123         int statuscode = poster.getStatusCode();
124         System.out.println(statuscode + "-----------");
125         if(statuscode == 301 || statuscode == 302){
126             // 讀取新的 URL 地址
127             Header header = poster.getResponseHeader("location");
128             System.out.println("獲取到跳轉header>>>" + header);
129             if (header != null) {
130                 String newuri = header.getValue();
131                 if ((newuri == null) || (newuri.equals("")))
132                     newuri = "/";
133                 GetMethod redirect = new GetMethod(newuri);
134                 // ////////////
135                 redirect.setRequestHeader("Cookie", cookies.toString());
136                 httpClient.executeMethod(redirect);
137                 System.out.println("Redirect:"
138                         + redirect.getStatusLine().toString());
139                 redirect.releaseConnection();
140 
141             } else
142                 System.out.println("Invalid redirect");
143         }
144 
145             poster.releaseConnection();
146     }
147 
148     public static String StreamOut(InputStream txtis, String code)
149             throws IOException {
150         BufferedReader br = new BufferedReader(new InputStreamReader(txtis,
151                 code));
152         String tempbf;
153         StringBuffer html = new StringBuffer(100);
154         while ((tempbf = br.readLine()) != null) {
155             html.append(tempbf + "\n");
156         }
157         return html.toString();
158 
159     }
160 }

5．提交XML格式參數

提交XML格式的參數很簡單，僅僅是一個提交時候的ContentType問題，下面的例子演示從文件文件中讀取XML信息並提交給服務器的過程，該過程能夠用來測試Web服務。

  1 import java.io.File;
  2 import java.io.FileInputStream;
  3 import org.apache.commons.httpclient.HttpClient;
  4 import org.apache.commons.httpclient.methods.EntityEnclosingMethod;
  5 import org.apache.commons.httpclient.methods.PostMethod;
  6 /**
 7  *用來演示提交XML格式數據的例子
 8 */
  9 public class PostXMLClient {
 10 
 11    public static void main(String[] args) throws Exception {
 12       File input = new File(「test.xml」);
 13       PostMethod post = new PostMethod(「http://localhost:8080/httpclient/xml.jsp」);
 14 
 15       // 設置請求的內容直接從文件中讀取
 16       post.setRequestBody( new FileInputStream(input));
 17       if (input.length() < Integer.MAX_VALUE)
 18          post.setRequestContentLength(input.length());
 19       else
 20          post.setRequestContentLength(EntityEnclosingMethod.CONTENT_LENGTH_CHUNKED);
 21 
 22       // 指定請求內容的類型
 23       post.setRequestHeader( "Content-type" , "text/xml; charset=GBK" );
 24       HttpClient httpclient = new HttpClient();
 25       int result = httpclient.executeMethod(post);
 26       System.out.println( "Response status code: " + result);
 27       System.out.println( "Response body: " );
 28       System.out.println(post.getResponseBodyAsString());
 29       post.releaseConnection();
 30    }
 31 }

6．訪問啓用認證的頁面

咱們常常會碰到這樣的頁面，當訪問它的時候會彈出一個瀏覽器的對話框要求輸入用戶名和密碼後方可，這種用戶認證的方式不一樣於咱們在前面介紹的基於表單的用戶身份驗證。這是HTTP的認證策略，httpclient支持三種認證方式包括：基本、摘要以及NTLM認證。其中基本認證最簡單、通用但也最不安全；摘要認證是在HTTP 1.1中加入的認證方式，而NTLM則是微軟公司定義的而不是通用的規範，最新版本的NTLM是比摘要認證還要安全的一種方式。

下面例子是從httpclient的CVS服務器中下載的，它簡單演示如何訪問一個認證保護的頁面：

  1 import org.apache.commons.httpclient.HttpClient;
  2 import org.apache.commons.httpclient.UsernamePasswordCredentials;
  3 import org.apache.commons.httpclient.methods.GetMethod;
  4 
  5 public class BasicAuthenticationExample {
  6 
  7    public BasicAuthenticationExample() {
  8    }
  9 
 10    public static void main(String[] args) throws Exception {
 11       HttpClient client = new HttpClient();
 12       client.getState().setCredentials( "www.verisign.com" , "realm" , new UsernamePasswordCredentials( "username" , "password" ) );
 13 
 14       GetMethod get = new GetMethod( "https://www.verisign.com/products/index.html" );
 15       get.setDoAuthentication( true );
 16       int status = client.executeMethod( get );
 17       System.out.println(status+ "\n" + get.getResponseBodyAsString());
 18       get.releaseConnection();
 19    }
 20 }

7．多線程模式下使用

多線程同時訪問httpclient，例如同時從一個站點上下載多個文件。對於同一個HttpConnection同一個時間只能有一個線程訪問，爲了保證多線程工做環境下不產生衝突，httpclient使用了一個多線程鏈接管理器的類：MultiThreadedHttpConnectionManager，要使用這個類很簡單，只須要在構造HttpClient實例的時候傳入便可，代碼以下：

MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();

HttpClient client = new HttpClient(connectionManager);

之後儘管訪問client實例便可。

httpClient完整封裝

HttpInvoke.java:封裝了HttpClient調度的必要參數設置,以及post,get等經常使用方法

  1 import org.apache.commons.logging.Log;
  2 import org.apache.commons.logging.LogFactory;
  3 import org.apache.commons.httpclient.*;
  4 import org.apache.commons.httpclient.auth.AuthScope;
  5 import org.apache.commons.httpclient.methods.PostMethod;
  6 import org.apache.commons.httpclient.methods.GetMethod;
  7 
  8 import java.util.Iterator;
  9 import java.util.Map;
 10 import java.net.SocketTimeoutException;
 11 import java.io.BufferedReader;
 12 import java.io.InputStreamReader;
 13 
 14 public class HttpInvoker {
 15     private Log logger = LogFactory.getLog(HttpInvoker.class);
 16     private static HttpInvoker httpInvoker = new HttpInvoker();
 17     private HttpClient client = null;
 18     private String charset = "gbk";
 19     private int timeout = 10000;
 20     private boolean useProxy = false;
 21     private String proxyHost = null;
 22     private int proxyPort;
 23     private String proxyUsername = null;
 24     private String proxyPassword = null;
 25     private boolean initialized = false;
 26 
 27     public static HttpInvoker getInstance() {
 28         return httpInvoker;
 29     }
 30 
 31     private HttpInvoker() {
 32         client = new HttpClient(new MultiThreadedHttpConnectionManager());
 33         client.getParams().setParameter("http.protocol.content-charset", "gbk");
 34         client.getParams().setContentCharset("gbk");
 35         client.getParams().setSoTimeout(timeout);
 36     }
 37 
 38     public HttpInvoker(String charset, int timeout, boolean useProxy,
 39                        String proxyHost, int proxyPort, String proxyUsername,
 40                        String proxyPassword) {
 41         client = new HttpClient(new MultiThreadedHttpConnectionManager());
 42         if(charset != null && !charset.trim().equals("")) {
 43             this.charset = charset;
 44         }
 45         if(timeout > 0) {
 46             this.timeout = timeout;
 47         }
 48         client.getParams().setParameter("http.protocol.content-charset", charset);
 49         client.getParams().setContentCharset(charset);
 50         client.getParams().setSoTimeout(timeout);
 51         if(useProxy && proxyHost != null &&
 52                 !proxyHost.trim().equals("") && proxyPort > 0) {
 53             HostConfiguration hc = new HostConfiguration();
 54             hc.setProxy(proxyHost, proxyPort);
 55             client.setHostConfiguration(hc);
 56             if (proxyUsername != null && !proxyUsername.trim().equals("") &&
 57                     proxyPassword != null && !proxyPassword.trim().equals("")) {
 58                 client.getState().setProxyCredentials(AuthScope.ANY,
 59                     new UsernamePasswordCredentials(proxyUsername, proxyPassword));
 60             }
 61         }
 62         initialized = true;
 63         logger.debug("HttpInvoker初始化完成");
 64     }
 65 
 66     public synchronized void init() {
 67         if(charset != null && !charset.trim().equals("")) {
 68             client.getParams().setParameter("http.protocol.content-charset", charset);
 69             client.getParams().setContentCharset(charset);
 70         }
 71         if(timeout > 0) {
 72             client.getParams().setSoTimeout(timeout);
 73         }
 74         if(useProxy && proxyHost != null &&
 75                 !proxyHost.trim().equals("") && proxyPort > 0) {
 76             HostConfiguration hc = new HostConfiguration();
 77             hc.setProxy(proxyHost, proxyPort);
 78             client.setHostConfiguration(hc);
 79             if (proxyUsername != null && !proxyUsername.trim().equals("") &&
 80                     proxyPassword != null && !proxyPassword.trim().equals("")) {
 81                 client.getState().setProxyCredentials(AuthScope.ANY,
 82                     new UsernamePasswordCredentials(proxyUsername, proxyPassword));
 83             }
 84         }
 85         initialized = true;
 86         logger.debug("HttpInvoker初始化完成");
 87     }
 88 
 89     public String invoke(String url) throws Exception {
 90         return invoke(url, null, false);
 91     }
 92 
 93     public String invoke(String url, Map params, boolean isPost) throws Exception {
 94         logger.debug("HTTP調用[" + (isPost?"POST":"GET") + "][" + url + "][" + params + "]");
 95         HttpMethod httpMethod = null;
 96         String result = "";
 97         try {
 98             if(isPost && params != null && params.size() > 0) {
 99                 Iterator paramKeys = params.keySet().iterator();
100                 httpMethod = new PostMethod(url);
101                 NameValuePair[] form = new NameValuePair[params.size()];
102                 int formIndex = 0;
103                 while(paramKeys.hasNext()) {
104                     String key = (String)paramKeys.next();
105                     Object value = params.get(key);
106                     if(value != null && value instanceof String && !value.equals("")) {
107                         form[formIndex] = new NameValuePair(key, (String)value);
108                         formIndex++;
109                     } else if(value != null && value instanceof String[] &&
110                             ((String[])value).length > 0) {
111                         NameValuePair[] tempForm =
112                                 new NameValuePair[form.length + ((String[])value).length - 1];
113                         for(int i=0; i<formIndex; i++) {
114                             tempForm[i] = form[i];
115                         }
116                         form = tempForm;
117                         for(String v : (String[])value) {
118                             form[formIndex] = new NameValuePair(key, (String)v);
119                             formIndex++;
120                         }
121                     }
122                 }
123                 ((PostMethod)httpMethod).setRequestBody(form);
124             } else {
125                 if(params != null && params.size() > 0) {
126                     Iterator paramKeys = params.keySet().iterator();
127                     StringBuffer getUrl = new StringBuffer(url.trim());
128                     if(url.trim().indexOf("?") > -1) {
129                         if(url.trim().indexOf("?") < url.trim().length()-1 &&
130                                 url.trim().indexOf("&")  < url.trim().length()-1) {
131                             getUrl.append("&");
132                         }
133                     } else {
134                         getUrl.append("?");
135                     }
136                     while(paramKeys.hasNext()) {
137                         String key = (String)paramKeys.next();
138                         Object value = params.get(key);
139                         if(value != null && value instanceof String && !value.equals("")) {
140                             getUrl.append(key).append("=").append(value).append("&");
141                         } else if(value != null && value instanceof String[] &&
142                                 ((String[])value).length > 0) {
143                             for(String v : (String[])value) {
144                                 getUrl.append(key).append("=").append(v).append("&");
145                             }
146                         }
147                     }
148                     if(getUrl.lastIndexOf("&") == getUrl.length()-1) {
149                         httpMethod = new GetMethod(getUrl.substring(0, getUrl.length()-1));
150                     } else {
151                         httpMethod = new GetMethod(getUrl.toString());
152                     }
153                 } else {
154                     httpMethod = new GetMethod(url);
155                 }
156             }
157             client.executeMethod(httpMethod);
158 //            result = httpMethod.getResponseBodyAsString();
159             BufferedReader reader = new BufferedReader(new InputStreamReader(
160                     httpMethod.getResponseBodyAsStream(),"ISO-8859-1"));
161             String line = null;
162             String html = null;
163             while((line = reader.readLine()) != null){
164                 if(html == null) {
165                     html = "";
166                 } else {
167                     html += "\r\n";
168                 }
169                 html += line;
170             }
171             if(html != null) {
172                 result = new String(html.getBytes("ISO-8859-1"), charset);
173             }
174         } catch (SocketTimeoutException e) {
175             logger.error("鏈接超時[" + url + "]");
176             throw e;
177         } catch (java.net.ConnectException e) {
178             logger.error("鏈接失敗[" + url + "]");
179             throw e;
180         } catch (Exception e) {
181             logger.error("鏈接時出現異常[" + url + "]");
182             throw e;
183         } finally {
184             if (httpMethod != null) {
185                 try {
186                     httpMethod.releaseConnection();
187                 } catch (Exception e) {
188                     logger.error("釋放網絡鏈接失敗[" + url + "]");
189                     throw e;
190                 }
191             }
192         }
193 
194         return result;
195     }
196 
197     public void setCharset(String charset) {
198         this.charset = charset;
199     }
200 
201     public void setTimeout(int timeout) {
202         this.timeout = timeout;
203     }
204 
205     public void setProxyHost(String proxyHost) {
206         this.proxyHost = proxyHost;
207     }
208 
209     public void setProxyPort(int proxyPort) {
210         this.proxyPort = proxyPort;
211     }
212 
213     public void setProxyUsername(String proxyUsername) {
214         this.proxyUsername = proxyUsername;
215     }
216 
217     public void setProxyPassword(String proxyPassword) {
218         this.proxyPassword = proxyPassword;
219     }
220 
221     public void setUseProxy(boolean useProxy) {
222         this.useProxy = useProxy;
223     }
224 
225     public synchronized boolean isInitialized() {
226         return initialized;
227     }
228 }

http訪問網絡的代理ip和端口，還有使用用戶及密碼均可以在Spring容器中注入進來:

  1 <bean id="httpInvoker" class="HttpInvoker">
  2         <constructor-arg type="java.lang.String" value="gbk" /><!--useProxy-->
  3         <constructor-arg type="int" value="10000" /><!--useProxy-->
  4         <constructor-arg type="boolean" value="true" /><!--useProxy-->
  5         <!--代理地址 -->
  6         <constructor-arg type="java.lang.String" value="192.168.1.1" />
  7         <constructor-arg type="int" value="8080" />
  8         <constructor-arg type="java.lang.String" value="" /><!--用戶名-->
  9         <constructor-arg type="java.lang.String" value="" /><!--密碼-->
 10 </bean>

使用方式：post

Map<String,String> params = new HashMap<String,String>();
params.put("check", check);
String result = httpInvoker.invoke( "someURL", params, true);

使用方式：get

String content  = httpInvoker.invoke(url);

參考資料：

httpclient首頁： http://jakarta.apache.org/commons/httpclient/
關於NTLM是如何工做： http://davenport.sourceforge.net/ntlm.html
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
HttpClient入門
http://blog.csdn.net/ambitiontan/archive/2006/01/07/572644.aspx
Jakarta Commons HttpClient 學習筆記
http://blog.csdn.net/cxl34/archive/2005/01/19/259051.aspx
Cookies,SSL，httpclient的多線程處理，HTTP方法
http://blog.csdn.net/bjbs_270/archive/2004/11/05/168233.aspx

HttpClient 學習整理

內容來自：cnblogs：牛奶、不加糖

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。