幾種流行Webservice框架

一、 幾個比較流行的Webservice框架：

Apache Axis1、Apache Axis2、Codehaus XFire、Apache CXF、Apache Wink、Jboss  RESTEasy、sun JAX-WS（最簡單、方便）、阿里巴巴  Dubbo（除外）等，采用Java作為測試用例，通過本機和遠程兩種進行測試方式，對這幾種框架進行了性能測試，並對測試結果分析和性能比較，最后並對性能優異的框架進行了推薦。

目前三種主流的web服務實現方法： 

REST（新型）：表象化狀態轉變 (軟件架構風格）RESTEasy、Wink、CXF、Axis2…….

SOAP（比較成熟）：簡單對象訪問協議  Xfire、Axis2、CXF、Axis1

XML-RPC（淘汰）：遠程過程調用協議（慢慢被soap 所取代）

REST 簡單易用，效率高，貌似未來有很大的發展空間，也有宣稱rest性能個方便比soap強大的，已經有很多框架宣稱對rest進行支持比如spring 3.0、struts…….. （百度觀點）

SOAP 成熟度較高，安全性較好

關鍵詞：Axis1、Axis2、XFire、CXF、Spring、SOAP、StAX、WSDL

二、rest理解

先說REST名稱
REST -- REpresentational State Transfer
首先，之所以晦澀是因為前面主語被去掉了，全稱是 Resource Representational State Transfer：

通俗來講就是：資源在網絡中以某種表現形式進行狀態轉移。分解開來：

Resource：資源，即數據（前面說過網絡的核心）。比如 newsfeed，friends等；
Representational：某種表現形式，比如用JSON，XML，JPEG等；
State Transfer：狀態變化。通過HTTP動詞實現。
REST的出處
Roy Fielding的畢業論文。這哥們參與設計HTTP協議，也是Apache Web Server項目（可惜現在已經是 nginx 的天下）的co-founder。PhD的畢業學校是 UC Irvine，Irvine在加州，有着充裕的陽光和美麗的海灘，是著名的富人區。Oculus VR 的總部就坐落於此（虛擬現實眼鏡，被FB收購，CTO為Quake和Doom的作者 John Carmack）。
眾說周知，論文都是晦澀難懂的。當年在CMU讀書的時候，很多課程都會安排每周兩篇的Paper review。現在回想起來每次寫Paper review都是我最為痛苦的時候。REST這篇博士論文毫無疑問更甚。

三、java實現http請求的三種方式

目前JAVA實現HTTP請求的方法用的最多的有兩種：一種是通過HTTPClient這種第三方的開源框架去實現。HTTPClient對HTTP的封裝性比較不錯，通過它基本上能夠滿足我們大部分的需求，HttpClient3.1 是 org.apache.commons.httpclient下操作遠程 url的工具包，雖然已不再更新，但實現工作中使用httpClient3.1的代碼還是很多，HttpClient4.5是org.apache.http.client下操作遠程 url的工具包，最新的；另一種則是通過HttpURLConnection去實現，HttpURLConnection是JAVA的標准類，是JAVA比較原生的一種實現方式。

 

如何通過Java發送HTTP請求，通俗點講，如何通過Java（模擬瀏覽器）發送HTTP請求。

Java有原生的API可用於發送HTTP請求，即java.net.URL、java.net.URLConnection，這些API很好用、很常用，但不夠簡便；

所以，也流行有許多Java HTTP請求的framework，如，Apache的HttpClient。

第一種方式：java原生HttpURLConnection

package com.powerX.httpClient;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class HttpClient {
    public static String doGet(String httpurl) {
        HttpURLConnection connection = null;
        InputStream is = null;
        BufferedReader br = null;
        String result = null;// 返回結果字符串
        try {
            // 創建遠程url連接對象
            URL url = new URL(httpurl);
            // 通過遠程url連接對象打開一個連接，強轉成httpURLConnection類
            connection = (HttpURLConnection) url.openConnection();
            // 設置連接方式：get
            connection.setRequestMethod("GET");
            // 設置連接主機服務器的超時時間：15000毫秒
            connection.setConnectTimeout(15000);
            // 設置讀取遠程返回的數據時間：60000毫秒
            connection.setReadTimeout(60000);
            // 發送請求
            connection.connect();
            // 通過connection連接，獲取輸入流
            if (connection.getResponseCode() == 200) {
                is = connection.getInputStream();
                // 封裝輸入流is，並指定字符集
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                // 存放數據
                StringBuffer sbf = new StringBuffer();
                String temp = null;
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append("\r\n");
                }
                result = sbf.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            connection.disconnect();// 關閉遠程連接
        }

        return result;
    }

    public static String doPost(String httpUrl, String param) {

        HttpURLConnection connection = null;
        InputStream is = null;
        OutputStream os = null;
        BufferedReader br = null;
        String result = null;
        try {
            URL url = new URL(httpUrl);
            // 通過遠程url連接對象打開連接
            connection = (HttpURLConnection) url.openConnection();
            // 設置連接請求方式
            connection.setRequestMethod("POST");
            // 設置連接主機服務器超時時間：15000毫秒
            connection.setConnectTimeout(15000);
            // 設置讀取主機服務器返回數據超時時間：60000毫秒
            connection.setReadTimeout(60000);

            // 默認值為：false，當向遠程服務器傳送數據/寫數據時，需要設置為true
            connection.setDoOutput(true);
            // 默認值為：true，當前向遠程服務讀取數據時，設置為true，該參數可有可無
            connection.setDoInput(true);
            // 設置傳入參數的格式:請求參數應該是 name1=value1&name2=value2 的形式。
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            // 設置鑒權信息：Authorization: Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0
            connection.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
            // 通過連接對象獲取一個輸出流
            os = connection.getOutputStream();
            // 通過輸出流對象將參數寫出去/傳輸出去,它是通過字節數組寫出的
            os.write(param.getBytes());
            // 通過連接對象獲取一個輸入流，向遠程讀取
            if (connection.getResponseCode() == 200) {

                is = connection.getInputStream();
                // 對輸入流對象進行包裝:charset根據工作項目組的要求來設置
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));

                StringBuffer sbf = new StringBuffer();
                String temp = null;
                // 循環遍歷一行一行讀取數據
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append("\r\n");
                }
                result = sbf.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 斷開與遠程地址url的連接
            connection.disconnect();
        }
        return result;
    }
}

