Rxjava Retrofit 封裝Http請求實現生命週期管理和基類code的處理

時間 2019-11-08

標籤 rxjava retrofit 封裝 http 請求實現生命週期管理 code 處理欄目 Java 简体版

原文原文鏈接

解決問題

解決不一樣基類BaseBean的返回結果判斷 (參照 mp.weixin.qq.com/s/Qu-sNjU9u… )
lifecycle 解決頁面生命週期問題不須要引入三方的AUtoDispose 或者 RxLifeCycle 類庫

初始化

初始化配置參數按須要來配置java

RxHttp.initConfig(new ConfigModule() {
            @Override
            public void applyOptions(GlobalConfigBuild.Builder builder) {
                builder
                        .addInterceptor(new LoggerInterceptor())
                        .baseurl("http://lf.snssdk.com/api/")
                        .setPaeseInfor(new ParseInfo("errorCode", "data", "errorMsg", "0"))
                        .setAPICallBack(new APICallBack() {
                            @Override
                            public String callback(String code, String resultData) {
                                return null;
                            }
                        });

            }
        });
複製代碼

基類封裝方式

框架是基於Rxjava的因此能夠使用map操做符去將接口返回的String 作一層過濾去獲取到返回數據的code mes data 這裏能夠對數據狀態進行統一判斷數據獲取爭取返回字符串類型的data 固然也能夠將data json格式化以後再返回,這裏咱們這個map 只作數據狀態的判斷,下邊是整個狀態判斷的代碼android

爲了應對不一樣接口基類狀態字段的不一樣咱們定義了 paseInfor 來將基本的code msg data 以及成功碼統一外部傳入用這些字符串字段來匹配接口數據詳細方式請查看源代碼. 下一步咱們在將返回的data 字符串轉成業務實體 ,實體type外部傳入class,這裏將整個數據狀態判斷 ,數據實體轉換,以及線程切換統一封裝到Transformer中方便使用時直接調用compose 來實現這三個步驟

完整的使用方式以下

RxHttp
                .create()  //一 .獲取BaseApi
                .get("https://www.wanandroid.com/banner/json", SimpleParams.create().put("", "")) //二. 調用請求方法
                .compose(Transformer.switchSchedulersArray(DataBean.class)) //三. 返回結果處理
                .subscribe(new CommonObserver<List<DataBean>>(mBaseView) { //四.發起訂閱
                    @Override
                    public void onNext(List<DataBean> dataBeans) {
                        DataBean dataBean = dataBeans.get(0);
                        System.out.println(dataBean.getDesc());

                    }

                    @Override
                    protected void onError(int code, String mes) {
                        super.onError(code, mes);
                        System.out.println(code + "===" + mes);

                    }

                });
複製代碼

這裏咱們直接使用的BaseApi 固然咱們也能夠使用本身定義的APi 能夠調用creata()的另外一個有參方法傳入咱們自定義的請求APi,自定義APi 返回值能夠是String 也能夠是業務實體. 若是是業務實體那在compose裏能夠不使用咱們封裝的轉換方式,只須要作線程切換便可.能夠調用Transformer 的另外一個方法switchThread 值進行線程的切換. 若是返回值沒有基類的 code msg data 能夠直接使用能夠調用Transformer的switchSchedulersNoBase方法直接轉成業務實體自定義Api 使用方式以下git

RxHttp
                .create(ApiServer.class)
                .get("client_credentials",
                        "PPSSlAbaCYZpe8IhLQwWWinS",
                        "noqd2GKQmrpwhLu3hEuUi9X5cGQDfGw6")
                .compose(Transformer.<ResToken>switchThread())
                .subscribe(new CommonObserver<ResToken>(mBaseView) {
                    @Override
                    public void onNext(ResToken resToken) {
                        System.out.println(resToken.access_token);

                    }

                    @Override
                    protected void onError(int code, String mes) {
                        super.onError(code, mes);
                        System.out.println(code + "=====" + mes);

                    }

                });

        RxHttp
                .create()
                .get("https://aip.baidubce.com/oauth/2.0/token", SimpleParams.create()
                        .put("grant_type", "client_credentials")
                        .put("client_id", "PPSSlAbaCYZpe8IhLQwWWinS")
                        .put("client_secret", "noqd2GKQmrpwhLu3hEuUi9X5cGQDfGw6"))

                .compose(Transformer.switchSchedulersNoBase(ResToken.class))
                .observeOn(Schedulers.io())
                .flatMap(new Function<ResToken, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(ResToken resToken) throws Exception {
                        System.out.println("============Token 請求成功");
                        ReqToken reqToken = new ReqToken();
                        reqToken.image = "2164728647816478264781242746127846";
                        reqToken.image_type = "BASE64";
                        reqToken.face_field = "age,beauty,expression,faceshape,gender,glasses,landmark,race,qualities";
                        reqToken.max_face_num = "10";
                        reqToken.face_type = "LIVE";
                        reqToken.access_token = resToken.access_token;
                        return RxHttp
                                .create()
                                .post("https://aip.baidubce.com/rest/2.0/face/v3/detect", reqToken)
                                .compose(Transformer.<String>switchThread());
                    }
                })
                .subscribe(new CommonObserver<String>(mBaseView) {
                    @Override
                    public void onNext(String s) {
                        System.out.println("=======" + s);
                    }

                    @Override
                    protected void onError(int code, String mes) {
                        super.onError(code, mes);
                    }
                });

    }
複製代碼

生命週期的管理

生命週期使用jetpacK的 lifecycle 管理, 能夠在被訂閱者裏註冊lifecycle 監聽週期變化也能夠自定義操做符來實現,能夠在Rxjava 訂閱時構造函數中傳入 Lifecycle對象進行註冊 ,在onSubscribe 回調中獲得 Disposable 在onDestroy中去對Disposable 作取消操做github

public abstract class BaseObserver<T> implements Observer<T>, LifecycleObserver {

    /**
     *要想實現生命週期的去掉訂閱操做必須傳入能夠獲取到lifeCycle 的對象
     *
     * @param lifecycle
     */
    public BaseObserver(Object lifecycle) {
        if (lifecycle != null) {
            if (lifecycle instanceof AppCompatActivity) {
                ((AppCompatActivity) lifecycle).getLifecycle().addObserver(this);
                return;
            }
            if (lifecycle instanceof Fragment) {
                ((Fragment) lifecycle).getLifecycle().addObserver(this);
                return;
            }
            if (lifecycle instanceof Lifecycle) {
                ((Lifecycle) lifecycle).addObserver(this);
                return;
            }

        }
    }


    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
        BaseException apiException = null;
        if (e instanceof BaseException) {
            apiException = (BaseException) e;
        } else {
            apiException = getErrorType(e);
        }
        String message = apiException.getMessage();
        int code = apiException.getCode();
        onError(code, message);

    }

    @Override
    public void onComplete() {

    }


    protected void onError(int code, String mes) {

    }

    protected BaseException getErrorType(Throwable e) {
        return DefaultException.handleException(e);
    }

    private Disposable disposable;

    @Override
    public void onSubscribe(Disposable d) {
        disposable = d;
    }

    private final void cancel(LifecycleOwner owner) {
        if (this.disposable != null && !disposable.isDisposed()) {
            disposable.dispose();
        }
        if (owner != null) {
            owner.getLifecycle().removeObserver(this);
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy(LifecycleOwner owner) {
        this.cancel(owner);
    }
}
複製代碼