HttpClient使用詳解 (一)

Http協議的重要性相信不用我多說了，HttpClient相比傳統JDK自帶的URLConnection，增加了易用性和靈活性（具體區別，日后我們再討論），它不僅是客戶端發送Http請求變得容易，而且也方便了開發人員測試接口（基於Http協議的），即提高了開發的效率，也方便提高代碼的健壯性。因此熟練掌握HttpClient是很重要的必修內容，掌握HttpClient后，相信對於Http協議的了解會更加深入。

一、簡介

HttpClient是Apache Jakarta Common下的子項目，用來提供高效的、最新的、功能豐富的支持HTTP協議的客戶端編程工具包，並且它支持HTTP協議最新的版本和建議。HttpClient已經應用在很多的項目中，比如Apache Jakarta上很著名的另外兩個開源項目Cactus和HTMLUnit都使用了HttpClient。

下載地址: http://hc.apache.org/downloads.cgi

二、特性

1. 基於標准、純凈的Java語言。實現了Http1.0和Http1.1

2. 以可擴展的面向對象的結構實現了Http全部的方法（GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE）。

3. 支持HTTPS協議。

4. 通過Http代理建立透明的連接。

5. 利用CONNECT方法通過Http代理建立隧道的https連接。

6. Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, SNPNEGO/Kerberos認證方案。

7. 插件式的自定義認證方案。

8. 便攜可靠的套接字工廠使它更容易的使用第三方解決方案。

9. 連接管理器支持多線程應用。支持設置最大連接數，同時支持設置每個主機的最大連接數，發現並關閉過期的連接。

10. 自動處理Set-Cookie中的Cookie。

11. 插件式的自定義Cookie策略。

12. Request的輸出流可以避免流中內容直接緩沖到socket服務器。

13. Response的輸入流可以有效的從socket服務器直接讀取相應內容。

14. 在http1.0和http1.1中利用KeepAlive保持持久連接。

15. 直接獲取服務器發送的response code和 headers。

16. 設置連接超時的能力。

17. 實驗性的支持http1.1 response caching。

18. 源代碼基於Apache License 可免費獲取。

三、使用方法

使用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. 釋放連接。無論執行方法是否成功，都必須釋放連接

四、實例

package com.test;  
  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.UnsupportedEncodingException;  
import java.security.KeyManagementException;  
import java.security.KeyStore;  
import java.security.KeyStoreException;  
import java.security.NoSuchAlgorithmException;  
import java.security.cert.CertificateException;  
import java.util.ArrayList;  
import java.util.List;  
  
import javax.net.ssl.SSLContext;  
  
import org.apache.http.HttpEntity;  
import org.apache.http.NameValuePair;  
import org.apache.http.ParseException;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.CloseableHttpResponse;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLContexts;  
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;  
import org.apache.http.entity.ContentType;  
import org.apache.http.entity.mime.MultipartEntityBuilder;  
import org.apache.http.entity.mime.content.FileBody;  
import org.apache.http.entity.mime.content.StringBody;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;  
import org.junit.Test;  
  
public class HttpClientTest {  
  
    @Test  
    public void jUnitTest() {  
        get();  
    }  
  
