Android okHttp網絡請求之Get/Post請求

   前言：

      之前項目中一直使用的Xutils開源框架，從xutils 2.1.5版本使用到最近的xutils 3.0，使用起來也是蠻方便的，只不過最近想着完善一下app中使用的開源框架，由於Xutils里面包含的東西相對來說比較雜，有數據庫、圖片緩存、注解、網絡請求等等，秉着一個開源庫只處理一件事的想法，決定逐步替換到Xutils，上網搜了一下比較好的開源框架，就找到了okHttp、volley、android-async-http等比較推薦的開源網絡請求，該如何選擇呢？

     okHttp相關文章地址：

• Android okHttp網絡請求之Get/Post請求
• Android okHttp網絡請求之文件上傳下載
• Android okHttp網絡請求之Json解析
• Android okHttp網絡請求之緩存控制Cache-Control
• Android okHttp網絡請求之Retrofit+Okhttp組合

   okHttp、volley、android-async-http對比：

• volley是一個簡單的異步http庫，僅此而已。缺點是不支持同步，這點會限制開發模式；不能post大數據，所以不適合用來上傳文件
• android-async-http。與volley一樣是異步網絡庫，但volley是封裝的httpUrlConnection，它是封裝的httpClient，而android平台不推薦用HttpClient了，所以這個庫已經不適合android平台了。
• okhttp是高性能的http庫，支持同步、異步，而且實現了spdy、http2、websocket協議，api很簡潔易用，和volley一樣實現了http協議的緩存。

   okHttp介紹：

      通過上面的對比說明，讓你不得不做出明智的選擇，OkHttp是一個相對成熟的解決方案，據說Android4.4的源碼中可以看到HttpURLConnection已經替換成OkHttp實現了，所以決定選擇采用okhttp。

      官網地址：http://square.github.io/okhttp/

      官方API地址：http://m.blog.csdn.net/article/details?id=50747352

      github源碼地址：https://github.com/square/okhttp

   okHttp主要類：

       1.)OkHttpClient.java

       2.)Request.java

       3.)Call.java

       4.)RequestBody.java

       5.)Response.java

   okHttp使用：

  1.）添加引用 build.gradle添加如下    

