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

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

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

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

为什么要封装 ?

未封装版，正常的Retrofit 代码

1. 
   
2. OkHttpClient mOkHttpClient = new OkHttpClient.Builder()
3. .connectTimeout(10, TimeUnit.SECONDS)
4. .readTimeout(10, TimeUnit.SECONDS)
5. .addInterceptor(new HttpParamInterceptor())
6. .cookieJar(new CookieJarImpl(new PersistentCookieStore(this)))
7. .build();
9. Retrofit mRetrofit = new Retrofit.Builder()
10. .baseUrl(Contacts.BASE_URL)
11. .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
12. .addConverterFactory(FastJsonConvertFactory.create())
13. .client(mOkHttpClient).build();
16. ApiService apiService = mRetrofit.create(ApiService.class);
18. apiService.getData()
19. .subscribeOn(Schedulers.io())
20. .observeOn(AndroidSchedulers.mainThread())
21. .subscribe(new Observer<TestBean>() {
22. @Override
23. public void onSubscribe(@NonNull Disposable d) {
25. }
27. @Override
28. public void onNext(@NonNull TestBean testBean) {
29. TestBean.Bean data = testBean.getData();
30. String icon = data.getIcon();
31. }
33. @Override
34. public void onError(@NonNull Throwable e) {
36. }
38. @Override
39. public void onComplete() {
41. }
42. });

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

封装方案

Step 1 封装ApiService 的创建

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

1. 
   
2. public class RetrofitClient {
5. private static RetrofitClient instance;
7. private OkHttpClient mOkHttpClient;
10. private Context mContext;
12. private Retrofit mRetrofit;
14. private ApiService mApiService;
16. private RetrofitClient(Context context) {
17. this.mContext = context;
18. }
20. public static RetrofitClient getInstance(Context context) {
21. if (instance == null) {
22. instance = new RetrofitClient(context);
23. }
24. return instance;
25. }
28. private OkHttpClient provideOkHttpClient() {
29. if (mOkHttpClient == null) {
30. mOkHttpClient = new OkHttpClient.Builder()
31. .connectTimeout(10, TimeUnit.SECONDS)
32. .readTimeout(10, TimeUnit.SECONDS)
33. .addInterceptor(new HttpParamInterceptor()) //公共参数的封装
34. .cookieJar(new CookieJarImpl(new PersistentCookieStore(mContext))) //cookie 保存方案
35. .build();
36. }
39. return mOkHttpClient;
40. }
43. private Retrofit provideRetrofit() {
45. if (mRetrofit == null) {
46. mRetrofit = new Retrofit.Builder()
47. .baseUrl(Contacts.BASE_URL)
48. .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) //RxJava2 的CallAdapter
49. .addConverterFactory(FastJsonConvertFactory.create()) // FastJsonConvertFactory
50. .client(provideOkHttpClient()).build();
51. }
53. return mRetrofit;
54. }
56. public ApiService provideApiService() {
57. if (mApiService == null) {
58. mApiService = provideRetrofit().create(ApiService.class);
59. }
60. return mApiService;
61. }
62. }

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

Step 2 对线程切换进行包装

每次订阅都要执行

1. 
   
2. .subscribeOn(Schedulers.io())
4. .observeOn(AndroidSchedulers.mainThread())

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

1. 
   
2. public class RxSchedulerHepler {
4. public static <T> ObservableTransformer<T,T> io_main(){
5. return new ObservableTransformer<T, T>() {
6. @Override
7. public ObservableSource<T> apply(Observable<T> upstream) {
8. return upstream.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
9. }
10. };
11. }
12. }

使用的方式变为：

1. 
   
2. apiService.getData()
3. .compose(RxSchedulerHepler.<TestBean>io_main())

Step 3对请求结果的封装

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

1. 
   
2. public class TestBean {
3. private int status;
4. private String info;
5. private Bean data;
7. public int getStatus() {
8. return status;
9. }
11. public void setStatus(int status) {
12. this.status = status;
13. }
15. public String getInfo() {
16. return info;
17. }
19. public void setInfo(String info) {
20. this.info = info;
21. }
23. public Bean getData() {
24. return data;
25. }
27. public void setData(Bean data) {
28. this.data = data;
29. }
31. @Override
32. public String toString() {
33. return "BaseResult{" +
34. "status=" + status +
35. ", info='" + info + '\'' +
36. ", data=" + data.toString() +
37. '}';
38. }
39. public class Bean{
41. private String icon;
43. public String getIcon() {
44. return icon;
45. }
47. public void setIcon(String icon) {
48. this.icon = icon;
49. }
50. }
51. }

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

1. 
   