    /** 
     * HttpClient連接SSL 
     */  
    public void ssl() {  
        CloseableHttpClient httpclient = null;  
        try {  
            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());  
            FileInputStream instream = new FileInputStream(new File("d:\\tomcat.keystore"));  
            try {  
                // 加載keyStore d:\\tomcat.keystore    
                trustStore.load(instream, "123456".toCharArray());  
            } catch (CertificateException e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    instream.close();  
                } catch (Exception ignore) {  
                }  
            }  
            // 相信自己的CA和所有自簽名的證書  
            SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(trustStore, new TrustSelfSignedStrategy()).build();  
            // 只允許使用TLSv1協議  
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,  
                    SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);  
            httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();  
            // 創建http請求(get方式)  
            HttpGet httpget = new HttpGet("https://localhost:8443/myDemo/Ajax/serivceJ.action");  
            System.out.println("executing request" + httpget.getRequestLine());  
            CloseableHttpResponse response = httpclient.execute(httpget);  
            try {  
                HttpEntity entity = response.getEntity();  
                System.out.println("----------------------------------------");  
                System.out.println(response.getStatusLine());  
                if (entity != null) {  
                    System.out.println("Response content length: " + entity.getContentLength());  
                    System.out.println(EntityUtils.toString(entity));  
                    EntityUtils.consume(entity);  
                }  
            } finally {  
                response.close();  
            }  
        } catch (ParseException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (KeyManagementException e) {  
            e.printStackTrace();  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        } catch (KeyStoreException e) {  
            e.printStackTrace();  
        } finally {  
            if (httpclient != null) {  
                try {  
                    httpclient.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
  
    /** 
     * post方式提交表單（模擬用戶登錄請求） 
     */  
    public void postForm() {  
        // 創建默認的httpClient實例.    
        CloseableHttpClient httpclient = HttpClients.createDefault();  
        // 創建httppost    
        HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");  
        // 創建參數隊列    
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();  
        formparams.add(new BasicNameValuePair("username", "admin"));  
        formparams.add(new BasicNameValuePair("password", "123456"));  
        UrlEncodedFormEntity uefEntity;  
        try {  
            uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");  
            httppost.setEntity(uefEntity);  
            System.out.println("executing request " + httppost.getURI());  
            CloseableHttpResponse response = httpclient.execute(httppost);  
            try {  
                HttpEntity entity = response.getEntity();  
                if (entity != null) {  
                    System.out.println("--------------------------------------");  
                    System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));  
                    System.out.println("--------------------------------------");  
                }  
            } finally {  
                response.close();  
            }  
        } catch (ClientProtocolException e) {  
            e.printStackTrace();  
        } catch (UnsupportedEncodingException e1) {  
            e1.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            // 關閉連接,釋放資源    
            try {  
                httpclient.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    /** 
     * 發送 post請求訪問本地應用並根據傳遞參數不同返回不同結果 
     */  
    public void post() {  
        // 創建默認的httpClient實例.    
        CloseableHttpClient httpclient = HttpClients.createDefault();  
        // 創建httppost    
        HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");  
        // 創建參數隊列    
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();  
        formparams.add(new BasicNameValuePair("type", "house"));  
        UrlEncodedFormEntity uefEntity;  
        try {  
            uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");  
            httppost.setEntity(uefEntity);  
            System.out.println("executing request " + httppost.getURI());  
            CloseableHttpResponse response = httpclient.execute(httppost);  
            try {  
                HttpEntity entity = response.getEntity();  
                if (entity != null) {  
                    System.out.println("--------------------------------------");  
                    System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));  
                    System.out.println("--------------------------------------");  
                }  
            } finally {  
                response.close();  
            }  
        } catch (ClientProtocolException e) {  
            e.printStackTrace();  
        } catch (UnsupportedEncodingException e1) {  
            e1.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            // 關閉連接,釋放資源    
            try {  
                httpclient.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    /** 
     * 發送 get請求 
     */  
    public void get() {  
        CloseableHttpClient httpclient = HttpClients.createDefault();  
        try {  
            // 創建httpget.    
            HttpGet httpget = new HttpGet("http://www.baidu.com/");  
            System.out.println("executing request " + httpget.getURI());  
            // 執行get請求.    
            CloseableHttpResponse response = httpclient.execute(httpget);  
            try {  
                // 獲取響應實體    
                HttpEntity entity = response.getEntity();  
                System.out.println("--------------------------------------");  
                // 打印響應狀態    
                System.out.println(response.getStatusLine());  
                if (entity != null) {  
                    // 打印響應內容長度    
                    System.out.println("Response content length: " + entity.getContentLength());  
                    // 打印響應內容    
                    System.out.println("Response content: " + EntityUtils.toString(entity));  
                }  
                System.out.println("------------------------------------");  
            } finally {  
                response.close();  
            }  
        } catch (ClientProtocolException e) {  
            e.printStackTrace();  
        } catch (ParseException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            // 關閉連接,釋放資源    
            try {  
                httpclient.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    /** 
     * 上傳文件 
     */  
    public void upload() {  
        CloseableHttpClient httpclient = HttpClients.createDefault();  
        try {  
            HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceFile.action");  
  
            FileBody bin = new FileBody(new File("F:\\image\\sendpix0.jpg"));  
            StringBody comment = new StringBody("A binary file of some kind", ContentType.TEXT_PLAIN);  
  
            HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("bin", bin).addPart("comment", comment).build();  
  
            httppost.setEntity(reqEntity);  
  
            System.out.println("executing request " + httppost.getRequestLine());  
            CloseableHttpResponse response = httpclient.execute(httppost);  
            try {  
                System.out.println("----------------------------------------");  
                System.out.println(response.getStatusLine());  
                HttpEntity resEntity = response.getEntity();  
                if (resEntity != null) {  
                    System.out.println("Response content length: " + resEntity.getContentLength());  
                }  
                EntityUtils.consume(resEntity);  
            } finally {  
                response.close();  
            }  
        } catch (ClientProtocolException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            try {  
                httpclient.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

五、實例(開發用到工具類實例)

package com.fh.util.http;

import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.security.cert.CertificateException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HttpEntity;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.params.ClientPNames;
import org.apache.http.client.params.CookiePolicy;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.ByteArrayBody;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.protocol.ExecutionContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

import net.sf.json.JSONObject;

/**
 * @className:HttpClientUtil.java
 * @classDescription:HttpClient工具類//待完善模擬登錄，cookie,證書登錄
 * @author:xiayingjie
 * @createTime:2011-8-31
 */

public class HttpClientUtilMy {

    public static String CHARSET_ENCODING = "UTF-8";
    // private static String
    // USER_AGENT="Mozilla/4.0 (compatible; MSIE 6.0; Win32)";//ie6
    public static String USER_AGENT = "Mozilla/4.0 (compatible; MSIE 7.0; Win32)";// ie7

    // private static String
    // USER_AGENT="Mozilla/4.0 (compatible; MSIE 8.0; Win32)";//ie8

    /**
     * 獲取DefaultHttpClient對象
     * 
     * @param charset
     *            字符編碼
     * @return DefaultHttpClient對象
     */
    private static DefaultHttpClient getDefaultHttpClient(final String charset) {
        DefaultHttpClient httpclient = new DefaultHttpClient();
        // 模擬瀏覽器，解決一些服務器程序只允許瀏覽器訪問的問題
        httpclient.getParams().setParameter(CoreProtocolPNames.USER_AGENT, USER_AGENT);
        httpclient.getParams().setParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, Boolean.FALSE);
        httpclient.getParams().setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET,
                charset == null ? CHARSET_ENCODING : charset);

        // 瀏覽器兼容性
        httpclient.getParams().setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.BROWSER_COMPATIBILITY);
        // 定義重試策略
        httpclient.setHttpRequestRetryHandler(requestRetryHandler);

        return httpclient;
    }

    /**
     * 訪問https的網站
     * 
     * @param httpclient
     */
    private static void enableSSL(DefaultHttpClient httpclient) {
        // 調用ssl
        try {
            SSLContext sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, new TrustManager[] { truseAllManager }, null);
            SSLSocketFactory sf = new SSLSocketFactory(sslcontext);
            sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            Scheme https = new Scheme("https", sf, 443);
            httpclient.getConnectionManager().getSchemeRegistry().register(https);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 重寫驗證方法，取消檢測ssl
     */
    private static TrustManager truseAllManager = new X509TrustManager() {

        public void checkClientTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
                throws CertificateException {
            // TODO Auto-generated method stub

        }

        public void checkServerTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
                throws CertificateException {
            // TODO Auto-generated method stub

        }

        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            // TODO Auto-generated method stub
            return null;
        }

    };

    /**
     * 異常自動恢復處理, 使用HttpRequestRetryHandler接口實現請求的異常恢復
     */
    private static HttpRequestRetryHandler requestRetryHandler = new HttpRequestRetryHandler() {
        // 自定義的恢復策略
        public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
            // 設置恢復策略，在發生異常時候將自動重試3次
            if (executionCount >= 3) {
                // 如果連接次數超過了最大值則停止重試
                return false;
            }
            if (exception instanceof NoHttpResponseException) {
                // 如果服務器連接失敗重試
                return true;
            }
            if (exception instanceof SSLHandshakeException) {
                // 不要重試ssl連接異常
                return false;
            }
            HttpRequest request = (HttpRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST);
            boolean idempotent = (request instanceof HttpEntityEnclosingRequest);
            if (!idempotent) {
                // 重試，如果請求是考慮冪等
                return true;
            }
            return false;
        }
    };

    /**
     * 使用ResponseHandler接口處理響應，HttpClient使用ResponseHandler會自動管理連接的釋放，解決了對連接的釋放管理
     */
    private static ResponseHandler<String> responseHandler = new ResponseHandler<String>() {
        // 自定義響應處理
        public String handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                String charset = EntityUtils.getContentCharSet(entity) == null ? CHARSET_ENCODING
                        : EntityUtils.getContentCharSet(entity);
                return new String(EntityUtils.toByteArray(entity), charset);
            } else {
                return null;
            }
        }
    };

    /**
     * 使用post方法獲取相關的數據
     * 
     * @param url
     * @param paramsList
     * @return
     */
    public static String post(String url, List<NameValuePair> paramsList) {
        return httpRequest(url, paramsList, "POST", null);
    }

    /**
     * 使用post方法並且通過代理獲取相關的數據
     * 
     * @param url
     * @param paramsList
     * @param proxy
     * @return
     */
    public static String post(String url, List<NameValuePair> paramsList, HttpHost proxy) {
        return httpRequest(url, paramsList, "POST", proxy);
    }

    /**
     * 使用get方法獲取相關的數據
     * 
     * @param url
     * @param paramsList
     * @return
     */
    public static String get(String url, List<NameValuePair> paramsList) {
        return httpRequest(url, paramsList, "GET", null);
    }

    /**
     * 使用get方法並且通過代理獲取相關的數據
     * 
     * @param url
     * @param paramsList
     * @param proxy
     * @return
     */
    public static String get(String url, List<NameValuePair> paramsList, HttpHost proxy) {
        return httpRequest(url, paramsList, "GET", proxy);
    }

    /**
     * 提交數據到服務器
     * 
     * @param url
     * @param params
     * @param authenticated
     * @throws IOException
     * @throws ClientProtocolException
     */
    public static String httpRequest(String url, List<NameValuePair> paramsList, String method, HttpHost proxy) {
        String responseStr = null;
        // 判斷輸入的值是是否為空
        if (null == url || "".equals(url)) {
            return null;
        }

        // 創建HttpClient實例
        DefaultHttpClient httpclient = getDefaultHttpClient(CHARSET_ENCODING);

        // 判斷是否是https請求
        if (url.startsWith("https")) {
            enableSSL(httpclient);
        }
        String formatParams = null;
        // 將參數進行utf-8編碼
        if (null != paramsList && paramsList.size() > 0) {
            formatParams = URLEncodedUtils.format(paramsList, CHARSET_ENCODING);
        }
        // 如果代理對象不為空則設置代理
        if (null != proxy) {
            httpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
        }
        try {
            // 如果方法為Get
            if ("GET".equalsIgnoreCase(method)) {
                if (formatParams != null) {
                    url = (url.indexOf("?")) < 0 ? (url + "?" + formatParams)
                            : (url.substring(0, url.indexOf("?") + 1) + formatParams);
                }
                HttpGet hg = new HttpGet(url);
                responseStr = httpclient.execute(hg, responseHandler);

                // 如果方法為Post
            } else if ("POST".equalsIgnoreCase(method)) {
                HttpPost hp = new HttpPost(url);
                if (formatParams != null) {
                    StringEntity entity = new StringEntity(formatParams);
                    entity.setContentType("application/x-www-form-urlencoded");
                    hp.setEntity(entity);
                }
                responseStr = httpclient.execute(hp, responseHandler);

            }

        } catch (ClientProtocolException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return responseStr;
    }

    /**
     * 提交數據到服務器
     * 
     * @param url
     * @param params
     * @param authenticated
     * @throws IOException
     * @throws ClientProtocolException
     */
    public static String httpFileRequest(String url, Map<String, String> fileMap, Map<String, String> stringMap,
            int type, HttpHost proxy) {
        String responseStr = null;
        // 判斷輸入的值是是否為空
        if (null == url || "".equals(url)) {
            return null;
        }
        // 創建HttpClient實例
        DefaultHttpClient httpclient = getDefaultHttpClient(CHARSET_ENCODING);

        // 判斷是否是https請求
        if (url.startsWith("https")) {
            enableSSL(httpclient);
        }

        // 如果代理對象不為空則設置代理
        if (null != proxy) {
            httpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
        }
        // 發送文件
        HttpPost hp = new HttpPost(url);
        MultipartEntity multiEntity = new MultipartEntity();
        try {
            // type=0是本地路徑，否則是網絡路徑
            if (type == 0) {
                for (String key : fileMap.keySet()) {
                    multiEntity.addPart(key, new FileBody(new File(fileMap.get(key))));
                }
            } else {
                for (String key : fileMap.keySet()) {
                    multiEntity.addPart(key, new ByteArrayBody(getUrlFileBytes(fileMap.get(key)), key));
                }
            }
            // 加入相關參數 默認編碼為utf-8
            for (String key : stringMap.keySet()) {
                multiEntity.addPart(key, new StringBody(stringMap.get(key), Charset.forName(CHARSET_ENCODING)));
            }
            hp.setEntity(multiEntity);
            responseStr = httpclient.execute(hp, responseHandler);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return responseStr;
    }

    /**
     * 將相關文件和參數提交到相關服務器
     * 
     * @param url
     * @param fileMap
     * @param StringMap
     * @return
     */
    public static String postFile(String url, Map<String, String> fileMap, Map<String, String> stringMap) {
        return httpFileRequest(url, fileMap, stringMap, 0, null);
    }

    /**
     * 將相關文件和參數提交到相關服務器
     * 
     * @param url
     * @param fileMap
     * @param StringMap
     * @return
     */
    public static String postUrlFile(String url, Map<String, String> urlMap, Map<String, String> stringMap) {
        return httpFileRequest(url, urlMap, stringMap, 1, null);
    }

    /**
     * 獲取網絡文件的字節數組
     * 
     * @param url
     * @return
     * @throws IOException
     * @throws ClientProtocolException
     * @throws ClientProtocolException
     * @throws IOException
     */
    public static byte[] getUrlFileBytes(String url) throws ClientProtocolException, IOException {

        byte[] bytes = null;
        // 創建HttpClient實例
        CloseableHttpClient httpclient = getDefaultHttpClient(CHARSET_ENCODING);
        // 獲取url里面的信息
        HttpGet hg = new HttpGet(url);
        HttpResponse hr = httpclient.execute(hg);
        bytes = EntityUtils.toByteArray(hr.getEntity());
        // 轉換內容為字節
        return bytes;
    }

    /**
     * 獲取圖片的字節數組
     * 
     * @createTime 2011-11-24
     * @param url
     * @return
     * @throws IOException
     * @throws ClientProtocolException
     * @throws ClientProtocolException
     * @throws IOException
     */
    public static byte[] getImg(String url) throws ClientProtocolException, IOException {
        byte[] bytes = null;
        // 創建HttpClient實例
        DefaultHttpClient httpclient = getDefaultHttpClient(CHARSET_ENCODING);
        // 獲取url里面的信息
        HttpGet hg = new HttpGet(url);
        HttpResponse hr = httpclient.execute(hg);
        bytes = EntityUtils.toByteArray(hr.getEntity());
        // 轉換內容為字節
        return bytes;
    }

    /**
     * @Description 請求微吼接口
     * @author 張洋
     * @date 2017年8月12日 上午11:19:44
     * @param method
     *            方法名 樣式:{資源名}/{函數名}
     * @param params 條件參數
     * @return
     */
    public static JSONObject getVhallUrlByPost(String method, Map<String,String> param) {
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        //封裝請求參數
        for (Entry<String, String> entry : param.entrySet()) {
            params.add(new BasicNameValuePair(entry.getKey(), (String) entry.getValue()));
        }
        // 訪問接口地址
        Object[] parameter = new Object[4];
        parameter[0] = method;
        String url = MessageFormat.format("http://e.vhall.com/api/vhallapi/v2/{0}", parameter);
        // String url = MessageFormat.format("http:loaclhost/{0}", parameter);
        // 參數
        // List<NameValuePair> params = new ArrayList<NameValuePair>();
        // 添加公共參數
        params.add(new BasicNameValuePair("auth_type", "1"));
        params.add(new BasicNameValuePair("account", "v19462836"));
        params.add(new BasicNameValuePair("password", "12345678"));
        String str = HttpClientUtilMy.post(url, params);
        JSONObject jsonData = JSONObject.fromObject(str);
        System.out.println("code:" + jsonData.get("code"));
        System.out.println("info:" + jsonData.get("msg"));
        System.out.println(jsonData.toString());
        return jsonData;

    }

}