compile 'com.squareup.okhttp3:okhttp:3.2.0'

 2.）創建一個RequestManager類接下來以項目中用來的實戰為例 

     RequestManager.java 全局屬性解說

    private static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/x-www-form-urlencoded; charset=utf-8");//mdiatype 這個需要和服務端保持一致
    private static final MediaType MEDIA_TYPE_MARKDOWN = MediaType.parse("text/x-markdown; charset=utf-8");//mdiatype 這個需要和服務端保持一致
    private static final String TAG = RequestManager.class.getSimpleName();
    private static final String BASE_URL = "http://xxx.com/openapi";//請求接口根地址
    private static volatile RequestManager mInstance;//單利引用
    public static final int TYPE_GET = 0;//get請求
    public static final int TYPE_POST_JSON = 1;//post請求參數為json
    public static final int TYPE_POST_FORM = 2;//post請求參數為表單
    private OkHttpClient mOkHttpClient;//okHttpClient 實例
    private Handler okHttpHandler;//全局處理子線程和M主線程通信

     RequestManager.java 構造函數

   /**
     * 初始化RequestManager
     */
    public RequestManager(Context context) {
        //初始化OkHttpClient
        mOkHttpClient = new OkHttpClient().newBuilder()
                .connectTimeout(10, TimeUnit.SECONDS)//設置超時時間
                .readTimeout(10, TimeUnit.SECONDS)//設置讀取超時時間
                .writeTimeout(10, TimeUnit.SECONDS)//設置寫入超時時間
                .build();
        //初始化Handler
        okHttpHandler = new Handler(context.getMainLooper());
    }

   RequestManager.java 獲取單利引用 這里用到了雙重檢查鎖實現單例

   /**
     * 獲取單例引用
     *
     * @return
     */
    public static RequestManager getInstance(Context context) {
        RequestManager inst = mInstance;
        if (inst == null) {
            synchronized (RequestManager.class) {
                inst = mInstance;
                if (inst == null) {
                    inst = new RequestManager(context.getApplicationContext());
                    mInstance = inst;
                }
            }
        }
        return inst;
    }

 3.）實現okHttp同步請求

     同步請求統一入口

   /**
     *  okHttp同步請求統一入口
     * @param actionUrl  接口地址
     * @param requestType 請求類型
     * @param paramsMap   請求參數
     */
    public void requestSyn(String actionUrl, int requestType, HashMap<String, String> paramsMap) {
        switch (requestType) {
            case TYPE_GET:
                requestGetBySyn(actionUrl, paramsMap);
                break;
            case TYPE_POST_JSON:
                requestPostBySyn(actionUrl, paramsMap);
                break;
            case TYPE_POST_FORM:
                requestPostBySynWithForm(actionUrl, paramsMap);
                break;
        }
    }

 okHttp get同步請求

    /**
     * okHttp get同步請求
     * @param actionUrl  接口地址
     * @param paramsMap   請求參數
     */
    private void requestGetBySyn(String actionUrl, HashMap<String, String> paramsMap) {
        StringBuilder tempParams = new StringBuilder();
        try {
            //處理參數
            int pos = 0;
            for (String key : paramsMap.keySet()) {
                if (pos > 0) {
                    tempParams.append("&");
                }
                //對參數進行URLEncoder
                tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
                pos++;
            }
            //補全請求地址
            String requestUrl = String.format("%s/%s?%s", BASE_URL, actionUrl, tempParams.toString());
            //創建一個請求
            Request request = addHeaders().url(requestUrl).build();
            //創建一個Call
            final Call call = mOkHttpClient.newCall(request);
            //執行請求
            final Response response = call.execute();
            response.body().string();
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
    }

okHttp post同步請求

    /**
     * okHttp post同步請求
     * @param actionUrl  接口地址
     * @param paramsMap   請求參數
     */
    private void requestPostBySyn(String actionUrl, HashMap<String, String> paramsMap) {
        try {
            //處理參數
            StringBuilder tempParams = new StringBuilder();
            int pos = 0;
            for (String key : paramsMap.keySet()) {
                if (pos > 0) {
                    tempParams.append("&");
                }
                tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
                pos++;
            }
            //補全請求地址
            String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
            //生成參數
            String params = tempParams.toString();
            //創建一個請求實體對象 RequestBody
            RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, params);
            //創建一個請求
            final Request request = addHeaders().url(requestUrl).post(body).build();
            //創建一個Call
            final Call call = mOkHttpClient.newCall(request);
            //執行請求
            Response response = call.execute();
            //請求執行成功
            if (response.isSuccessful()) {
                //獲取返回數據 可以是String，bytes ,byteStream
                Log.e(TAG, "response ----->" + response.body().string());
            }
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
    }

okHttp post同步請求表單提交

 /**
     * okHttp post同步請求表單提交
     * @param actionUrl 接口地址
     * @param paramsMap 請求參數
     */
    private void requestPostBySynWithForm(String actionUrl, HashMap<String, String> paramsMap) {
        try {
            //創建一個FormBody.Builder
            FormBody.Builder builder = new FormBody.Builder();
            for (String key : paramsMap.keySet()) {
                //追加表單信息
                builder.add(key, paramsMap.get(key));
            }
            //生成表單實體對象
            RequestBody formBody = builder.build();
            //補全請求地址
            String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
            //創建一個請求
            final Request request = addHeaders().url(requestUrl).post(formBody).build();
            //創建一個Call
            final Call call = mOkHttpClient.newCall(request);
            //執行請求
            Response response = call.execute();
            if (response.isSuccessful()) {
                Log.e(TAG, "response ----->" + response.body().string());
            }
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
    }

 4.）實現okHttp異步請求

   異步請求統一入口

  /**
     * okHttp異步請求統一入口
     * @param actionUrl   接口地址
     * @param requestType 請求類型
     * @param paramsMap   請求參數
     * @param callBack 請求返回數據回調
     * @param <T> 數據泛型
     **/
    public <T> Call requestAsyn(String actionUrl, int requestType, HashMap<String, String> paramsMap, ReqCallBack<T> callBack) {
        Call call = null;
        switch (requestType) {
            case TYPE_GET:
                call = requestGetByAsyn(actionUrl, paramsMap, callBack);
                break;
            case TYPE_POST_JSON:
                call = requestPostByAsyn(actionUrl, paramsMap, callBack);
                break;
            case TYPE_POST_FORM:
                call = requestPostByAsynWithForm(actionUrl, paramsMap, callBack);
                break;
        }
        return call;
    }

okHttp get異步請求

  /**
     * okHttp get異步請求
     * @param actionUrl 接口地址
     * @param paramsMap 請求參數
     * @param callBack 請求返回數據回調
     * @param <T> 數據泛型
     * @return
     */
    private <T> Call requestGetByAsyn(String actionUrl, HashMap<String, String> paramsMap, final ReqCallBack<T> callBack) {
        StringBuilder tempParams = new StringBuilder();
        try {
            int pos = 0;
            for (String key : paramsMap.keySet()) {
                if (pos > 0) {
                    tempParams.append("&");
                }
                tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
                pos++;
            }
            String requestUrl = String.format("%s/%s?%s", BASE_URL, actionUrl, tempParams.toString());
            final Request request = addHeaders().url(requestUrl).build();
            final Call call = mOkHttpClient.newCall(request);
            call.enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    failedCallBack("訪問失敗", callBack);
                    Log.e(TAG, e.toString());
                }

                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    if (response.isSuccessful()) {
                        String string = response.body().string();
                        Log.e(TAG, "response ----->" + string);
                        successCallBack((T) string, callBack);
                    } else {
                        failedCallBack("服務器錯誤", callBack);
                    }
                }
            });
            return call;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        return null;
    }

