android okhttp+RxJava+retrofit网络请求框架封装

android okhttp+RxJava+retrofit网络请求框架封装

android开发中,网络请求是必不可少的开发模块，所以对于网络请求的框架和封装在开发中就显得尤为重要,今天我这里就大概的描述下okhttp+rxJava+retrofit三者相结合网络请求的封装

一.okhttp+RxJava+Retrofit请求框架集成

在app的build.gradle中加入如下依赖

    implementation 'com.squareup.retrofit2:adapter-rxjava:2.2.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.0.0-beta3'
    implementation 'com.squareup.okhttp3:logging-interceptor:3.4.1'
    implementation 'com.squareup.okhttp3:okhttp:3.4.1'
    implementation 'io.reactivex:rxjava:1.1.9'
    implementation 'io.reactivex:rxandroid:1.2.1'

截图信息如下:

二.大致需要封装的五个类

这里为了描述的比较清晰,我这边大致把封装分为以下几个类来做描述,所需的类有以下五个：

1. BaseReponse ，统一接口返回的数据基类,其中results的类型是泛型,用于接收具体的数据类；

 * 接口返回的实体基类
 * @param <T>
 */
public class BaseReponse<T> {
    private static int SUCCESS_CODE=200;//成功的code
    private int code;                   //响应码
    private String message;             //提示信息
    private T results;                  //返回的具体数据
    public boolean isSuccess(){
        return getCode()==SUCCESS_CODE;
    }
    public static int getSuccessCode() {
        return SUCCESS_CODE;
    }

    public static void setSuccessCode(int successCode) {
        SUCCESS_CODE = successCode;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public T getResults() {
        return results;
    }

    public void setResults(T results) {
        this.results = results;
    }

    @Override
    public String toString() {
        return "BaseReponse{" +
                "code=" + code +
                ", message='" + message + '\'' +
                ", results=" + results +
                '}';
    }
}

2. InterceptorUtil ,主要是一个拦截器工具类,用于日志拦截和添加头部相关信息

 * 工具拦截器
 */
public class InterceptorUtil {
    public static final String TAG="------";
    public static HttpLoggingInterceptor LogInterceptor() {     //日志拦截器,用于打印返回请求的结果
        return new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                Log.w(TAG,"log:"+message);
            }
        }).setLevel(HttpLoggingInterceptor.Level.BODY);
    }

    public static Interceptor HeaderInterceptor(){      //头部添加请求头信息
        return new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request request=chain.request().newBuilder().
                addHeader("Content-Type","application/json;charSet=UTF-8").build();
                return chain.proceed(request);
            }
        };
    }
}

3. ApiServise ,它是接口的形式,主要用于封装get、post等请求方法,这里用到retrofit2的注解；

 * 请求方法类
 */
public interface ApiServise {
    //https://api.apiopen.top/musicDetails?id=604392760  接口完整路径
    /**
     * get请求方式
     * @Query
     * 形成单个查询参数, 将接口url中追加类似于"page=1"的字符串,形成提交给服务器端的参数,
     * 主要用于Get请求数据，用于拼接在拼接在url路径后面的查询参数，一个@Query相当于拼接一个参数
     */
    String HOST = "https://api.apiopen.top";        //接口地址
    @GET("/musicDetails")
    Observable<BaseReponse<List<MeiZiResponse>>> getMeiZi(@Query("id") String id);

    /**
     * post请求方式
     */
    @FormUrlEncoded         //post请求必须要申明该注解
    @POST("musicDetails")   //方法名
    Observable<BaseReponse<List<MeiZiResponse>>> getInfo(@Field("id") String data);//请求参数
}

具体的注解说明可以参考以下链接:(转自简述 宁_593066063的博客)
Retrofit2中常用的注解介绍
4. BaseObserver ,它主要是请求成功失败、网络异常时的回调,它实现的Observer类,其中成功失败主要在Onext方法里处理；

 * 请求回调,主要实现Observer类
 * @param <T>
 */
public abstract class BaseObserver<T> implements Observer<BaseReponse<T>> {
    private Context mContext;

