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

2017-08-16 本文已影响626人写代码的解先生

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 项目中使用的简洁封装

为什么要封装 ?

未封装版，正常的Retrofit 代码

封装方案

Step 1 封装ApiService 的创建

Step 2 对线程切换进行包装

Step 3对请求结果的封装

Step 4对请求结果的预处理

针对错误码定义异常

对请求结果处理

Step 5 对异常的统一处理

Step 6 MVP模式下对Presenter 的封装

猜你喜欢

热点阅读

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

为什么要封装 ?

未封装版，正常的Retrofit 代码

封装方案

Step 1 封装ApiService 的创建

Step 2 对线程切换进行包装

Step 3对请求结果的封装

Step 4对请求结果的预处理

针对错误码定义异常

对请求结果处理

Step 5 对异常的统一处理

Step 6 MVP模式下 对Presenter 的封装

猜你喜欢

热点阅读

Step 6 MVP模式下对Presenter 的封装