前提：

1、Restful風格的WS服務端：Web Service筆記（五）：CXF開發RESTful風格的Web Service

2、訪問客戶端的技術太多了，這邊總結下本人使用過的，主要是四種：WebClient 、HttpURLConnection、HttpClient 和RestTemplate

3、服務端程式碼實現為 Web Service筆記（五）：CXF開發RESTful風格的Web Service 中的sendXml()方法，訪問地址與客戶端傳輸的xml檔案分別為：
[java] view plain copy

// 傳送的報文  
String mRequestXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><USER><AGE>27</AGE><NAME>SAM-SHO</NAME><PhoneList><UserPhone><num>13612345678</num><type>移動</type></UserPhone><UserPhone><num>13798765432</num><type>聯通</type></UserPhone></PhoneList><UserAddress><homeAddress>蘇州高新區</homeAddress><workAddress>蘇州園區</workAddress></UserAddress></USER>";  

// 服務端地址  
String mUrl = "http://localhost:8080/Java_WS_Server/rest/surpolicy/sendXml";  
 

一、WebClient

（一）WebClient 客戶端

1、WebClient 是CXF自帶的客戶端實現，比較簡單實用。

2、客戶端程式碼如下：

[java] view plain copy

/** 
 * WebClient 的客戶端訪問 
 */  
private void WebClientVisit() {  
    // 手動建立webClient物件，注意這裡的地址是釋出的那個/rest地址  
    // String url = "http://localhost:8080/Java_WS_Server/rest/";  
    // WebClient client = WebClient.create(url);  

    // 從Spring Ioc容器中拿webClient物件，或者直接用注入  
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-client.xml");  
    WebClient client = ctx.getBean("webClient", WebClient.class);  

    // 設定超時  
    ClientConfiguration config = WebClient.getConfig(client);  
    config.getHttpConduit().getClient().setReceiveTimeout(90000);  

    String tResponseMsg = client.path("surpolicy/sendXml").accept(MediaType.APPLICATION_XML).post(mRequestXml, String.class);  
    System.out.println("返回的資訊： \r\n" + tResponseMsg);  

}  
 

（二）WebClient 詳解

1、WebClient.create(String url)：訪問地址。

2、path(String url，Object parames)：地址 和 引數 。

3、accept(String… types)：接收的型別。

4、get/post(Object body, Class responseClass)：傳送的內容 和 返回的型別。

5、設定超時（固定用法）:

[java] view plain copy

ClientConfiguration config = WebClient.getConfig(client);  
config.getHttpConduit().getClient().setReceiveTimeout(90000);//設定超時  
 

（三）WebClient 工具類封裝

[java] view plain copy

package cn.rest.util;  

import java.io.IOException;  
import java.io.StringWriter;  
import java.util.ArrayList;  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  

import javax.ws.rs.core.Response;  

import org.apache.cxf.jaxrs.client.ClientConfiguration;  
import org.apache.cxf.jaxrs.client.WebClient;  
import org.apache.cxf.jaxrs.ext.form.Form;  
import org.apache.http.HttpResponse;  
import org.apache.http.ParseException;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.log4j.Logger;  

import freemarker.cache.StringTemplateLoader;  
import freemarker.template.Configuration;  
import freemarker.template.Template;  
import freemarker.template.TemplateException;  

/** 
 *  
 *<p>Description : 客戶端傳送請求共通方法</p> 
 *<p>Date        : May 3, 2013</p> 
 *<p>Remark      : </p> 
 * @version 
 */  
public class HttpClient {  

    private static Logger logger  = Logger.getLogger(HttpClient.class);  

    public final static String ESB_REQUEST_ID = "TP-REQUEST-ID";  
    public final static String ESB_SERVICE_ID = "TP-SERVICE-ID";  
    public final static String ESB_APP_ID = "TP-APP-ID";  
    public final static String ESB_ACCESS_TOKEN = "TP-ACCESS-TOKEN";  
    public final static String ESB_REQUEST_TIME = "TP-REQUEST-TIME";  
    public final static String ESB_REQUEST_HASH = "TP-REQUEST-HASH";  
    public final static String ESB_REQUEST_EXT = "TP-REQUEST-EXT";  

    private static final String ENCODING = "UTF-8";  