　　第二種方式：apache HttpClient3.1

package com.powerX.httpClient;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;

public class HttpClient3 {

    public static String doGet(String url) {
        // 輸入流
        InputStream is = null;
        BufferedReader br = null;
        String result = null;
        // 創建httpClient實例
        HttpClient httpClient = new HttpClient();
        // 設置http連接主機服務超時時間：15000毫秒
        // 先獲取連接管理器對象，再獲取參數對象,再進行參數的賦值
        httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
        // 創建一個Get方法實例對象
        GetMethod getMethod = new GetMethod(url);
        // 設置get請求超時為60000毫秒
        getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);
        // 設置請求重試機制，默認重試次數：3次，參數設置為true，重試機制可用，false相反
        getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(3, true));
        try {
            // 執行Get方法
            int statusCode = httpClient.executeMethod(getMethod);
            // 判斷返回碼
            if (statusCode != HttpStatus.SC_OK) {
                // 如果狀態碼返回的不是ok,說明失敗了,打印錯誤信息
                System.err.println("Method faild: " + getMethod.getStatusLine());
            } else {
                // 通過getMethod實例，獲取遠程的一個輸入流
                is = getMethod.getResponseBodyAsStream();
                // 包裝輸入流
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));

                StringBuffer sbf = new StringBuffer();
                // 讀取封裝的輸入流
                String temp = null;
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp).append("\r\n");
                }

                result = sbf.toString();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 釋放連接
            getMethod.releaseConnection();
        }
        return result;
    }

    public static String doPost(String url, Map<String, Object> paramMap) {
        // 獲取輸入流
        InputStream is = null;
        BufferedReader br = null;
        String result = null;
        // 創建httpClient實例對象
        HttpClient httpClient = new HttpClient();
        // 設置httpClient連接主機服務器超時時間：15000毫秒
        httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
        // 創建post請求方法實例對象
        PostMethod postMethod = new PostMethod(url);
        // 設置post請求超時時間
        postMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);

        NameValuePair[] nvp = null;
        // 判斷參數map集合paramMap是否為空
        if (null != paramMap && paramMap.size() > 0) {// 不為空
            // 創建鍵值參數對象數組，大小為參數的個數
            nvp = new NameValuePair[paramMap.size()];
            // 循環遍歷參數集合map
            Set<Entry<String, Object>> entrySet = paramMap.entrySet();
            // 獲取迭代器
            Iterator<Entry<String, Object>> iterator = entrySet.iterator();

            int index = 0;
            while (iterator.hasNext()) {
                Entry<String, Object> mapEntry = iterator.next();
                // 從mapEntry中獲取key和value創建鍵值對象存放到數組中
                try {
                    nvp[index] = new NameValuePair(mapEntry.getKey(),
                            new String(mapEntry.getValue().toString().getBytes("UTF-8"), "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                index++;
            }
        }
        // 判斷nvp數組是否為空
        if (null != nvp && nvp.length > 0) {
            // 將參數存放到requestBody對象中
            postMethod.setRequestBody(nvp);
        }
        // 執行POST方法
        try {
            int statusCode = httpClient.executeMethod(postMethod);
            // 判斷是否成功
            if (statusCode != HttpStatus.SC_OK) {
                System.err.println("Method faild: " + postMethod.getStatusLine());
            }
            // 獲取遠程返回的數據
            is = postMethod.getResponseBodyAsStream();
            // 封裝輸入流
            br = new BufferedReader(new InputStreamReader(is, "UTF-8"));

            StringBuffer sbf = new StringBuffer();
            String temp = null;
            while ((temp = br.readLine()) != null) {
                sbf.append(temp).append("\r\n");
            }

            result = sbf.toString();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 釋放連接
            postMethod.releaseConnection();
        }
        return result;
    }
}

　　第三種方式：apache  httpClient4.5

package com.powerX.httpClient;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
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.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class HttpClient4 {

    public static String doGet(String url) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        String result = "";
        try {
            // 通過址默認配置創建一個httpClient實例
            httpClient = HttpClients.createDefault();
            // 創建httpGet遠程連接實例
            HttpGet httpGet = new HttpGet(url);
            // 設置請求頭信息，鑒權
            httpGet.setHeader("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
            // 設置配置請求參數
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(35000)// 連接主機服務超時時間
                    .setConnectionRequestTimeout(35000)// 請求超時時間
                    .setSocketTimeout(60000)// 數據讀取超時時間
                    .build();
            // 為httpGet實例設置配置
            httpGet.setConfig(requestConfig);
            // 執行get請求得到返回對象
            response = httpClient.execute(httpGet);
            // 通過返回對象獲取返回數據
            HttpEntity entity = response.getEntity();
            // 通過EntityUtils中的toString方法將結果轉換為字符串
            result = EntityUtils.toString(entity);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    public static String doPost(String url, Map<String, Object> paramMap) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse httpResponse = null;
        String result = "";
        // 創建httpClient實例
        httpClient = HttpClients.createDefault();
        // 創建httpPost遠程連接實例
        HttpPost httpPost = new HttpPost(url);
        // 配置請求參數實例
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(35000)// 設置連接主機服務超時時間
                .setConnectionRequestTimeout(35000)// 設置連接請求超時時間
                .setSocketTimeout(60000)// 設置讀取數據連接超時時間
                .build();
        // 為httpPost實例設置配置
        httpPost.setConfig(requestConfig);
        // 設置請求頭
        httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded");
        // 封裝post請求參數
        if (null != paramMap && paramMap.size() > 0) {
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            // 通過map集成entrySet方法獲取entity
            Set<Entry<String, Object>> entrySet = paramMap.entrySet();
            // 循環遍歷，獲取迭代器
            Iterator<Entry<String, Object>> iterator = entrySet.iterator();
            while (iterator.hasNext()) {
                Entry<String, Object> mapEntry = iterator.next();
                nvps.add(new BasicNameValuePair(mapEntry.getKey(), mapEntry.getValue().toString()));
            }

            // 為httpPost設置封裝好的請求參數
            try {
                httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        try {
            // httpClient對象執行post請求,並返回響應參數對象
            httpResponse = httpClient.execute(httpPost);
            // 從響應對象中獲取響應內容
            HttpEntity entity = httpResponse.getEntity();
            result = EntityUtils.toString(entity);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (null != httpResponse) {
                try {
                    httpResponse.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }
}

 

參考資料：

http://www.cnblogs.com/firstdream/p/5575928.html

https://www.zhihu.com/question/28557115

https://blog.csdn.net/chenxiaochan/article/details/52988323 (restful接口的兩種使用方式)

https://www.cnblogs.com/hhhshct/p/8523697.html（java實現http請求的三種方式）

http://www.cnblogs.com/nick-huang/p/3859353.html（java.net.URLConnection發送http請求）