Mvp+Retrofit2+RxJava2 项目中使用的简洁封装

Retrofit2 + RxJava2 是一个强大的组合，完成一系列网络请求

MVP当前用的很多的一种框架，Model+View+Presenter

本文记录了作者在项目中对 Retrofit2 + RxJava2+Mvp 使用的一些封装

为什么要封装 ?

未封装版，正常的Retrofit 代码

OkHttpClient mOkHttpClient = new OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.addInterceptor(new HttpParamInterceptor())
.cookieJar(new CookieJarImpl(new PersistentCookieStore(this)))
.build();

Retrofit mRetrofit = new Retrofit.Builder()
.baseUrl(Contacts.BASE_URL)
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(FastJsonConvertFactory.create())
.client(mOkHttpClient).build();

ApiService apiService = mRetrofit.create(ApiService.class);

apiService.getData()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<TestBean>() {
@Override
public void onSubscribe(@NonNull Disposable d) {

}

@Override
public void onNext(@NonNull TestBean testBean) {
TestBean.Bean data = testBean.getData();
String icon = data.getIcon();
}

@Override
public void onError(@NonNull Throwable e) {

}

@Override
public void onComplete() {

}
});

可能你发现确是代码有点多，但是更加可怕的是，如果你一个activity或者fragment中多次需要http请求，你需要多次重复的写回调处理（一个回调就有4个方法呀！！！！反正我是忍受不了），而且以上处理还没有做过多的判断和错误校验就如此复杂！如果不封装，简直...

封装方案

Step 1 封装ApiService 的创建

在实际项目中基本都是用的同一个BaseUrl ，这里对ApiService 的创建进行了封装，单例

public class RetrofitClient {

private static RetrofitClient instance;

private OkHttpClient mOkHttpClient;

private Context mContext;

private Retrofit mRetrofit;

private ApiService mApiService;

private RetrofitClient(Context context) {
this.mContext = context;
}

public static RetrofitClient getInstance(Context context) {
if (instance == null) {
instance = new RetrofitClient(context);
}
return instance;
}

private OkHttpClient provideOkHttpClient() {
if (mOkHttpClient == null) {
mOkHttpClient = new OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.addInterceptor(new HttpParamInterceptor())  //公共参数的封装
.cookieJar(new CookieJarImpl(new PersistentCookieStore(mContext))) //cookie 保存方案
.build();
}

return mOkHttpClient;
}

private Retrofit provideRetrofit() {

if (mRetrofit == null) {
mRetrofit = new Retrofit.Builder()
.baseUrl(Contacts.BASE_URL)
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())   //RxJava2 的CallAdapter
.addConverterFactory(FastJsonConvertFactory.create())       // FastJsonConvertFactory
.client(provideOkHttpClient()).build();
}

return mRetrofit;
}

public ApiService provideApiService() {
if (mApiService == null) {
mApiService = provideRetrofit().create(ApiService.class);
}
return mApiService;
}
}

以上就是 对ApiService 创建过程的封装，构建Rrtrofit 时候使用了 自定义的FastJsonConvertFactory,可以参考
FastJsonConverter ,至于为什么使用它，虽然Retrofit 官方推荐使用的是GsonConverter,这个下文 Step3有讲到

Step 2 对线程切换进行包装

每次订阅都要执行

.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

这两行代码，可以进行简化一番，这里就用到了RxJava 2 的ObservableTransformer **(注意: 这个类在RxJava1 版本中是 Observable.Transformer 内部类的形式) **

public class RxSchedulerHepler {

public static <T> ObservableTransformer<T,T> io_main(){
return new ObservableTransformer<T, T>() {
@Override
public ObservableSource<T> apply(Observable<T> upstream) {
return  upstream.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
}
};
}
}

使用的方式变为：

apiService.getData()
.compose(RxSchedulerHepler.<TestBean>io_main())

Step 3对请求结果的封装

可以看到最初的返回结果是 TestBean类型，TestBean的结构大体如下：

public class TestBean {
private int status;
private String info;
private  Bean data;

public int getStatus() {
return status;
}

public void setStatus(int status) {
this.status = status;
}

public String getInfo() {
return info;
}

public void setInfo(String info) {
this.info = info;
}

public Bean getData() {
return data;
}

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

@Override
public String toString() {
return "BaseResult{" +
"status=" + status +
", info='" + info + '\'' +
", data=" + data.toString() +
'}';
}
public class Bean{

private String icon;

public String getIcon() {
return icon;
}

public void setIcon(String icon) {
this.icon = icon;
}
}
}

相信很多人的接口返回格式都是这样，如果每次请求都要创建这样的类结构，简直可怕，要把注意力放在 里面实体Bean ，那才是我们真正想要的数据，接下来对结果进行封装

public class BaseResult<T> {

public static final int SUCCESS = 1;
public static final int ERROR = 1000;
private int status;
private String info;
private T data;
public boolean isSuccess() {
return (status == SUCCESS);
}
public int getStatus() {
return status;
}

public void setStatus(int status) {
this.status = status;
}

public String getInfo() {
return info;
}

public void setInfo(String info) {
this.info = info;
}

public T getData() {
return data;
}

public void setData(T data) {
this.data = data;
}
@Override
public String toString() {
return "BaseResult{" +
"status=" + status +
", info='" + info + '\'' +
", data=" + data.toString() +
'}';
}
}

使用泛型<T>指定 我们想要的数据类型，对于 错误码，可以添加你们定义的规则