    /** 
     * json 
     */  
    private static final String APPLICATION_JSON = "application/json";  

    /** 
     * xml 
     */  
    private static final String APPLICATION_XML = "text/xml";  
    /** 
     * form 
     */  
    private static final String APPLICATION_FORM = "application/x-www-form-urlencoded";  

    private static final long defaultReciveTimeout = 60000;  
    private static long reciveTimeout;  

    /** 
     * 設定HttpClient超時時間 
     *  
     * 注意：因為是靜態變數所以修改此處，會影響整個應用程式的超時。 
     *       如果不想影響到其他處呼叫的超時，在每次呼叫請求方法後， 
     *       需要再次呼叫 setDefaultTimeout()，恢復成預設設定。 
     *  
     * @param timeout 
     */  
    public static void setReciveTimeout(long timeout) {  
        reciveTimeout = timeout;  
    }  

    public static void setDefaultTimeout() {  
        reciveTimeout = defaultReciveTimeout;  
        System.out.println("HttpClient default reciveTimeout is: " + reciveTimeout);  
    }  

    private static WebClient createClient(String url, List<Object> providers) {  
        WebClient client;  
        if (providers != null && providers.size() > 0) {  
            client = WebClient.create(url, providers);  
        } else {  
            client = WebClient.create(url);  
        }  
        ClientConfiguration config = WebClient.getConfig(client);  
        config.getHttpConduit().getClient().setReceiveTimeout(reciveTimeout);  
        return client;  
    }  

    private static WebClient createClient(String url) {  
        return createClient(url, null);  
    }  

    /** 
     * post Json 
     *  
     * @param url 
     *            請求地址 
     * @param o 
     *            POJO物件 
     * @return 返回伺服器響應 
     * @throws TpException 
     *           
     */  
    public static Object postJson(String url, Object o) {  
        List<Object> providers = new ArrayList<Object>();  
        // 配置json轉換器  
        providers.add(new org.codehaus.jackson.jaxrs.JacksonJsonProvider());  
        // 建立Webclient物件  
        WebClient client = createClient(url, providers);  
        // 傳送請求，伺服器返回響應  
        Object res = client.accept(APPLICATION_JSON).type(APPLICATION_JSON)  
                .post(o, o.getClass());  
        return res;  
    }  

    /** 
     * post Xml 
     *  
     * @param url 
     *            請求地址 
     * @param o 
     *            POJO物件 
     * @return 返回伺服器響應 
     */  
    public static Response postXML(String url, Object o) {  
        // 建立建立Web client物件  
        WebClient client = createClient(url);         
        // 傳送請求，伺服器返回響應  
        Response res = client.accept(APPLICATION_XML).type(APPLICATION_XML)  
                .post(o);  
        return res;  
    }  

    /** 
     * post Xml with additional headers 
     *  
     * @param url 
     *            請求地址 
     * @param o 
     *            POJO物件 
     * @return 返回伺服器響應 
     */  
    public static Response postXML(String url, Object o, Map<String, String> addHeaders) {  
        // 建立建立Web client物件  
        WebClient client = createClient(url);  
        addHeaders(client, addHeaders);  
        // 傳送請求，伺服器返回響應  
        Response res = client.accept(APPLICATION_XML).type(APPLICATION_XML)  
                .post(o);  
        return res;  
    }  

    /** 
     * post object to xml 
     *  
     * @param url 
     *            請求地址 
     * @param o 
     *            POJO物件 
     * @return 返回伺服器響應 
     */  
    public static Object postXML(String url, Object o, Class<?> clazz){  
        // 建立建立Web client物件  
        WebClient client = createClient(url);  
        // 傳送請求，伺服器返回響應  
        Object res = client.accept(APPLICATION_XML).type(APPLICATION_XML)  
                .post(o, clazz);  
        return res;  
    }  

    public static Object postXML(String url, Object o, Class<?> clazz, Map<String, String> addHeaders){  
        // 建立建立Web client物件  
        WebClient client = createClient(url);  
        addHeaders(client, addHeaders);  
        // 傳送請求，伺服器返回響應  
        Object res = client.accept(APPLICATION_XML).type(APPLICATION_XML)  
                .post(o, clazz);  
        return res;  
    }  

