簡單封裝了okhttp3的工具類以便於以後直接拿來使用。

使用的okhttp版本為：

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

該工具類的功能如下：

• Get請求，同步方式獲取網路資料
• Post請求，同步方式獲取資料
• Get請求，非同步方式獲取網路資料
• Post請求，非同步方式獲取資料
• 支援HTTPS請求，自動跳過證書驗證
• 判斷當前網路是否可用

其中Post請求提交的是鍵值對<String,String>

1. 完整程式碼

import android.content.Context;
import android.net.ConnectivityManager;
import
 
 android.net.NetworkInfo;
import android.util.Log;

import java.io.IOException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import javax.net.ssl.HostnameVerifier;
import
 
 javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import
 
 okhttp3.Response;

/**
 * Created by fxjzzyo on 2017/7/12.
 */

public class NetUtils {
    private static final byte[] LOCKER = new byte[0];
    private static NetUtils mInstance;
    private OkHttpClient mOkHttpClient;

    private NetUtils() {
        okhttp3.OkHttpClient.Builder ClientBuilder=new okhttp3.OkHttpClient.Builder();
        ClientBuilder.readTimeout(20, TimeUnit.SECONDS);//讀取超時
        ClientBuilder.connectTimeout(6, TimeUnit.SECONDS);//連線超時
        ClientBuilder.writeTimeout(60, TimeUnit.SECONDS);//寫入超時
        //支援HTTPS請求，跳過證書驗證
        ClientBuilder.sslSocketFactory(createSSLSocketFactory());
        ClientBuilder.hostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        });
        mOkHttpClient=ClientBuilder.build();
    }

    /**
     * 單例模式獲取NetUtils
     * @return
     */
    public static NetUtils getInstance() {
        if (mInstance == null) {
            synchronized (LOCKER) {
                if (mInstance == null) {
                    mInstance = new NetUtils();
                }
            }
        }
        return mInstance;
    }

    /**
     * get請求，同步方式，獲取網路資料，是在主執行緒中執行的，需要新起執行緒，將其放到子執行緒中執行
     * @param url
     * @return
     */
    public  Response getDataSynFromNet(String url) {
        //1 構造Request
        Request.Builder builder = new Request.Builder();
        Request request=builder.get().url(url).build();
        //2 將Request封裝為Call
        Call call = mOkHttpClient.newCall(request);
        //3 執行Call，得到response
        Response response = null;
        try {
            response = call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return response;
    }
    /**
     * post請求，同步方式，提交資料，是在主執行緒中執行的，需要新起執行緒，將其放到子執行緒中執行
     * @param url
     * @param bodyParams
     * @return
     */
    public  Response postDataSynToNet(String url,Map<String,String> bodyParams) {
        //1構造RequestBody
        RequestBody body=setRequestBody(bodyParams);
        //2 構造Request
        Request.Builder requestBuilder = new Request.Builder();
        Request request = requestBuilder.post(body).url(url).build();
        //3 將Request封裝為Call
        Call call = mOkHttpClient.newCall(request);
        //4 執行Call，得到response
        Response response = null;
        try {
            response = call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return response;
    }
    /**
     * 自定義網路回撥介面
     */
    public interface MyNetCall{
        void success(Call call, Response response) throws IOException;
        void failed(Call call, IOException e);
    }

    /**
     * get請求，非同步方式，獲取網路資料，是在子執行緒中執行的，需要切換到主執行緒才能更新UI
     * @param url
     * @param myNetCall
     * @return
     */
    public  void getDataAsynFromNet(String url, final MyNetCall myNetCall) {
        //1 構造Request
        Request.Builder builder = new Request.Builder();
        Request request=builder.get().url(url).build();
        //2 將Request封裝為Call
        Call call = mOkHttpClient.newCall(request);
        //3 執行Call
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                myNetCall.failed(call,e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                myNetCall.success(call,response);

            }
        });
    }

    /**
     * post請求，非同步方式，提交資料，是在子執行緒中執行的，需要切換到主執行緒才能更新UI
     * @param url
     * @param bodyParams
     * @param myNetCall
     */
    public  void postDataAsynToNet(String url, Map<String,String> bodyParams, final MyNetCall myNetCall) {
        //1構造RequestBody
        RequestBody body=setRequestBody(bodyParams);
        //2 構造Request
        Request.Builder requestBuilder = new Request.Builder();
        Request request = requestBuilder.post(body).url(url).build();
        //3 將Request封裝為Call
        Call call = mOkHttpClient.newCall(request);
        //4 執行Call
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                myNetCall.failed(call,e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                myNetCall.success(call,response);

            }
        });
    }
    /**
     * post的請求引數，構造RequestBody
     * @param BodyParams
     * @return
     */
    private RequestBody setRequestBody(Map<String, String> BodyParams){
        RequestBody body=null;
        okhttp3.FormBody.Builder formEncodingBuilder=new okhttp3.FormBody.Builder();
        if(BodyParams != null){
            Iterator<String> iterator = BodyParams.keySet().iterator();
            String key = "";
            while (iterator.hasNext()) {
                key = iterator.next().toString();
                formEncodingBuilder.add(key, BodyParams.get(key));
                Log.d("post http", "post_Params==="+key+"===="+BodyParams.get(key));
            }
        }
        body=formEncodingBuilder.build();
        return body;

    }

    /**
     * 判斷網路是否可用
     * @param context
     * @return
     */
    public static boolean isNetworkAvailable(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm == null) {
        } else {
      //如果僅僅是用來判斷網路連線
      //則可以使用cm.getActiveNetworkInfo().isAvailable();
            NetworkInfo[] info = cm.getAllNetworkInfo();
            if (info != null) {
                for (int i = 0; i < info.length; i++) {
                    if (info[i].getState() == NetworkInfo.State.CONNECTED) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    /**
     * 生成安全套接字工廠，用於https請求的證書跳過
     * @return
     */
    public SSLSocketFactory createSSLSocketFactory() {
        SSLSocketFactory ssfFactory = null;
        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, new TrustManager[]{new TrustAllCerts()}, new SecureRandom());
            ssfFactory = sc.getSocketFactory();
        } catch (Exception e) {
        }
        return ssfFactory;
    }
    /**
     * 用於信任所有證書
     */
    class TrustAllCerts implements X509TrustManager {
        @Override
        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
        }
        @Override
        public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

        }
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    }
}