okHttp post異步請求

  /**
     * okHttp post異步請求
     * @param actionUrl 接口地址
     * @param paramsMap 請求參數
     * @param callBack 請求返回數據回調
     * @param <T> 數據泛型
     * @return
     */
    private <T> Call requestPostByAsyn(String actionUrl, HashMap<String, String> paramsMap, final ReqCallBack<T> callBack) {
        try {
            StringBuilder tempParams = new StringBuilder();
            int pos = 0;
            for (String key : paramsMap.keySet()) {
                if (pos > 0) {
                    tempParams.append("&");
                }
                tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
                pos++;
            }
            String params = tempParams.toString();
            RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, params);
            String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
            final Request request = addHeaders().url(requestUrl).post(body).build();
            final Call call = mOkHttpClient.newCall(request);
            call.enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    failedCallBack("訪問失敗", callBack);
                    Log.e(TAG, e.toString());
                }

                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    if (response.isSuccessful()) {
                        String string = response.body().string();
                        Log.e(TAG, "response ----->" + string);
                        successCallBack((T) string, callBack);
                    } else {
                        failedCallBack("服務器錯誤", callBack);
                    }
                }
            });
            return call;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        return null;
    }

okHttp post異步請求表單提交

 /**
     * okHttp post異步請求表單提交
     * @param actionUrl 接口地址
     * @param paramsMap 請求參數
     * @param callBack 請求返回數據回調
     * @param <T> 數據泛型
     * @return
     */
    private <T> Call requestPostByAsynWithForm(String actionUrl, HashMap<String, String> paramsMap, final ReqCallBack<T> callBack) {
        try {
            FormBody.Builder builder = new FormBody.Builder();
            for (String key : paramsMap.keySet()) {
                builder.add(key, paramsMap.get(key));
            }
            RequestBody formBody = builder.build();
            String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
            final Request request = addHeaders().url(requestUrl).post(formBody).build();
            final Call call = mOkHttpClient.newCall(request);
            call.enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    failedCallBack("訪問失敗", callBack);
                    Log.e(TAG, e.toString());
                }

                @Override
                public void onResponse(Call call, Response response) throws IOException {
                    if (response.isSuccessful()) {
                        String string = response.body().string();
                        Log.e(TAG, "response ----->" + string);
                        successCallBack((T) string, callBack);
                    } else {
                        failedCallBack("服務器錯誤", callBack);
                    }
                }
            });
            return call;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        return null;
    }

接口ReqCallBack.java實現

public interface ReqCallBack<T> {
    /**
     * 響應成功
     */
     void onReqSuccess(T result);

    /**
     * 響應失敗
     */
     void onReqFailed(String errorMsg);
}

5.）如何添加請求頭

   /**
     * 統一為請求添加頭信息
     * @return
     */
    private Request.Builder addHeaders() {
        Request.Builder builder = new Request.Builder()
                .addHeader("Connection", "keep-alive")
                .addHeader("platform", "2")
                .addHeader("phoneModel", Build.MODEL)
                .addHeader("systemVersion", Build.VERSION.RELEASE)
                .addHeader("appVersion", "3.2.0");
        return builder;
    }

 6.）成功與失敗 回調處理

   成功回調處理

 /**
     * 統一同意處理成功信息
     * @param result
     * @param callBack
     * @param <T>
     */
    private <T> void successCallBack(final T result, final ReqCallBack<T> callBack) {
        okHttpHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.onReqSuccess(result);
                }
            }
        });
    }

失敗回調處理

 /**
     * 統一處理失敗信息
     * @param errorMsg
     * @param callBack
     * @param <T>
     */
    private <T> void failedCallBack(final String errorMsg, final ReqCallBack<T> callBack) {
        okHttpHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callBack != null) {
                    callBack.onReqFailed(errorMsg);
                }
            }
        });
    }

小結：基於上述基本上可以實現http之間的網絡通訊，接下來我們來研究如何搞定文件的上傳和下載。具體實現參考（http://www.cnblogs.com/whoislcj/p/5529827.html）