    /** 
     * get xml 
     * @param url 
     *            請求地址 
     * @param o 
     *            POJO物件 
     * @return 返回伺服器響應 
     */  
    public static Object getXML(String url, Object o) {  
        // 建立建立Web client物件  
        WebClient client = createClient(url);  
        // 傳送請求，伺服器返回響應  
        Object obj = client.accept(APPLICATION_XML).type(APPLICATION_XML)  
                .get(o.getClass());  
        return obj;  
    }  

    public static Object getXML(String url, Object o, Map<String, String> addHeaders) {  
        // 建立建立Web client物件  
        WebClient client = createClient(url);  
        addHeaders(client, addHeaders);  
        // 傳送請求，伺服器返回響應  
        Object obj = client.accept(APPLICATION_XML).type(APPLICATION_XML)  
                .get(o.getClass());  
        return obj;  
    }  

    /** 
     * get json 
     *  
     * @param url 
     *            請求地址 
     * @param o 
     *            POJO物件 
     * @return 返回伺服器響應 
     */  
    public static Object getJson(String url, Object o) {  
        // 建立建立Web client物件  
        WebClient client = createClient(url);  
        // 傳送請求，伺服器返回響應  
        Object obj = client.accept(APPLICATION_JSON).type(APPLICATION_JSON)  
                .get(o.getClass());  
        return obj;  
    }  

    public static Object getJson(String url, Object o, Map<String, String> addHeaders) {  
        // 建立建立Web client物件  
        WebClient client = createClient(url);  
        addHeaders(client, addHeaders);  
        // 傳送請求，伺服器返回響應  
        Object obj = client.accept(APPLICATION_JSON).type(APPLICATION_JSON)  
                .get(o.getClass());  
        return obj;  
    }  

    /** 
     * post XML過載，返回Response資訊 
     *  
     * @param url 
     *            請求地址 
     * @param o 
     *            實體類物件 
     * @param xmlStr 
     *            xml字串 
     * @return 返回伺服器響應資訊 
     * @throws IOException 
     *            異常 
     * @throws TemplateException 
     *            異常 
     */  
    public static Response postXML(String url, Object o, String xmlStr){  
        String toPostXML = writeXML(o, xmlStr);  
        // 建立建立Web client物件  
        WebClient client = createClient(url);  
        // 傳送請求,返回響應資訊  
        Response res = client.post(toPostXML);  
        return res;  
    }  

    public static Response postFormRequest(String url, Map<String, String> formValues, Map<String, String> addHeaders) {  
        WebClient client = createClient(url);  
        Form form = new Form();  
        addHeaders(client, addHeaders);  
        Set<String> keys = formValues.keySet();  
        for(String key : keys) {  
            form.set(key, formValues.get(key));  
        }  
        return client.form(form);  
    }  

    /** 
     * POST FORM表單 
     * @param <T> 返回型別(String.class, xxx.class等) 
     * @param url 請求url 
     * @param formValues 表單資料(Map) 
     * @param addHeaders 表頭資料(Map) 
     * @param clazz 返回型別(String.class, xxx.class等) 
     * @return 返回指定型別的物件 
     */  
    public static <T> T postForm(String url, Map<String, String> formValues, Map<String, String> addHeaders, Class clazz) {  
        Response res = postFormRequest(url, formValues, addHeaders);  
        return (T)res.readEntity(clazz);  
    }  

    /** 
     * POST FORM表單 
     * @param <T> 
     * @param url 請求url 
     * @param formValues 表單資料(Map) 
     * @param clazz 返回型別(String.class, xxx.class等) 
     * @return 
     */  
    public static <T> T postForm(String url, Map<String, String> formValues, Class clazz) {  
        Response res = postFormRequest(url, formValues, null);  
        return (T)res.readEntity(clazz);  
    }  

    private static void addHeaders(WebClient client, Map<String, String> addHeaders) {  
        if (addHeaders != null) {  
            Set<String> keys = addHeaders.keySet();  
            for(String key : keys) {  
                client.header(key, addHeaders.get(key));  
            }  
        }  
    }  