Step1中提到了为什么要用FastJson ,要知道在某些情况下后台返回的数据时有问题的，并不是那么完美的直接就能Gson解析拿来用(虽然我对这种情况很不爽)。

如果存在这样的返回数据 例如：{"1":"value"} 这时你想换成String回来自己手动解析，

这时候使用Gson就会产生如下的异常：

com.google.gson.JsonSyntaxException: java.lang.IllegalStateException: Expected a string but was BEGIN_OBJECT at line 1

这时候就该我们自定义的FastJsonConverter上场了。

Step 4对请求结果的预处理

针对错误码定义异常

public class BaseException extends Exception {
private String code;
private String displayMessage;
public BaseException(String code, String displayMessage) {
this.code = code;
this.displayMessage = displayMessage;
}

public BaseException(String message, String code, String displayMessage) {
super(message);
this.code = code;
this.displayMessage = displayMessage;
}

public String getCode() {
return code;
}

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

public String getDisplayMessage() {
return displayMessage;
}

public void setDisplayMessage(String displayMessage) {
this.displayMessage = displayMessage;
}
}

对请求结果处理

public class RxResultCompat {
public static <T> ObservableTransformer<BaseResult<T>, T> handleResult() {
return new ObservableTransformer<BaseResult<T>, T>() {
@Override
public ObservableSource<T> apply(Observable<BaseResult<T>> upstream) {
return upstream.flatMap(new Function<BaseResult<T>, ObservableSource<T>>() {
@Override
public ObservableSource<T> apply(BaseResult<T> tBaseResult) throws Exception {
int status = tBaseResult.getStatus();
tBaseResult.getStatus();
if (tBaseResult.isSuccess()) {
return Observable.just(tBaseResult.getData());
} else if (status == BaseResult.ERROR) {
return Observable.error(new BaseException(tBaseResult.getStatus() + "", tBaseResult.getInfo()));
}
//这里可以增加一些 错误码的处理
return Observable.empty();
}
});
}
};
}
}

Step 5 对异常的统一处理

public class RxExceptionHandler<T extends Throwable> implements Consumer<T> {

private static String TAG = "RxExceptionHandler";

private static final String TIMEOUT_EXCEPTION = "网络连接超时，请检查您的网络状态，稍后重试";
private static final String CONNECT_EXCEPTION = "网络连接异常，请检查您的网络状态";
private static final String JSON_EXCEPTION = "数据获取异常";
private static final String UNKNOWN_HOST_EXCEPTION = "网络异常，请检查您的网络状态";

private static final String TOKEN_EXCEPTION = "身份信息验证失败！";

private Consumer<? super Throwable> onError;

public RxExceptionHandler( Consumer<? super Throwable> onError) {
this.onError = onError;
}

@Override
public void accept(T t) {
t.printStackTrace();
if (t instanceof SocketTimeoutException) {
Log.e(TAG, "onError: SocketTimeoutException---");

} else if (t instanceof ConnectException) {
Log.e(TAG, "onError: CONNECT_EXCEPTION---");

} else if (t instanceof UnknownHostException) {
Log.e(TAG, "onError: UNKNOWN_HOST_EXCEPTION---");

} else if (t instanceof JSONException) {
Log.e("TAG", "onError: JSON_EXCEPTION");

} else if (t instanceof BaseException) {
Log.e("TAG", "onError: TokenException");

} else if (t instanceof TokenErrorException) {

} else {
try {
onError.accept(t);
} catch (Exception e) {
e.printStackTrace();
}
}
}

}

可能会对这里的构造器有疑问

public RxExceptionHandler( Consumer<? super Throwable> onError) {
this.onError = onError;
}

这么处理的缘由来自RxJava 的升级

在RxJava1版本中 subscribe()方法订阅传入 Subscriber并且会返回一个Subscription 对象，并且我们可以使用该对象来解除订阅，通常我们会用一个 CompositeSubscription 来管理订阅和解除订阅，
RxJava升级到 RxJava2版本之后 原来的Subscriber换成了Observer 、Subscription 换成了Disposable 、同时 subscribe()方法传入observer 不再有返回值 ，而subscribe(Consumer ... )则返回Disposable对象
所以这里采用继承Consumer 的方式，并传递一个Consumer 去处理未知的异常

Step 6 MVP模式下 对Presenter 的封装

在Mvp 模式下,Presenter 作为一个管理者的角色存在,在这里进行对网络请求的RxJava处理

public abstract class BasePresenter<M, V extends BaseView> {

private CompositeDisposable disposables;// 管理Destroy取消订阅者者

protected M mModel;
protected V mView;

protected Context mContext;

public BasePresenter(V view) {
mView = view;
initContext(view);
mModel = createModel();
}

protected void initContext(V view) {
if (view instanceof Activity) {
//Activity
mContext = (Activity) view;
} else {
mContext = ((Fragment) view).getActivity();
}

}

public boolean addRx(Disposable disposable) {
if (disposables == null) {
disposables = new CompositeDisposable();
}
disposables.add(disposable);
return true;
}

public Context getContext() {
return mContext;
}

protected abstract M createModel();

public void detachView() {
if (disposables != null) {
disposables.dispose();
disposables = null;
}
}

}

在请求网络时，视同addRx方法 ，将Disposable添加到 CompositeDisposable 中，便于解除订阅释放资源

文章转自Mvp+Retrofit2+RxJava2 项目中使用的简洁封装

个人注:

1. Observable的compose可以接受一个ObservableTransformer对upstream进行转换.
2. 在使用Gson的时候反序列泛型是有点问题，使用FastJson正常