    public BaseObserver(Context mContext) {
        this.mContext = mContext;
    }

    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {
        if (e instanceof ConnectException ||
                e instanceof TimeoutException ||
                e instanceof NetworkErrorException ||
                e instanceof UnknownHostException) {
            try {
                onFailure(e, false);
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        } else {
            try {
                onFailure(e, true);
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    }

    @Override
    public void onNext(BaseReponse<T> tBaseReponse) {
        if (tBaseReponse.isSuccess()) {
            onSuccess(tBaseReponse);
        } else {
            onCodeError(tBaseReponse);
        }
    }
	//请求成功且返回码为200的回调方法,这里抽象方法申明
    public abstract void onSuccess(BaseReponse<T> tBaseReponse);
    
   //请求成功但返回的code码不是200的回调方法,这里抽象方法申明
    public abstract void onCodeError(BaseReponse tBaseReponse);
    
   //请求失败回调方法,这里抽象方法申明
    public abstract void onFailure(Throwable e, boolean netWork) throws Exception;
}

5. BaseRequest ,主要获取okhttp、retrofit的实例,然后再通过retrofit的实例获取ApiServise的实例

 * 通过初始化okhttp和retrofit,获取ApiServise的实例
 * 主要做retrofit绑定okhttp,然后通过retrofit的实例
 * 获取ApiServise的实例
 */
public class BaseRequest {
    //初始化Okhttp,绑定拦截器事件
    OkHttpClient client=new OkHttpClient.Builder().
            connectTimeout(20, TimeUnit.SECONDS).                   //设置请求超时时间
            readTimeout(20,TimeUnit.SECONDS).                       //设置读取数据超时时间
            writeTimeout(20,TimeUnit.SECONDS).                      //设置写入数据超时时间
            addInterceptor(InterceptorUtil.LogInterceptor()).                //绑定日志拦截器
            addNetworkInterceptor(InterceptorUtil.HeaderInterceptor())       //绑定header拦截器
            .build();

    Retrofit retrofit=new Retrofit.Builder().
            addConverterFactory(GsonConverterFactory.create()).             //设置gson转换器,将返回的json数据转为实体
            addCallAdapterFactory(RxJavaCallAdapterFactory.create()).       //设置CallAdapter
            baseUrl(ApiServise.HOST).
            client(client)                                                  //设置客户端okhttp相关参数
            .build();


    public static BaseRequest instance;
    public ApiServise apiServise=retrofit.create(ApiServise.class);         //通过retrofit的实例,获取ApiServise接口的实例

    private BaseRequest(){

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

    public ApiServise getApiServise(){
        return apiServise;
    }
}

6. 调用方式的实现

     * 调用网络请求方法
     */
    public void getData() {
        BaseRequest.getInstance().getApiServise().getMeiZi("604392760").subscribeOn(Schedulers.io()).
                observeOn(AndroidSchedulers.mainThread()).subscribe(new BaseObserver<List<MeiZiResponse>>(this) {
            @Override
            public void onSuccess(BaseReponse<List<MeiZiResponse>> t) {
		    //成功回调方法,可以直接在此更新ui,AndroidSchedulers.mainThread()表示切换到主线程
            }

            @Override
            public void onCodeError(BaseReponse baseReponse) {
            //失败回调方法,可以直接在此更新ui,AndroidSchedulers.mainThread()表示切换到主线程
            }

            @Override
            public void onFailure(Throwable e, boolean netWork) throws Exception {

            }
        });
    }

MeiZiResponse这个类我是随便定义的一个实体类,也没有跟返回的数据字段做一个映射,这里只是单纯的描述okhttp+RxJava+Retrofit网络封装,所以这里我就没有贴出来了.大致按照这五个步骤来,基本上就把网络请求这块的封装做好了.如下是我觉得还不错的几篇讲解okhttp+RxJava+Retrofit的博客,有需要的请自行查阅。
1.Retrofit各个注解的含义及作用
2.RxJava2.0——从放弃到入门
3.打造终极MVP+Retrofit2+okhttp3+Rxjava2网络请求,开发实用,简约