    /** 
     * 伺服器請求 
     *  
     * @param url 
     *         請求路徑 
     * @param posMap 
     *           map物件 
     * @return 伺服器響應資訊 
     * @throws Exception  
     * @throws ParseException  
     */  
    public static HttpResponse postXMl(String url,Map<String,String> posMap) throws ParseException, Exception{  
        // 建立HttpClient  
        DefaultHttpClient client = new DefaultHttpClient();  
        List<BasicNameValuePair> namePairs = new ArrayList<BasicNameValuePair>();  
        HttpPost httppost = new HttpPost(url);  
        // Map引數轉化為鍵值對  
        for (Map.Entry<String, String> entry : posMap.entrySet()) {  
            BasicNameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());  
            namePairs.add(pair);  
        }  
        //   
        httppost.setEntity(new UrlEncodedFormEntity(namePairs,"UTF-8"));  

        // 傳送請求  
        HttpResponse res =  client.execute(httppost);  
        return res;  
    }  

    /** 
     * 將物件值寫入XML模板中 
     *  
     * @param o 
     *            實體類物件 
     * @param xmlStr 
     *            模板xml字串 
     * @return 返回xml字串 
     * @throws IOException 
     *            異常 
     * @throws TemplateException 
     *            異常 
     */  
    public static String writeXML(Object o, String xmlStr) {  
        // 建立Configuration物件  
        Configuration cfg = new Configuration();  
        // 建立StringTemplateLoader物件  
        StringTemplateLoader stringLoader = new StringTemplateLoader();  
        // 傳入的xml字串  
        stringLoader.putTemplate("xmlTemplate", xmlStr);  
        // 設定模板  
        cfg.setTemplateLoader(stringLoader);  
        // 建立StringWriter物件  
        StringWriter out = new StringWriter();  
        // 獲取字串模板  
        try {  
            Template template = cfg.getTemplate("xmlTemplate");  
            // 物件值寫入xml模板  
            template.process(o, out);  
        } catch (IOException e) {  
            logger.error(HttpClient.class, e);  
            e.printStackTrace();  
        } catch (TemplateException e) {  
            logger.error(HttpClient.class, e);  
            e.printStackTrace();  
        } finally {  
            try {  
                out.close();  
            } catch (IOException e) {  
                logger.error(HttpClient.class, e);  
                e.printStackTrace();  
            }  
        }  
        return out.toString();  
    }  

}  

二、HttpURLConnection

（一）HttpURLConnection客戶端

1、java自帶的api，位於net包下，使用較為繁瑣，基本功能齊全。

2、客戶端程式碼如下：

[java] view plain copy

/** 
 * HttpURLConnection 的客戶端訪問 
 */  
private void connectionClientVisit() {  

    // 定義輸入輸出引數  
    String returnXml = ""; // 核心返回結果報文字串  
    String strMessage = "";  

    // 傳送報文  
    BufferedReader reader = null;  
    StringBuffer buffer = new StringBuffer();  

    // System.setProperty("http.proxyHost","10.7.9.8");//設定代理  
    // System.setProperty("http.proxyPort","54367");  

    try {  

        URL sendUrl = new URL(mUrl);  
        HttpURLConnection conn = (HttpURLConnection) sendUrl.openConnection();  

        conn.setRequestMethod("POST");// 設定請求方式  
        conn.setConnectTimeout(5000); // 設定連線超時為5秒  
        conn.setDoOutput(true);// 設定是否向connection輸出，因為這個是post請求，引數要放在  
        // http正文內，因此需要設為true  
        conn.setDoInput(true);// Read from the connection. Default is true.  
        conn.setAllowUserInteraction(true);  
        conn.setUseCaches(false); // Post 請求不能使用快取  
        conn.setRequestProperty("Content-Language", "GBK");  
        conn.setRequestProperty("Content-Type", "text/xml");// 設定header資訊,這個必不可少  

        // 連線，從sendUrl.openConnection()至此的配置必須要在 connect 之前完成，  
        // 要注意的是 conn.getOutputStream 會隱含的進行 connect。  
        // conn.connect();//連線，可以省略  
        OutputStream stream = conn.getOutputStream();  

        stream.write(mRequestXml.getBytes());  
        stream.flush();  
        stream.close();  
        // 獲取返回的資料  
        // 無論是post還是get，http請求實際上直到HttpURLConnection.getInputStream()這個函式裡面才正式傳送出去。  
        InputStream inputStream = conn.getInputStream();  
        reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));  
        while ((strMessage = reader.readLine()) != null) {  
            buffer.append(strMessage);  
        }  
        returnXml = buffer.toString();  

        System.out.println("HttpURLConnection 的客戶端接收返回值: \r\n" + returnXml);  

        reader.close();  
        conn.disconnect();  
    } catch (MalformedURLException e) {  
        e.printStackTrace();  
    } catch (IOException e) {  
        e.printStackTrace();  
    }  
}  