2. 用法舉例

推薦使用非同步請求，因為已經把網路請求自動放到子執行緒了，用起來稍簡單。而同步請求還需要自己new Thread+handler來做，幾乎和原始的網路請求沒區別了。因此這裡舉例就只舉非同步請求了。

非同步GET請求

點選按鈕登入

  public void login(View view) {
  final String account = etAccount.getText().toString();
  final String pass = etPassword.getText().toString();
  if (account.isEmpty() || pass.isEmpty()) {
    Toast.makeText(this, "使用者名稱或密碼不能為空！", Toast.LENGTH_SHORT).show();
           return;
       }
       if(!Global.isNetAvailable)
       {
           Toast.makeText(this, "網路不可用！", Toast.LENGTH_SHORT).show();
           return;
       }
       //進度條
       loginProgress.setVisibility(View.VISIBLE);
       //獲取網路工具類例項
       NetUtils netUtils = NetUtils.getInstance();
       //請求網路，一句程式碼搞定
       netUtils.getDataAsynFromNet(Global.LOGIN + "?username=" + account + "&password=" + pass,
               new NetUtils.MyNetCall() {
                   @Override
                   public void success(Call call, Response response) throws IOException {
                       Log.i("tag", "success");
                       String result = response.body().string();
                       final ResponseBean responseBean = JSON.parseObject(result, ResponseBean.class);

                       if (responseBean != null) {
                           runOnUiThread(new Runnable() {
                               @Override
                               public void run() {
                                   loginProgress.setVisibility(View.GONE);
                                   String errcode = responseBean.getErrcode();
                                   if (errcode.equals("0")) {//登入成功
                                       //記錄學號
                                       Global.account = account;
                                       //儲存使用者名稱密碼
                                       saveUserName(account, pass);

                                       Intent intent = new Intent(LoginActivity.this, MainActivity.class);
                                       startActivity(intent);
                                       LoginActivity.this.finish();
                                   } else {
                                       Toast.makeText(LoginActivity.this, "請求失敗！錯誤程式碼： " + errcode, Toast.LENGTH_SHORT).show();
                                   }

                               }
                           });

                       }
                   }

                   @Override
                   public void failed(Call call, IOException e) {
                       Log.i("tag", "failed");
                       runOnUiThread(new Runnable() {
                           @Override
                           public void run() {
                               loginProgress.setVisibility(View.GONE);
                               Toast.makeText(LoginActivity.this, "請求失敗！", Toast.LENGTH_SHORT).show();
                           }
                       });
                   }
               }

       );

   }

