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 中，便于解除订阅释放资源