（二）HttpURLConnection 詳解：注意傳送的時機

1、Get方式的訪問：

[java] view plain copy

/** 
 * Get方式 
 * @throws IOException 
 */  
public static void readContentFromGet() throws IOException {  
    // 拼湊get請求的URL字串，使用URLEncoder.encode對特殊和不可見字元進行編碼  
    String getURL = GET_URL + "?username=" + URLEncoder.encode("你好", "utf-8");  
    URL getUrl = new URL(getURL);  
    // 根據拼湊的URL，開啟連線，URL.openConnection函式會根據URL的型別，  
    // 返回不同的URLConnection子類的物件，這裡URL是一個http，因此實際返回的是HttpURLConnection  
    HttpURLConnection connection = (HttpURLConnection) getUrl.openConnection();  
    // 進行連線，但是實際上get request要在下一句的connection.getInputStream()函式中才會真正發到伺服器  
    connection.connect();  
    // 取得輸入流，並使用Reader讀取  
    BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));  
    System.out.println("=============================");  
    System.out.println("Contents of get request");  
    System.out.println("=============================");  
    String lines;  
    while ((lines = reader.readLine()) != null) {  
        System.out.println(lines);  
    }  
    reader.close();  
    // 斷開連線  
    connection.disconnect();  
    System.out.println("=============================");  
    System.out.println("Contents of get request ends");  
    System.out.println("=============================");  
}  

2、Post方式的訪問：

[java] view plain copy

/** 
 * Post 方式 
 * @throws IOException 
 */  
public static void readContentFromPost() throws IOException {  
    // Post請求的url，與get不同的是不需要帶引數  
    URL postUrl = new URL(POST_URL);  
    // 開啟連線  
    HttpURLConnection connection = (HttpURLConnection) postUrl.openConnection();  
    // Output to the connection. Default is  
    // false, set to true because post  
    // method must write something to the  
    // connection  
    // 設定是否向connection輸出，因為這個是post請求，引數要放在  
    // http正文內，因此需要設為true  
    connection.setDoOutput(true);  
    // Read from the connection. Default is true.  
    connection.setDoInput(true);  
    // Set the post method. Default is GET  
    connection.setRequestMethod("POST");  
    // Post cannot use caches  
    // Post 請求不能使用快取  
    connection.setUseCaches(false);  
    // This method takes effects to  
    // every instances of this class.  
    // URLConnection.setFollowRedirects是static函式，作用於所有的URLConnection物件。  
    // connection.setFollowRedirects(true);  

    // This methods only  
    // takes effacts to this  
    // instance.  
    // URLConnection.setInstanceFollowRedirects是成員函式，僅作用於當前函式  
    connection.setInstanceFollowRedirects(true);  
    // Set the content type to urlencoded,  
    // because we will write  
    // some URL-encoded content to the  
    // connection. Settings above must be set before connect!  
    // 配置本次連線的Content-type，配置為application/x-www-form-urlencoded的  
    // 意思是正文是urlencoded編碼過的form引數，下面我們可以看到我們對正文內容使用URLEncoder.encode  
    // 進行編碼  
    connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");  
    // 連線，從postUrl.openConnection()至此的配置必須要在connect之前完成，  
    // 要注意的是connection.getOutputStream會隱含的進行connect。  
    connection.connect();  
    DataOutputStream out = new DataOutputStream(connection.getOutputStream());  
    // The URL-encoded contend  
    // 正文，正文內容其實跟get的URL中'?'後的引數字串一致  
    String content = "firstname=" + URLEncoder.encode("一個大肥人", "utf-8");  
    // DataOutputStream.writeBytes將字串中的16位的unicode字元以8位的字元形式寫道流裡面  
    out.writeBytes(content);  

    out.flush();  
    out.close(); // flush and close  
    BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));  
    String line;  
    System.out.println("=============================");  
    System.out.println("Contents of post request");  
    System.out.println("=============================");  
    while ((line = reader.readLine()) != null) {  
        System.out.println(line);  
    }  
    System.out.println("=============================");  
    System.out.println("Contents of post request ends");  
    System.out.println("=============================");  
    reader.close();  
    connection.disconnect();  
}  