2. public class BaseResult<T> {
4. public static final int SUCCESS = 1;
5. public static final int ERROR = 1000;
6. private int status;
7. private String info;
8. private T data;
9. public boolean isSuccess() {
10. return (status == SUCCESS);
11. }
12. public int getStatus() {
13. return status;
14. }
16. public void setStatus(int status) {
17. this.status = status;
18. }
20. public String getInfo() {
21. return info;
22. }
24. public void setInfo(String info) {
25. this.info = info;
26. }
28. public T getData() {
29. return data;
30. }
32. public void setData(T data) {
33. this.data = data;
34. }
35. @Override
36. public String toString() {
37. return "BaseResult{" +
38. "status=" + status +
39. ", info='" + info + '\'' +
40. ", data=" + data.toString() +
41. '}';
42. }
43. }

使用泛型<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对请求结果的预处理

针对错误码定义异常

1. 
   
2. public class BaseException extends Exception {
3. private String code;
4. private String displayMessage;
5. public BaseException(String code, String displayMessage) {
6. this.code = code;
7. this.displayMessage = displayMessage;
8. }
10. public BaseException(String message, String code, String displayMessage) {
11. super(message);
12. this.code = code;
13. this.displayMessage = displayMessage;
14. }
16. public String getCode() {
17. return code;
18. }
20. public void setCode(String code) {
21. this.code = code;
22. }
24. public String getDisplayMessage() {
25. return displayMessage;
26. }
28. public void setDisplayMessage(String displayMessage) {
29. this.displayMessage = displayMessage;
30. }
31. }

对请求结果处理

1. 
   
2. public class RxResultCompat {
3. public static <T> ObservableTransformer<BaseResult<T>, T> handleResult() {
4. return new ObservableTransformer<BaseResult<T>, T>() {
5. @Override
6. public ObservableSource<T> apply(Observable<BaseResult<T>> upstream) {
7. return upstream.flatMap(new Function<BaseResult<T>, ObservableSource<T>>() {
8. @Override
9. public ObservableSource<T> apply(BaseResult<T> tBaseResult) throws Exception {
10. int status = tBaseResult.getStatus();
11. tBaseResult.getStatus();
12. if (tBaseResult.isSuccess()) {
13. return Observable.just(tBaseResult.getData());
14. } else if (status == BaseResult.ERROR) {
15. return Observable.error(new BaseException(tBaseResult.getStatus() + "", tBaseResult.getInfo()));
16. }
17. //这里可以增加一些 错误码的处理
18. return Observable.empty();
19. }
20. });
21. }
22. };
23. }
24. }

Step 5 对异常的统一处理

1. 
   
2. public class RxExceptionHandler<T extends Throwable> implements Consumer<T> {
4. private static String TAG = "RxExceptionHandler";
7. private static final String TIMEOUT_EXCEPTION = "网络连接超时，请检查您的网络状态，稍后重试";
8. private static final String CONNECT_EXCEPTION = "网络连接异常，请检查您的网络状态";
9. private static final String JSON_EXCEPTION = "数据获取异常";
10. private static final String UNKNOWN_HOST_EXCEPTION = "网络异常，请检查您的网络状态";
12. private static final String TOKEN_EXCEPTION = "身份信息验证失败！";
14. private Consumer<? super Throwable> onError;
18. public RxExceptionHandler( Consumer<? super Throwable> onError) {
19. this.onError = onError;
20. }
22. @Override
23. public void accept(T t) {
24. t.printStackTrace();
25. if (t instanceof SocketTimeoutException) {
26. Log.e(TAG, "onError: SocketTimeoutException---");
28. } else if (t instanceof ConnectException) {
29. Log.e(TAG, "onError: CONNECT_EXCEPTION---");
31. } else if (t instanceof UnknownHostException) {
32. Log.e(TAG, "onError: UNKNOWN_HOST_EXCEPTION---");
34. } else if (t instanceof JSONException) {
35. Log.e("TAG", "onError: JSON_EXCEPTION");
37. } else if (t instanceof BaseException) {
38. Log.e("TAG", "onError: TokenException");
40. } else if (t instanceof TokenErrorException) {
42. } else {
43. try {
44. onError.accept(t);
45. } catch (Exception e) {
46. e.printStackTrace();
47. }
48. }
49. }
51. }

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

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

这么处理的缘由来自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处理

1. 
   
2. public abstract class BasePresenter<M, V extends BaseView> {
4. private CompositeDisposable disposables;// 管理Destroy取消订阅者者
6. protected M mModel;
7. protected V mView;
9. protected Context mContext;
11. public BasePresenter(V view) {
12. mView = view;
13. initContext(view);
14. mModel = createModel();
15. }
17. protected void initContext(V view) {
18. if (view instanceof Activity) {
19. //Activity
20. mContext = (Activity) view;
21. } else {
22. mContext = ((Fragment) view).getActivity();
23. }
25. }
27. public boolean addRx(Disposable disposable) {
28. if (disposables == null) {
29. disposables = new CompositeDisposable();
30. }
31. disposables.add(disposable);
32. return true;
33. }
35. public Context getContext() {
36. return mContext;
37. }
39. protected abstract M createModel();
42. public void detachView() {
43. if (disposables != null) {
44. disposables.dispose();
45. disposables = null;
46. }
47. }
50. }

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