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

最新推荐文章于 2024-03-27 22:22:22 发布

sutonline

最新推荐文章于 2024-03-27 22:22:22 发布

阅读量420

点赞数

分类专栏： Android 文章标签： mvp

Android 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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&lt;TestBean&gt;() {
     @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 RxSchedulerHelper {

    public static <T> ObservableTransformer<T, T> io_main() {
        return upstream -> upstream.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }
}

使用的方式变为:
apiService.getData() .compose(RxSchedulerHepler.<TestBean>io_main())

Step 3对请求结果的封装

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

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


    @Data
    public class Bean{

        private String icon;
    }
}

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

public class RxResultCompat {

    public static <T> ObservableTransformer<Result<T>, T> convert() {
        return upstream -> upstream.flatMap(tResult -> {
            if (tResult == null) {
                return Observable.error(new BizException("结果不能为空"));
            }

            if (Objects.equals(tResult.getCode(), ResultTypeEnum.ERROR.getCode())) {
                return Observable.error(new BizException("返回结果不正确"));
            }

            return Observable.just(tResult.getT());
        });
    }
}

使用泛型指定我们想要的数据类型，对于错误码，可以添加你们定义的规则
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对请求结果的预处理

针对错误码定义异常

@EqualsAndHashCode(callSuper = true)
@Data
public class BizException extends RuntimeException {

    private String code;
    private String displayMessage;

    public BizException(String message) {
        super(message);
    }

    public BizException(String code, String displayMessage) {
        this.code = code;
        this.displayMessage = displayMessage;
    }

    public BizException(String message, String code, String displayMessage) {
        super(message);
        this.code = code;
        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 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 {
            try {
                Log.e(TAG, "发生了异常," + t.getMessage());
                onError.accept(t);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}

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

public RxExceptionHandler( Consumer&lt;? super Throwable&gt; 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 的封装

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

    private static String TAG = "RxExceptionHandler";
    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 {
            try {
                Log.e(TAG, "发生了异常," + t.getMessage());
                onError.accept(t);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}

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

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

个人注:

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

sutonline

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mvp+Retrofit2+RxJava2 项目中使用的简洁封装

Mvp+Retrofit2+RxJava2 项目中使用的简洁封装Retrofit2 + RxJava2 是一个强大的组合，完成一系列网络请求 MVP当前用的很多的一种框架，Model+View+Presenter 本文记录了作者在项目中对 Retrofit2 + RxJava2+Mvp 使用的一些封装为什么要封装 ?未封装版，正常的Retrofit 代码```OkHttpClient mOkH
复制链接

扫一扫