3、利用setChunkedStreamingMode 改變傳送的時機

[java] view plain copy

/** 
 * 利用setChunkedStreamingMode 改變傳送的時機 
 * @throws IOException 
 */  
public static void readContentFromChunkedPost() throws IOException {  
    URL postUrl = new URL(POST_URL);  
    HttpURLConnection connection = (HttpURLConnection) postUrl.openConnection();  
    connection.setDoOutput(true);  
    connection.setDoInput(true);  
    connection.setRequestMethod("POST");  
    connection.setUseCaches(false);  
    connection.setInstanceFollowRedirects(true);  
    connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");  
    /**//* 
         * 與readContentFromPost()最大的不同，設定了塊大小為5位元組 
         */  
    connection.setChunkedStreamingMode(5);  
    connection.connect();  
    /**//* 
         * 注意，下面的getOutputStream函式工作方式於在readContentFromPost()裡面的不同 
         * 在readContentFromPost()裡面該函式仍在準備http request，沒有向伺服器傳送任何資料 
         * 而在這裡由於設定了ChunkedStreamingMode，getOutputStream函式會根據connect之前的配置 
         * 生成http request頭，先發送到伺服器。 
         */  
    DataOutputStream out = new DataOutputStream(connection.getOutputStream());  
    String content = "firstname="  
            + URLEncoder.encode("一個大肥人                                                                               " + "                                          "  
                    + "asdfasfdasfasdfaasdfasdfasdfdasfs", "utf-8");  
    out.writeBytes(content);  

    out.flush();  
    out.close(); // 到此時伺服器已經收到了完整的http  
                    // request了，而在readContentFromPost()函式裡，要等到下一句伺服器才能收到http請求。  
    BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));  

    out.flush();  
    out.close(); // flush and close  
    String line;  
    System.out.println("=============================");  
    System.out.println("Contents of post request");  
    System.out.println("=============================");  
    while ((line = reader.readLine()) != null) {  
        System.out.println(line);  
    }  
    System.out.println("=============================");  
    System.out.println("Contents of post request ends");  
    System.out.println("=============================");  
    reader.close();  
    connection.disconnect();  
}  

（三）HttpURLConnection 工具類封裝
[java] view plain copy

package cn.rest.util;  

import java.io.BufferedReader;  
import java.io.ByteArrayOutputStream;  
import java.io.DataInputStream;  
import java.io.DataOutputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.io.ObjectOutputStream;  
import java.io.OutputStream;  
import java.net.URL;  
import java.net.URLConnection;  
import java.net.URLEncoder;  
import java.util.HashMap;  
import java.util.Map;  

public class OtherHttpClient {  

    private Map<String, String> parameters = new HashMap<String, String>();  
    private String url;  
    private String service;  
    private String sendEncode = "UTF-8";  
    private String receiceEncode = "UTF-8";  

    public void addParameter(String name, String value) {  
        this.parameters.put(name, value);  
    }  

    /** 
     * 設定代理 
     *  
     * @param host 
     * @param port 
     */  
    public void setProxy(String host, String port) {  
        System.getProperties().put("proxySet", "true");  
        System.getProperties().setProperty("http.proxyHost", host);  
        System.getProperties().setProperty("http.proxyPort", port);  
    }  

    /** 
     * Post 方法 
     *  
     * @return 
     * @throws Exception 
     */  
    public String post() throws Exception {  
        String response = "";  
        try {  
            response = send();  
        } catch (Exception e) {  
            e.printStackTrace();  
            throw new Exception("PostFailure,Url:" + this.url, e);  
        }  
        return response;  
    }  

