OkhttpClient工具类

public class OkHttpUtils {
    private String baseUrl = "https://monitor.api.qcloud.com/";
    private static OkHttpClient mOkHttpClient;
    private Request.Builder requestBuilder;
    private String url;
    private Map<String, String> querys = new HashMap<String, String>();

    private OkHttpUtils() {
        if (mOkHttpClient == null) {
            OkHttpClient.Builder ClientBuilder = new OkHttpClient.Builder();
            // 读取超时
            ClientBuilder.readTimeout(40, TimeUnit.SECONDS);
            // 连接超时
            ClientBuilder.connectTimeout(60, TimeUnit.SECONDS);
            // 写入超时
            ClientBuilder.writeTimeout(50, TimeUnit.SECONDS);
            mOkHttpClient = ClientBuilder.build();
            mOkHttpClient.dispatcher().setMaxRequests(1200);
            mOkHttpClient.dispatcher().setMaxRequestsPerHost(2000);
        }
        requestBuilder = new Request.Builder();
    }

    /**
     * 新建一个请求
     *
     * @return
     */
    public static OkHttpUtils getInstance() {
        return new OkHttpUtils();
    }

    /**
     * 请求相对地址
     *
     * @param path
     * @return
     */
    public OkHttpUtils path(String path) {
        this.url = baseUrl + path;
        return this;
    }

    /**
     * 请求完整绝对地址
     *
     * @param url
     * @return
     */
    public OkHttpUtils url(String url) {
        this.url = url;
        return this;
    }

    /**
     * 标记get请求
     *
     * @return
     */
    public OkHttpUtils get() {
        requestBuilder.get();
        return this;
    }

    /**
     * 无body参数post请求
     *
     * @return
     */
    public OkHttpUtils post() {
        requestBuilder.post(RequestBody.create(MediaType.parse("application/json"), ""));
        return this;
    }

    /**
     * 带body参数
     *
     * @param body
     *            MultipartBody,FormBody....
     * @return
     */
    public OkHttpUtils post(RequestBody body) {
        requestBuilder.post(body);
        return this;
    }

    /**
     * 添加头信息
     *
     * @param name
     *            键
     * @param value
     *            值
     * @return
     */
    public OkHttpUtils addHeader(String name, String value) {
        requestBuilder.addHeader(name, value);
        return this;
    }

    /**
     * 添加多个头信息
     *
     * @param headers
     * @return
     */
    public OkHttpUtils addHeaders(Map<String, String> headers) {
        if (headers != null) {
            for (String name : headers.keySet()) {
                requestBuilder.addHeader(name, headers.get(name));
            }
        }
        return this;
    }

    /**
     * 添加query信息
     *
     * @param querys
     *            queryMap
     * @return
     */
    public OkHttpUtils addQuerys(Map<String, String> querys) {
        if (querys != null) {
            this.querys.putAll(querys);
        }
        return this;
    }

    /**
     * 添加query信息
     *
     * @param name
     *            键
     * @param value
     *            值
     * @return
     */
    public OkHttpUtils addQuery(String name, String value) {
        this.querys.put(name, value);
        return this;
    }

    /**
     * 缓存信息
     *
     * @param cacheControl
     * @return
     */
    public OkHttpUtils cacheControl(CacheControl cacheControl) {
        requestBuilder.cacheControl(cacheControl);
        return this;
    }

    /**
     * 同步执行
     *
     * @return
     */
    public Response execute() {
        try {
            for (String name : querys.keySet()) {
                if (url.contains("?")) {
                    url += "&" + name + "=" + URLEncoder.encode(querys.get(name), "UTF-8");
                } else {
                    url += "?" + name + "=" + URLEncoder.encode(querys.get(name), "UTF-8");
                }
            }
            return mOkHttpClient.newCall(requestBuilder.url(url).build()).execute();
        } catch (IOException e) {
            return null;
        }
    }

    public void enqueue(Callback callback) {
        try {
            for (String name : querys.keySet()) {
                if (url.contains("?")) {
                    url += "&" + name + "=" + URLEncoder.encode(querys.get(name), "UTF-8");
                } else {
                    url += "?" + name + "=" + URLEncoder.encode(querys.get(name), "UTF-8");
                }
            }
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        if (callback == null) {
            callback = Callback.CALLBACK_DEFAULT;
        }
        final Callback finalCallback = callback;
        mOkHttpClient.newCall(requestBuilder.url(url).build()).enqueue(new okhttp3.Callback() {

            public void onFailure(Call call, IOException e) {
                sendFailResultCallback(call, e, finalCallback);
            }

            public void onResponse(Call call, Response response) throws IOException {
                try {
                    if (call.isCanceled()) {
                        sendFailResultCallback(call, new IOException("Canceled!"), finalCallback);
                        return;
                    }
                    if (!finalCallback.validateReponse(response)) {
                        sendFailResultCallback(call, new IOException("请求失败，响应代码是: " + response.code()), finalCallback);
                        return;
                    }
                    Object o = finalCallback.parseNetworkResponse(response);
                    sendSuccessResultCallback(o, finalCallback);
                } catch (IOException e) {
                    sendFailResultCallback(call, e, finalCallback);
                } finally {
                    if (response.body() != null)
                        response.body().close();
                }
            }
        });
    }

    public void sendFailResultCallback(final Call call, final IOException e, final Callback callback) {
        if (callback == null)
            return;
        callback.onFailure(call, e);
    }

    public void sendSuccessResultCallback(final Object object, final Callback callback) {
        if (callback == null)
            return;
        callback.onResponse(object);
    }

    /**
     * 封装的GET请求(加在url后)
     */
    public static void gett(String path, Callback callback) {
        new OkHttpUtils().path(path).get().enqueue(callback);
    }
    
    /**
     * 封装的GET请求(加在url后)(同步)
     */
    public static Response gett(String path) {
        return new OkHttpUtils().path(path).get().execute();
    }

    /**
     * 封装的GET请求
     */
    public static void get(String path, Map<String, String> querys, Callback callback) {
        new OkHttpUtils().path(path).get().addQuerys(querys).enqueue(callback);
    }

    /**
     * 封装的GET请求(同步)
     * 
     * @return
     */
    public static Response get(String path, Map<String, String> querys) {
        return new OkHttpUtils().path(path).get().addQuerys(querys).execute();
    }

    /**
     * 封装的POST请求（发送字符串）
     */
    public static void postString(String path, String data, Callback callback) {
        new OkHttpUtils().path(path).post(RequestBody.create(MediaType.parse("application/json"), data))
                .enqueue(callback);
    }

    /**
     * 封装的POST请求（发送form）
     */
    public static void postForm(String path, Map<String, String> formData, Callback callback) {
        MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM);
        for (String name : formData.keySet()) {
            builder.addFormDataPart(name, formData.get(name));
        }
        new OkHttpUtils().path(path).post(builder.build()).enqueue(callback);
    }

    /**
     * 封装的POST请求（发送字符串）(同步)
     */
    public static Response postString(String path, String data) {
        return new OkHttpUtils().path(path).post(RequestBody.create(MediaType.parse("application/json"), data))
                .execute();
    }

}