非同步POST請求

點選按鈕，提交資料

public void postSelect() {
        //確保選擇了樓號
        if (tvTargetBuilding.getText().toString().isEmpty()) {
            Toast.makeText(getActivity(),"請選擇樓號！",Toast.LENGTH_SHORT).show();
            return;
        }
        //構造請求引數
        Map<String, String> reqBody = new ConcurrentSkipListMap<>();
        reqBody.put("num", "1");
        reqBody.put("stuid", Global.account);
        reqBody.put("buildingNo", selectBuilding + "");
        //獲取網路請求工具類例項
        NetUtils netUtils = NetUtils.getInstance();
        //提交資料
        netUtils.postDataAsynToNet(Global.SELECT_ROOM, reqBody, new NetUtils.MyNetCall() {
            @Override
            public void success(Call call, Response response) throws IOException {
                Log.i("tag", "success");
                String result = response.body().string();
                Log.i("tag", "result: " + result);
                //解析資料
                JSONObject jsonObject1 = JSON.parseObject(result);
                if (jsonObject1 != null) {
                    final int error_code = jsonObject1.getIntValue("error_code");

                    getActivity().runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Log.i("tag", "errcode: " + error_code);
                            if (error_code == 0) {//提交成功
                                Toast.makeText(getActivity(), "選擇成功！", Toast.LENGTH_SHORT).show();
                                //跳轉到selectSuccessfragment
                                MainActivity.mainActivityInstance.switchFragment(getParentFragment(),SelectSuccessFragment.newInstance("", ""));
                            } else {
                                Toast.makeText(getActivity(), "選擇失敗！錯誤程式碼： " + error_code, Toast.LENGTH_SHORT).show();
                            }

                        }
                    });

                }
            }
            @Override
            public void failed(Call call, IOException e) {
                Log.i("tag", "failed");
                getActivity().runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(getActivity(), "請求失敗！", Toast.LENGTH_SHORT).show();
                    }
                });
            }
        });

    }

什麼？還嫌程式碼太長？

其實很短的，除去註釋和列印的日誌以及一些不相干的部分（我這裡的是一個實際的專案，所以涉及到一些其他的東西），你會發現程式碼很少，核心的程式碼就是一句。（這時候你可能要說，哼，是一句，但一句有十多行。。。拜託~不要那麼懶啦好不好 -_-|||）

要注意的是獲取資料後，更新UI要在主執行緒中。我這裡使用的是runOnUiThread也可以用Handler。

用Handler後你會發現這一部分的程式碼很少了，因為只需要把獲取的資料用Message傳送到Handler處理就好了，這樣就把程式碼分散開了

用runOnUiThread的好處是很直接，不過看起來程式碼都堆到一起，其實很方便的。

完結，撒花~