    /** 
     * Get 方法 
     *  
     * @param httpUrl 
     * @param encode 
     * @return 
     * @throws Exception 
     */  
    public String get(String httpUrl, String encode) throws Exception {  
        String html = "";  
        try {  
            System.out.println("Http Access Url:" + httpUrl);  
            URL url = new URL(httpUrl);  
            URLConnection c = url.openConnection();  
            InputStream inputs = c.getInputStream();  
            int all = inputs.available();  
            byte[] b = new byte[all];  
            inputs.read(b);  
            html = new String(b, encode);  
            inputs.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
            throw new Exception("getFailure,Url:" + httpUrl);  
        }  

        String returnContent = html.toString();  
        System.out.println("Url return:\n" + returnContent);  
        return returnContent;  
    }  

    private String send() throws Exception {  
        URLConnection con;  
        URL url;  
        String response;  
        String paramStr = "";  
        Object[] services = this.parameters.keySet().toArray();  
        StringBuffer rspContent = null;  
        BufferedReader reader = null;  
        DataInputStream in = null;  

        for (int i = 0; i < services.length; ++i) {  
            if (i == 0)  
                paramStr = paramStr + services[i] + "=" + URLEncoder.encode(this.parameters.get(services[i]).toString(), getSendEncode());  
            else  
                paramStr = paramStr + "&" + services[i] + "=" + URLEncoder.encode(this.parameters.get(services[i]).toString(), getSendEncode());  
        }  
        try {  
            String aLine;  
            url = new URL(getUrl());  
            con = url.openConnection();  
            con.setUseCaches(false);  
            con.setDoOutput(true);  
            con.setDoInput(true);  
            con.setRequestProperty("Content-type", "application/x-www-form-urlencoded");  
            byte[] sendParamByte = paramStr.toString().getBytes("iso8859_1");  
            con.setRequestProperty("Content-length", String.valueOf(sendParamByte.length));  
            DataOutputStream dataOut = new DataOutputStream(con.getOutputStream());  
            dataOut.write(sendParamByte);  
            dataOut.flush();  
            dataOut.close();  
            rspContent = new StringBuffer();  
            in = new DataInputStream(con.getInputStream());  
            reader = new BufferedReader(new InputStreamReader(in, getReceiceEncode()));  

            while ((aLine = reader.readLine()) != null) {  
                rspContent.append(aLine + "\n");  
            }  
            response = rspContent.toString();  
            in.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
            throw new Exception(e);  
        } finally {  
            if (reader != null)  
                reader.close();  
            if (in != null)  
                in.close();  
        }  
        return response;  
    }  

    public String sendStream(String content) throws Exception {  
        URLConnection con;  
        URL url;  
        String response;  
        String paramStr = URLEncoder.encode(content, getSendEncode());  
        StringBuffer rspContent = null;  
        BufferedReader reader = null;  
        DataInputStream in = null;  
        try {  
            String aLine;  
            url = new URL(getUrl());  
            con = url.openConnection();  
            con.setUseCaches(false);  
            con.setDoOutput(true);  
            con.setDoInput(true);  
            con.setRequestProperty("Content-type", "application/x-www-form-urlencoded");  
            byte[] sendParamByte = paramStr.toString().getBytes("iso8859_1");  
            con.setRequestProperty("Content-length", String.valueOf(sendParamByte.length));  
            con.setRequestProperty("Keep-alive", "false");  

            DataOutputStream dataOut = new DataOutputStream(con.getOutputStream());  
            dataOut.write(sendParamByte);  
            dataOut.flush();  
            dataOut.close();  
            rspContent = new StringBuffer();  
            in = new DataInputStream(con.getInputStream());  
            reader = new BufferedReader(new InputStreamReader(in, getReceiceEncode()));  

            while ((aLine = reader.readLine()) != null) {  
                rspContent.append(aLine + "\n");  
            }  
            response = rspContent.toString();  
            in.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
            throw new Exception(e);  
        } finally {  
            if (reader != null)  
                reader.close();  
            if (in != null)  
                in.close();  
        }  
        return response;  
    }  

