okhttp3的网络请求工具类

直接上代码：

public class OkHttpUtils {
    private static final String TAG = "OkHttpUtils";
    public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    private static OkHttpUtils mInstance;
    private OkHttpClient mOkHttpClient;
    private Handler mHandler;
    private Context context;


    private OkHttpUtils(){
        //https
        HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        };

        //构建OkHttpClient
        mOkHttpClient = new OkHttpClient.Builder()
                .connectTimeout(10,TimeUnit.SECONDS)
                .writeTimeout(10,TimeUnit.SECONDS)
                .readTimeout(10,TimeUnit.SECONDS)
                .sslSocketFactory(createSSLSocketFactory())
                .hostnameVerifier(DO_NOT_VERIFY)
                .build();
        //允许使用cookie
        //mOkHttpClient.setCookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER));
        //获取主线程的handler
        mHandler = new Handler(Looper.getMainLooper());
    }

    private static 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;
    }


    /**
     * 类的初始化，使用单例模式
     * @return
     */
    public static OkHttpUtils getInstance() {
        if (mInstance == null) {
            synchronized (OkHttpUtils.class) {
                if (mInstance == null) {
                    mInstance = new OkHttpUtils();
                }
            }
        }
        return mInstance;
    }

    /**
     * 构造Get请求
     * @param url  请求的url
     * @param callback  结果回调的方法
     */
    private void getRequest(Context context, String url, LoadingListener callback) {
        this.context = context;
        Request request = new Request.Builder().url(url).build();
        if(null != request) {
            deliveryResult(context, callback, request);
        }
    }

    /**
     * 构造post 请求
     * @param url 请求的url
     * @param callback 结果回调的方法
     * @param jsonParams 请求参数
     */
    private void postRequest(Context context, String url, String jsonParams, LoadingListener callback) {
        this.context = context;
            Request request = buildPostRequest(url, jsonParams);
            if(null != request){
                deliveryResult(context,callback, request);
            }
    }

    /**
     * post请求，不带key关键字的特殊的请求
     * @param url
     * @param callback
     */
    private void postRequestWithoutKey(Context context, String url, LoadingListener callback){
            Request request = buildPostRequestWithOutKey(context,url);
            if(null != request){
                deliveryResult(context,callback,request);
            }
    }


    /**
     * 链接极少数接口时，会出现整体参数加密的情况，此时的参数不能已key-value的形式存在，可调用此接口
     * FormBody在okhttp3.0才有
     * @param url
     * @return
     */
    private Request buildPostRequestWithOutKey(Context context,String url){
        //RequestBody formBody = new FormBody.Builder().build();
        Request request = null;
            Request.Builder builder = new Request.Builder()
                   // .post(formBody)
                    .url(url);
            request = builder.build();
        return  request;
    }

    /**
     * 处理请求结果的回调
     * @param callback
     * @param request
     */
    private void deliveryResult(final Context context, final LoadingListener callback, Request request) {
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if(response.isSuccessful()){
                    try {
                        String str = response.body().string();
                        if(!TextUtils.isEmpty(str)){
                            Log.e("result:",str);
                            sendSuccessCallBack(callback, str);
                        }
                    } catch (final Exception e) {
                        Log.e( "convert json failure",e.getMessage());
                        sendFailCallback(callback, e);
                    }
                }else{
                    Log.e("error:",response.body().string());
                }
            }
        });
    }

    /**
     * 发送失败的回调
     * @param callback
     * @param e
     */
    private void sendFailCallback( final LoadingListener callback, final Exception e) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callback != null) {
                    callback.onFailure(e);
                }
            }
        });
    }

    /**
     * 发送成功的回调
     * @param callback
     * @param obj
     */
    private void sendSuccessCallBack(final LoadingListener callback, final String obj) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callback != null) {
                    callback.onSuccess(obj);
                }
            }
        });
    }

    /**
     * 构造post请求
     * @param url  请求url
     * @param jsonParams 请求的参数
     * @return 返回 Request
     */
    private Request buildPostRequest(String url, String jsonParams) {
        Log.e("请求URL：",url);
        RequestBody body = RequestBody.create(JSON ,jsonParams);
        Log.e("请求参数：",jsonParams);
        Request request = new Request.Builder().post(body).url(url).build();
        return  request;

    }



    /**********************对外接口************************/

    /**
     * get请求
     * @param url  请求url
     * @param callback  请求回调
     */
    public static boolean get(Context context, String url, LoadingListener callback) {
        if(!NetworkUtil.isNetworkConnected(context)){
            MyToast.getInstance(context).showShort(R.string.network_is_not_available);
            return false;
        }else{
            getInstance().getRequest(context,url, callback);
            return  true;
        }

    }

    /**
     * post请求
     * @param url       请求url
     * @param callback  请求回调
     * @param jsonParams    请求参数
     */
    public static void post(Context context, String url, String jsonParams, LoadingListener callback) {
        getInstance().postRequest(context,url, jsonParams,callback);
    }

    /**
     * post请求
     * @param url       请求url
     * @param callback  请求回调
     */
    public static boolean postWithOutKey(Context context, String url, final LoadingListener callback) {
        if(!NetworkUtil.isNetworkConnected(context)){
            MyToast.getInstance(context).showShort(R.string.network_is_not_available);
            return false;
        }else{
            getInstance().postRequestWithoutKey(context,url, callback);
            return  true;
        }

    }

    /**
     * 下载文件
     * @param file 文件保存文件
     * @param url 下载路径
     *
     * @param uiProgressListener
     */
    public boolean download( File file,String sdPath ,String fileName,final String url, UIProgressListener uiProgressListener, final FileDownPathCallBack callBack){

        //构造请求
        final Request request1 = new Request.Builder()
                .addHeader("Accept-Encoding", "identity")
                .url(url)
                .build();

        //包装Response使其支持进度回调
        ProgressHelper.addProgressResponseListener(mOkHttpClient, uiProgressListener).newCall(request1).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response){
                InputStream is = null;
                byte[] buf = new byte[2048];
                int len = 0;
                FileOutputStream fos = null;
                try {
                    long total = response.body().contentLength();
                    Log.e(TAG, "total------>" + total);
                    long current = 0;
                    is = response.body().byteStream();
                    fos = new FileOutputStream(file);
                    while ((len = is.read(buf)) != -1) {
                        current += len;
                        fos.write(buf, 0, len);
                        Log.e(TAG, "current------>" + current);
                    }
                    fos.flush();
                    callBack.path(sdPath+File.separator+fileName);
                } catch (IOException e) {
                    Log.e(TAG, e.toString());
                } finally {
                    try {
                        if (is != null) {
                            is.close();
                        }
                        if (fos != null) {
                            fos.close();
                        }
                    } catch (IOException e) {
                        Log.e(TAG, e.toString());
                    }
                }

            }

        });
        return false;
    }


}

使用实例：
在其他类中调用post方法发起网络请求：
其中Urls.CONFIG_MUSIC_PLAY是一个网络请求地址
gson.toJson(userConfigParams)是把实体类UserConfigParams转化为json数据，

  OkHttpUtils.post(context, Urls.CONFIG_MUSIC_PLAY, gson.toJson(userConfigParams), new LoadingListener() {
            @Override
            public void onSuccess(String json) {
                Log.e("接口返回成功",json);
                HandlerMessageUtils.sendSucMsg(handler, ResultCode.RESULT_SUC_CODE,json);
            }

            @Override
            public void onFailure(Exception e) {

            }

            @Override
            public void onEmpty() {

            }
        });

其中使用时要声明

 private Gson gson = new Gson();
 private UserConfigParams userConfigParams;

定义一个回调接口

public interface LoadingListener {
    void onSuccess(String json);
    void onFailure(Exception e);
    void onEmpty();
}