Retrofit+rxjava的封装

前言 基于以下参考进行改良封装

一、接入前准备，将下面的依赖导入工程里面

    implementation 'io.reactivex.rxjava2:rxjava:2.1.0'
    // 必要rxjava2依赖
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
    // 必要rxandrroid依赖，切线程时需要用到
    implementation 'com.squareup.retrofit2:retrofit:2.3.0'
    // 必要retrofit依赖
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
    // 必要依赖，和Rxjava结合必须用到，
    implementation 'com.squareup.retrofit2:converter-gson:2.3.0'
    // 必要依赖，解析json字符所用
    
    //非必要依赖， log依赖，如果需要打印OkHttpLog需要添加
    implementation 'com.squareup.okhttp3:logging-interceptor:3.8.1'
    //  gson转换工厂
    implementation 'com.google.code.gson:gson:2.8.5'

二、Retrofit使用讲解（网上许多参考故略）

三、工程结构图

结构图

四、封装流程

1. 进行Retrofit的封装

• 单例化Retrofit管理类
• 初始化okhttp
• 初始化retrofit

  private static final String CACHE_PATH = "httpCache";
    public static final long CACHE_SIZE = 1024 * 1024 * 100;
    public static final int TIMEOUT = 15; //超时时间
    private static volatile RetrofitManager mInstance;
    private Retrofit mRetrofit; //retorfit对象
    private OkHttpClient mOkhttpClient; //okhttp对象
    private ServerApi api; //生成接口类

   //单利化
    public static ServerApi getServerApi() {
        if (mInstance == null) {
            synchronized (RetrofitManager.class) {
                if (mInstance == null) {
                    mInstance = new RetrofitManager();
                }
            }
        }
        return mInstance.api;
    }


    /**
     * 构造器中初始化okhttp和retrofit
     */
    private RetrofitManager() {
        initOkhttp();//初始化okhttp 
        initRetrofit(); //初始retrofit
    }

    /**
     * 初始化retrofit
     */
    private void initRetrofit() {
        mRetrofit = new Retrofit.Builder()
                .baseUrl(CommonConstant.BASE_URL)
                .addConverterFactory(CustomGsonFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .client(mOkhttpClient)
                .build();
        api = mRetrofit.create(ServerApi.class);
    }

    /**
     * 初始化okhttp
     *
     * @return
     */
    private void initOkhttp() {
        //头部参数拦截器
        HeaderParamsInterceptor commonParamsInterceptor = new HeaderParamsInterceptor();
        //日志参数拦截器
        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        //关联相应的拦截器
        interceptor.setLevel(CommonConstant.IS_DEBUG ? HttpLoggingInterceptor.Level.BODY : HttpLoggingInterceptor.Level.NONE);
        
        if (mOkhttpClient == null) {
            synchronized ((RetrofitManager.class)) {
                if (mOkhttpClient == null) {
                //增加缓存
                    Cache cache = new Cache(new File(MyApplication.getInstance().getCacheDir(), CACHE_PATH), CACHE_SIZE);
                    mOkhttpClient = new OkHttpClient.Builder()
                            .cache(cache)
                            .addInterceptor(interceptor)
                            .addInterceptor(commonParamsInterceptor)
//                            .retryOnConnectionFailure(true)
                            .connectTimeout(TIMEOUT, TimeUnit.SECONDS)
                            .build();
                }
            }
        }
    }


    /**
     * 用于创建相关类
     *
     * @param clazz
     * @param 
     * @return
     */
    public  T create(Class clazz) {
        if (mRetrofit != null) {
            return mRetrofit.create(clazz);
        }
        return null;
    }

2.根据要求封装请求基类，响应基类，以及错误基类

• 请求基类，由于我们请求会将请求参数放在请求体中，然后通过json数据传给服务器

public class BaseRequest {
    
    private T options;
    
    public T getOptions() {
        return options;
    }

    public void setOptions(T options) {
        this.options = options;
    }
}

• 响应基类，一般情况会有msg ,code,data这三个字段

public class BaseResponse {
    @SerializedName(value = "code", alternate = "status")
    private int code; //返回码
    private T data; //具体数据结果
    private String msg; //返回信息
    
    public int getCode() {
        return code;
    }

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

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

}

• 错误基类，可以根据实际情况来，我们接口的请求放在errorbody中，故可以这样处理，但是如果放在response中通过这就需要灵活处理这个数据，防止类造型错误。

public class FailureBody {
    private List data;
    @SerializedName(value = "code",alternate = "status")
    private int code;
    private String msg;
    

    public List getData() {
        return data;
    }

    public void setData(List data) {
        this.data = data;
    }

    public int getCode() {
        return code;
    }

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

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

3.Observable的生成

• 通过ObjectNetLoader这个类，简化相应的线程切换
• 通过继承的NetDataLoader这个类生成相应的Observable对象

public class ObjectLoader {
    /**
     * 用于封装相关
     * @param observable
     * @param 
     * @return
     */
    protected    Observable observer(Observable observable){
        return observable.subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }
}


/**
 * 用于对数据提前处理，同时也可用来对参数处理
 * 例如合并，map ,zip或者flateMap这样可以将不符合自己参数的数据转换为自己想请求的参数
 * 这一层是属于module内，用于处理数据源，供给presenter作为中间纽带进行调用
 */
public class NetDataLoader extends ObjectLoader {
    private ServerApi api;
    private NetDataLoader() {
        api = RetrofitManager.getServerApi();
    }
    public static NetDataLoader loader;
    public static NetDataLoader get() {
        if (loader == null) {
            synchronized (NetDataLoader.class) {
                if (loader == null) {
                    loader = new NetDataLoader();
                }
            }
        }
        return loader;
    }
    /*******************************请求数据*****************************************/

    /************************************用户**************************************/
    //用用户信息登录
    public Observable> postUserLogin(ReqUserLogin bean) {
        return observer(api.postUserLogin(getRequestBody(bean))); //请求参数的初步处理
    }
    
    /***********************请求数据modle类*************************************/
    //用于对请求数据model修改为json数据
    private  BaseRequest getRequestBody(T data) {
        if (data == null)
            return null;
        BaseRequest requestBody = new BaseRequest<>();
        requestBody.setOptions(data);
        return requestBody;
    }

}

• observer的生成，自定义Myobserver，既可以作为回调（供MVP中module回调接口），也可以作为单独使用。

/**
 * @param 
 */
public abstract class MyObserver implements io.reactivex.Observer> {
    
    private Disposable d;

    @Override
    public void onSubscribe(Disposable d) {
        SubscriptionManager.newStance().add(d);//提前添加相应的Disposable
        this.d = d;
        onDisposable(d);
    }

    @Override
    public void onNext(BaseResponse response) {
        if (response.getCode() == 200) {//通过200说明请求成功
            onSuccess(response);
        }
        SubscriptionManager.newStance().cancel(d);
    }

    @Override
    public void onError(Throwable e) {
        onFail(ExceptionHandle.handleException(e));
        SubscriptionManager.newStance().cancel(d);

    }

    @Override
    public void onComplete() {
        onCompleted();
        SubscriptionManager.newStance().cancel(d);

    }

    public abstract void onSuccess(BaseResponse t);

    public abstract void onFail(ExceptionHandle.ResponseThrowable throwable);

    public abstract void onCompleted();

    public abstract void onDisposable(Disposable d);

}

4.Rxjava相关管理，防止发生内存泄漏

• 用于管理Rxjava，及时的取消订阅，防止出现泄漏等情况（包括了Helper,以及管理类）

/**
 * 订阅监听器帮助类
 * @param 
 */
public interface SubscriptionHelper {
    void add(Disposable disposable); //添加
    void cancel(Disposable t); //取消
    void cancelAll(); //取消所有订阅
}

public class SubscriptionManager implements SubscriptionHelper