    public String sendObjStream(Object content) throws Exception {  
        URLConnection con;  
        URL url;  
        String response;  
        StringBuffer rspContent = null;  
        BufferedReader reader = null;  
        DataInputStream in = null;  
        try {  
            String aLine;  
            url = new URL(getUrl());  
            con = url.openConnection();  
            con.setUseCaches(false);  
            con.setDoOutput(true);  
            con.setDoInput(true);  

            ObjectOutputStream dataOut = new ObjectOutputStream(con.getOutputStream());  
            dataOut.writeObject(content);  

            dataOut.flush();  
            dataOut.close();  
            rspContent = new StringBuffer();  
            in = new DataInputStream(con.getInputStream());  
            reader = new BufferedReader(new InputStreamReader(in, getReceiceEncode()));  

            while ((aLine = reader.readLine()) != null) {  
                rspContent.append(aLine + "\n");  
            }  
            response = rspContent.toString();  
            in.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
            throw new Exception(e);  
        } finally {  
            if (reader != null)  
                reader.close();  
            if (in != null)  
                in.close();  
        }  
        return response;  
    }  

    public void persistentPDF(String conurl, String fileName) throws IOException {  
        String paramStr = "";  
        Object[] services = this.parameters.keySet().toArray();  
        DataInputStream in = null;  
        try {  
            for (int i = 0; i < services.length; ++i) {  
                if (i == 0)  
                    paramStr = paramStr + services[i] + "=" + URLEncoder.encode(this.parameters.get(services[i]).toString(), getSendEncode());  
                else {  
                    paramStr = paramStr + "&" + services[i] + "=" + URLEncoder.encode(this.parameters.get(services[i]).toString(), getSendEncode());  
                }  
            }  

            /* 
             * LogTool.debug(super.getClass(), "\nServiceName:" + this.service + 
             * "\n" + "Request URL:" + conurl); 
             */  

            URL url = new URL(conurl);  
            URLConnection con = url.openConnection();  
            con.setUseCaches(false);  
            con.setDoOutput(true);  
            con.setDoInput(true);  
            con.setRequestProperty("Content-type", "application/x-www-form-urlencoded");  
            byte[] sendParamByte = paramStr.toString().getBytes("ISO8859-1");  
            con.setRequestProperty("Content-length", String.valueOf(sendParamByte.length));  
            DataOutputStream dataOut = new DataOutputStream(con.getOutputStream());  
            dataOut.write(sendParamByte);  
            dataOut.flush();  
            dataOut.close();  
            in = new DataInputStream(con.getInputStream());  
            if (in == null)  
                return;  
            OutputStream outPDFStream = new FileOutputStream(fileName);  
            int readSize = 0;  
            int blockSize = 15360;  
            byte[] buffer = new byte[blockSize];  
            while ((readSize = in.read(buffer, 0, buffer.length)) > 0) {  
                outPDFStream.write(buffer, 0, readSize);  
            }  
            label384: outPDFStream.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            if (in != null)  
                in.close();  
        }  
    }  

    public byte[] read(InputStream is) {  
        ByteArrayOutputStream bytestream = new ByteArrayOutputStream();  
        int ch;  
        byte imgdata[] = null;  
        try {  
            while ((ch = is.read()) != -1) {  
                bytestream.write(ch);  
            }  
            imgdata = bytestream.toByteArray();  
            bytestream.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return imgdata;  
    }  

    public String getSendEncode() {  
        return this.sendEncode;  
    }  

    public void setSendEncode(String sendEncode) {  
        this.sendEncode = sendEncode;  
    }  

    public String getReceiceEncode() {  
        return this.receiceEncode;  
    }  

    public void setReceiceEncode(String receiceEncode) {  
        this.receiceEncode = receiceEncode;  
    }  



    public String getUrl() {  
        return this.url;  
    }  

    public void setUrl(String url) {  
        this.url = url;  
    }  

    public Map getParameters() {  
        return this.parameters;  
    }  

    public void setParameters(Map parameters) {  
        this.parameters = parameters;  
    }  

    public String getService() {  
        return this.service;  
    }  

    public void setService(String service) {  
        this.service = service;  
    }  

    public static void main(String[] args) throws Exception {  
        OtherHttpClient client = new OtherHttpClient();  
        client.setProxy("10.100.11.148", "909");  
        client.setUrl("http://www.baidu.com");  
        client.addParameter("test1", "1");  
        String returnContent = client.post();  
        System.out.println(returnContent);  
    }  
}