ok请求封装：OkHttpClientManager

 okhttp-2.7.5.jar

okio-1.6.0.jar

/**
 * 请求管理类
 * 创建于 2018/7/5 by OkHttpClientManager
 */
public class OkHttpClientManager {

    private static OkHttpClientManager mInstance;
    private OkHttpClient mOkHttpClient;

    private OkHttpClientManager() {
        mOkHttpClient = new OkHttpClient();
        mOkHttpClient.setConnectTimeout(10, TimeUnit.SECONDS);
        mOkHttpClient.setWriteTimeout(10, TimeUnit.SECONDS);
        mOkHttpClient.setReadTimeout(30, TimeUnit.SECONDS);
        mOkHttpClient.setCookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER));
    }

    public static OkHttpClientManager getInstance() {
        if (mInstance == null) {
            synchronized (OkHttpClientManager.class) {
                if (mInstance == null) {
                    mInstance = new OkHttpClientManager();
                }
            }
        }
        return mInstance;
    }

    /**
     * 异步的get请求
     *
     * @param url
     * @param params
     * @param callback
     */
    public void getObject(String url, Map<String, Object> params, ResultCallback<JSONObject> callback) {
        if (StringUtils.isEmpty(url)){
            return;
        }
        String newUrl = attachHttpGetParams(url, params);
        Request request = new Request.Builder()
                .addHeader( "Content-Type","application/json; charset=UTF-8")
                .url(newUrl).get().build();
        deliveryObjectResult(callback, request);
    }

    /**
     * 异步的get请求
     *
     * @param url
     * @param params
     * @param callback
     */
    public void getArray(String url, Map<String, Object> params, ResultCallback<JSONArray> callback) {
        if (StringUtils.isEmpty(url)){
            return;
        }
        String newUrl = attachHttpGetParams(url, params);
        Request request = new Request.Builder().url(newUrl)
                .addHeader( "Content-Type","application/json; charset=UTF-8")
                .get().build();
        deliveryArrayResult(callback, request);
    }

    private String attachHttpGetParams(String url, Map<String, Object> params) {
        Set<String> strings = params.keySet();
        ArrayList<String> keys = new ArrayList<>(strings);
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("?");
        for (int i = 0; i < keys.size(); i++) {
            String keyString = keys.get(i);
            String key = null;
            try {
                key = URLEncoder.encode(keyString, "utf-8");
            } catch (UnsupportedEncodingException e) {
            }
            Object o = params.get(keyString);
            String value = "";
            if (o != null) {
                try {
                    value = URLEncoder.encode(o.toString(), "utf-8");
                } catch (UnsupportedEncodingException e) {
                }
            }
            stringBuffer.append(key).append("=").append(value);
            if (i != params.size() - 1) {
                stringBuffer.append("&");
            }
        }
        return url + stringBuffer.toString();
    }

    /**
     * 异步的post请求
     *
     * @param url
     * @param params
     * @param callback
     */
    public void postObject(String url, Map<String, Object> params, ResultCallback<JSONObject> callback) {
        if (StringUtils.isEmpty(url)){
            return;
        }
        JSONObject jsonObject = new JSONObject(params);
        Request request = new Request.Builder().url(url)
                .addHeader( "Content-Type","application/json; charset=UTF-8")
                .post(createBody(jsonObject.toString())).build();
        deliveryObjectResult(callback, request);
    }

    /**
     * 异步的post请求
     */
    public void postArray(String url, Map<String, Object> params, ResultCallback<JSONArray> callback) {
        if (StringUtils.isEmpty(url)){
            return;
        }
        JSONObject jsonObject = new JSONObject(params);
        Request request = new Request.Builder().url(url)
                .addHeader( "Content-Type","application/json; charset=UTF-8")
                .post(createBody(jsonObject.toString())).build();
        deliveryArrayResult(callback, request);
    }

    private RequestBody createBody(final String params) {
        ByteString content = ByteString.of(params.getBytes());
        return new RequestBody() {
            public MediaType contentType() {
                return MediaType.parse("application/json");
            }

            public long contentLength() throws IOException {
                return (long) content.size();
            }

            public void writeTo(BufferedSink sink) throws IOException {
                sink.write(content);
            }
        };
    }

    /**
     * 请求回调处理方法并传递返回值
     *
     * @param callback Map类型请求参数
     * @param request  Request请求
     */
    private void deliveryObjectResult(ResultCallback<JSONObject> callback, Request request) {
        System.out.println(request.toString());
        callback.onBefore(request);
        Callback responseCallback = new Callback() {
            @Override
            public void onFailure(final Request request, final IOException e) {
                MainHandler.getInstance().post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onAfter();
                        callback.onError(request, e);
                    }
                });
            }

            @Override
            public void onResponse(final Response response) {
                MainHandler.getInstance().post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onAfter();
                        final String responseBody;
                        try {
                            responseBody = response.body().string();
                            JSONObject jsonObject = RequestHttpResponse.parseJsonObjectResponse(responseBody);
                            if (jsonObject != null) {
                                callback.onResponse(jsonObject);
                            } else {
                                callback.onError(request, RequestHttpResponse.parseCodeAndMsg(responseBody));
                            }
                        } catch (IOException e) {
                            callback.onError(request, e);
                        }
                    }
                });
            }
        };
        mOkHttpClient.newCall(request).enqueue(responseCallback);
    }

    /**
     * 请求回调处理方法并传递返回值
     *
     * @param callback Map类型请求参数
     * @param request  Request请求
     */
    private void deliveryArrayResult(ResultCallback<JSONArray> callback, Request request) {
        callback.onBefore(request);
        Callback responseCallback = new Callback() {
            @Override
            public void onFailure(final Request request, final IOException e) {
                MainHandler.getInstance().post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onAfter();
                        callback.onError(request, e);
                    }
                });
            }
            @Override
            public void onResponse(final Response response) {
                MainHandler.getInstance().post(new Runnable() {
                    @Override
                    public void run() {
                        callback.onAfter();
                        try {
                            final String responseBody = response.body().string();
                            JSONArray jsonArray = RequestHttpResponse.parseJsonArrayResponse(responseBody);
                            if (jsonArray != null) {
                                callback.onResponse(jsonArray);
                            } else {
                                callback.onError(request, RequestHttpResponse.parseCodeAndMsg(responseBody));
                            }
                        } catch (IOException e) {
                            callback.onError(request, e);
                        }
                    }
                });
            }
        };
        mOkHttpClient.newCall(request).enqueue(responseCallback);
    }
}