OKHttp 二次封装

OKhttp 大家并不陌生。目前用起来最好用的网络请求框架

okhttp+mvp 用来更爽，有时候请求失败需要多次请求的时候，就需要做特俗处理，这里就直接风格装起来，

先看看get的调用方法

GetHttpRequestRunnable runnable = new GetHttpRequestRunnable(requestUrl, new RequestBackListener() {

    @Override
    public void requestSuccess(String json) {
      
    }

    @Override
    public void requestFailed(String errorDesc) {
        autoLoginView.showWaitDialog(false);
       
    }
});
Thread thread = new Thread(runnable);
thread.start();

是不是看起来很简单，返回的两个方法可以直接进行UI更新操作，返回的两个方法直接在主线程

如果又多次去请求的需求怎么办？别着急，初始化的添加int数字，就是如果请求失败的话的继续请求的次数

GetHttpRequestRunnable runnable = new GetHttpRequestRunnable(requestUrl,10， new RequestBackListener() {

    @Override
    public void requestSuccess(String json) {
      
    }

    @Override
    public void requestFailed(String errorDesc) {
        autoLoginView.showWaitDialog(false);
       
    }
});
Thread thread = new Thread(runnable);
thread.start();

post请求方法如此类推，举个例子

RequestBody requestBodyPost = new FormBody.Builder()
        .add("id", deviceId)
        .add("username", "tam")
        .add("password", "888888")
        .build();
PostRequestRunnable runnable = new PostRequestRunnable(requestUrl,requestBodyPost, new RequestBackListener() {
    @Override
    public void requestSuccess(String json) {
      
    }

    @Override
    public void requestFailed(String errorDesc) {
      
    }
});
Thread thread = new Thread(runnable);
thread.start();

直接看完整代码把，

package com.mirror.http;

/**
 * Created by jsjm on 2018/1/9.
 */

public interface RequestBackListener {

    void requestSuccess(String json);

    void requestFailed(String errorDesc);

}

两个监听接口

package com.mirror.http;


/***
 * 网络请求接口
 */
public interface RequeatListener {
    void requestSuccess(String json);

    void requestFailed(String errorDesc);
}

get原始封装

package com.mirror.http;

import android.util.Log;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

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

/**
 * Created by cdl
 */

public class MyOkHttpUtil {

    public static final String TAG = "MyOkHttpUtil";
    String requestUrl;
    OkHttpClient mOkHttpClient;
    int requestMaxNum;//当前请求的最大次数
    int requestNum = 0;  //当前请求的次数
    RequeatListener requeatListener;


    public MyOkHttpUtil(String requestUrl, int requestMaxNum) {
        this.requestUrl = requestUrl;
        this.requestMaxNum = requestMaxNum;
    }

    public void getRequestInfo(RequeatListener listener) {
        this.requeatListener = listener;
        Log.e(TAG, "===url:" + requestUrl);
        try {
            if (mOkHttpClient == null) {
                mOkHttpClient = new OkHttpClient.Builder()
                        .connectTimeout(10, TimeUnit.SECONDS)
                        .readTimeout(10, TimeUnit.SECONDS)
                        .build();
            }
            final Request request = new Request.Builder().url(requestUrl).build();
            Call call = mOkHttpClient.newCall(request);
            call.enqueue(new Callback() {
                @Override
                public void onFailure(Call arg0, IOException arg1) {
                    if (requestNum > requestMaxNum) {
                        requestNum = 0;
                        requeatListener.requestFailed(arg1.toString());
                    } else {
                        getRequestInfo(requeatListener);
                    }
                    requestNum++;
                    Log.i(TAG, "===网络请求失败==" + arg1.toString());
                }

                @Override
                public void onResponse(Call arg0, Response response)
                        throws IOException {
                    String json = response.body().string();
                    requeatListener.requestSuccess(json);
                }
            });
        } catch (Exception e) {
            Log.i(TAG, "===网络请求异常==" + e.toString());
            listener.requestFailed(e.toString());
        }
    }


}

get上层封装，这里直接实现runnable,直接运行在子线程，为什么要集成runnable>不jichengThread,了解线程池的同学一笑而过，这里不做多的解释，

package com.mirror.http;


import android.os.Handler;
import android.util.Log;

/***
 * get网络请求
 */
public class GetHttpRequestRunnable implements Runnable, RequeatListener {

