JAVA调用接口简单封装,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() {

@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 ObservableTransformer io_main(){

return new ObservableTransformer() {

@Override

public ObservableSource apply(Observable upstream) {

return upstream.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());

}

};

}

}

使用的方式变为：

apiService.getData()

.compose(RxSchedulerHepler.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 {

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() +

'}';

}

}

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

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 ObservableTransformer, T> handleResult() {

return new ObservableTransformer, T>() {

@Override

public ObservableSource apply(Observable> upstream) {

return upstream.flatMap(new Function, ObservableSource>() {

@Override

public ObservableSource apply(BaseResult 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 implements Consumer {

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 {

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