OKHTTP的封装和一个自定义的日志拦截器

先写一个接口

    void success(T t);
    void filed(Exception e);
}

这里的接口代表了网络请求的成功和失败
之后是网络请求的类

    //单例的静态变量
    private static volatile OkHttpqq mokqq;
    private final Handler mHandler;
    private OkHttpClient mOkhttp;
    //私有构造方法，为了让你的类不能直接new
    private OkHttpqq() {
        //创建一个handler对象
        mHandler = new Handler(Looper.getMainLooper());
        //B.okhttp添加公共参数到拦截器中
        Map<String, String> map = new HashMap<>();
        map.put("", "");
        PublicParameter publicParameter = new PublicParameter(map);
        //创建一个OKHTTP对象
        mOkhttp = new OkHttpClient.Builder()
                .addInterceptor(publicParameter )
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .writeTimeout(5, TimeUnit.SECONDS)
                .build();
    }
    //单例
    public static OkHttpqq getMokqq(){
        if (mokqq==null){
            synchronized (OkHttpqq.class){
                if (mokqq==null){
                    mokqq=new OkHttpqq();
                }
            }
        }
        return mokqq;
    }
    //get请求方法，这里实现了一个接口
    public void doGet(String s, final Call<String> Call){
        //get请求方法
        Request build1 = new Request.Builder().get().url(s).build();
        //成功和失败的方法
        mOkhttp.newCall(build1).enqueue(new Callback() {
            @Override
            public void onFailure(final okhttp3.Call call, final IOException e) {
                if (Call!=null){
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            Call.filed(e);
                        }
                    });
                }
            }

            @Override
            public void onResponse(okhttp3.Call call, Response response) throws IOException {
                final String req = response.body().string();
                if (Call!=null){
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            Call.success(req);
                        }
                    });
                }
            }
        });
    }
    //post请求方法，这里实现了一个接口
    public void doPost(String ss, Map<String ,String> map, final Call<String> call01){
        //这个是请求参数需要的一个对象
        FormBody.Builder builder = new FormBody.Builder();
        if (map!=null){
            for (String user: map.keySet()) {
                builder.add(user,map.get(user));
            }
        }
        FormBody formBody = builder.build();
        //post请求方法
        Request build = new Request.Builder().post(formBody).url(ss).build();
        //成功和失败的方法
        mOkhttp.newCall(build).enqueue(new Callback() {
            @Override
            public void onFailure(final okhttp3.Call call, final IOException e) {
                if (call!=null){
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            call01.filed(e);
                        }
                    });
                }

            }

            @Override
            public void onResponse(okhttp3.Call call, final Response response) throws IOException {
                if (call!=null){
                    final String string = response.body().string();
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            call01.success(string);
                        }
                    });
                }
            }
        });

    }
}

这里封装了get和post的方法。
还有一个日志的拦截器：

 *  日志拦截器类,请求来了,先在这里进行处理,可以得到发请求到得到请求消耗多久的时间
 *  作用:可以排查网络请求速度慢的根本原因
 *  1.有可能是我们在请求网络时,客户端写了一堆业务逻辑
 *  2.有可能是服务器端,写的有问题
 *  3.有可能就是网速不给力
 *
 */
public class PublicParameter implements Interceptor {
    Map<String,String> mParentMap;

    public PublicParameter(Map<String, String> parentMap) {
        mParentMap = parentMap;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        //拿到request
        Request requestFu = chain.request();
        //用request获取网址
        String url = requestFu.url().toString();
        //判断是什么请求方法
        if (requestFu.method().equalsIgnoreCase("Get")){
            //判断集合是否非空
            if (mParentMap!=null && mParentMap.size()>0){
                //获取build对象
                StringBuilder urlBuilder = new StringBuilder(url);
                for(Map.Entry<String,String> user: mParentMap.entrySet()){
                    //进行拼接
                    urlBuilder.append("&"+user.getKey()+"="+user.getValue());
                }
                //获取字符串
                url = urlBuilder.toString();
                //判断是否有?这个字符
                if (!url.contains("?")){
                    //如果没有？就替换一个
                    url= url.replaceFirst("&","?");
                }
                Request build = requestFu.newBuilder().url(url).build();
                return chain.proceed(build);
            }
        }else {
            //判断集合是否非空
            if (mParentMap!=null && mParentMap.size()>0){
                RequestBody requestBody = requestFu.body();
                if (requestBody!=null && requestBody instanceof FormBody){
                    FormBody body = (FormBody) requestBody;
                    //把原来的的body里面的参数添加到新的body中
                    FormBody.Builder form = new FormBody.Builder();
                    //为了防止重复添加相同的key和value
                    HashMap<String,String> hashMap=new HashMap<>();
                    for (int i = 0; i <body.size() ; i++) {
                        form.add(body.encodedName(i),body.encodedValue(i));
                        hashMap.put(body.encodedName(i),body.encodedValue(i));
                    }
                    //添加公共参数
                    for(HashMap.Entry<String,String> user: mParentMap.entrySet() ){
                        if (!hashMap.containsKey(user.getKey())){
                            form.add(user.getKey(),user.getValue());
                        }
                    }
                    FormBody build = form.build();
                    Request request = requestFu.newBuilder().post(build).build();
                    return chain.proceed(request);
                }
            }
        }
        return chain.proceed(requestFu);
    }
}