    String requestUrl;
    MyOkHttpUtil myOkHttpUtil;
    final String TAG = "http";
    RequestBackListener listener;
    private Handler handler = new Handler();

    public GetHttpRequestRunnable(String requestUrl, RequestBackListener listener) {
//        Log.e(TAG, "请求的网址===" + requestUrl);
//        this.requestUrl = requestUrl;
//        this.listener = listener;
//        myOkHttpUtil = new MyOkHttpUtil(requestUrl);
        getRequestRunnable(requestUrl, 1, listener);
    }

    public GetHttpRequestRunnable(String requestUrl, int requestNum, RequestBackListener listener) {
        getRequestRunnable(requestUrl, requestNum, listener);
    }

    /***
     *
     * @param requestUrl
     * 请求的网址
     * @param requestNum
     * 请求失败，重复请求的次数
     * @param listener
     */
    public void getRequestRunnable(String requestUrl, int requestNum, RequestBackListener listener) {
        Log.e(TAG, "请求的网址===" + requestUrl);
        this.requestUrl = requestUrl;
        this.listener = listener;
        myOkHttpUtil = new MyOkHttpUtil(requestUrl, requestNum);
    }

    @Override
    public void run() {
        myOkHttpUtil.getRequestInfo(this);
    }

    @Override
    public void requestSuccess(final String json) {
        Log.e(TAG, "===修改密码返回的结果:" + json);
        handler.post(new Runnable() {
            @Override
            public void run() {
                listener.requestSuccess(json);
            }
        });
    }

    @Override
    public void requestFailed(final String errorDesc) {
        handler.post(new Runnable() {
            @Override
            public void run() {
                listener.requestFailed(errorDesc);
            }
        });
    }
}

post网络请求，底层封装

package com.mirror.http;

import android.util.Log;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

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

/***
 * post请求模板
 */
public class PostHttpRequest {

    private static final String TAG = "postHttp";
    OkHttpClient mOkHttpClient;
    RequestBody requestBodyPost;
    String url;

    public PostHttpRequest(String url, RequestBody requestBodyPost) {
        Log.i(TAG, "==请求的URL==" + url);
        this.url = url;
        this.requestBodyPost = requestBodyPost;
    }

    public void querybindInfo(final RequeatListener listener) {
        try {
            if (mOkHttpClient == null) {
                mOkHttpClient = new OkHttpClient.Builder()
                        .connectTimeout(10, TimeUnit.SECONDS)
                        .readTimeout(10, TimeUnit.SECONDS)
                        .build();
            }
            Request requestPost = new Request.Builder().url(url)
                    .post(requestBodyPost).build();
            mOkHttpClient.newCall(requestPost).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    listener.requestFailed(e.toString());
                    Log.i(TAG, "==post请求失败==" + e.toString());
                }

                @Override
                public void onResponse(Call call, Response response)
                        throws IOException {
                    String htmlStr = response.body().string();
                    Log.i(TAG, "====post请求成功==" + htmlStr);
                    listener.requestSuccess(htmlStr);
                }
            });
        } catch (Exception e) {
            listener.requestFailed(e.toString());
            Log.i(TAG, "==post请求异常==" + e.toString());
        }
    }

}

post线程封装

package com.mirror.http;

import android.os.Handler;
import android.util.Log;

import okhttp3.RequestBody;

public class PostRequestRunnable implements Runnable, RequeatListener {

    private static final String TAG = "http";
    String requestUrl;
    PostHttpRequest postHttpRequest;
    RequestBackListener listener;
    private Handler handler = new Handler();

    public PostRequestRunnable(String requestUrl, RequestBody requestBodyPost, RequestBackListener listener) {
        this.requestUrl = requestUrl;
        this.listener = listener;
        postHttpRequest = new PostHttpRequest(requestUrl, requestBodyPost);
    }

    @Override
    public void run() {
        postHttpRequest.querybindInfo(this);
    }

    @Override
    public void requestSuccess(final String json) {
        handler.post(new Runnable() {
            @Override
            public void run() {
                listener.requestSuccess(json);
            }
        });

    }

    @Override
    public void requestFailed(final String errorDesc) {
        handler.post(new Runnable() {
            @Override
            public void run() {
                listener.requestFailed(errorDesc);
                Log.e(TAG, "===获取房间详情=====" + errorDesc);
            }
        });
    }
}

猜你喜欢