一行代码完成一个网络请求

我是一条大鱼
398 阅读2分钟

直入主题，用过rxjava retrofit的同学写一个网络请求 原始的可能是这样

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(API.BASE_URL)//基础URL 建议以 / 结尾
                .addConverterFactory(GsonConverterFactory.create())//设置 Json 转换器
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())//RxJava 适配器
                .build();
        RxWeatherService rxjavaService = retrofit.create(api .class);
        apiService .getMessage("xxx")
                .subscribeOn(Schedulers.io())//IO线程加载数据
                .observeOn(AndroidSchedulers.mainThread())//主线程显示数据
                .subscribe(new Subscriber<T>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(T t) {
                    }
                });

当然肯定会做一下封装 变成了这样

       HttpService.getInstance().getMessage(pageNo)  //retrofit 单例
                .compose(RxHelper.<T>handleResult()) //线程切换 ）
                .compose(rxlife)//绑定生命周期之类的库
               // .map(new fun)//一些操作
                //.flatMap()//一些操作
                .subscribe(new cusTomSubscriber<T>() { //自定义的回调 
                    @Override
                    protected void onSucess(T) {
                      // todo
                    }

                    @Override
                    protected void onFail(String message) {
                       //todo
                    }
                });

封装到这个部分也差不多没啥问题了。 retrofit单例，线程切换封装，网络返回的json全局处理/dialog等等，关联Activity/Fragment生命周期,也没用打破rxjava的链式调用（网上很多封装的完全打破了rxjava该有的意义） 说到这里 个人仍然认为还是写一堆代码，如果能直接写 api+回调接口 就完成一个网络请求那可以省好多事情 所以我切换到了kotlin

先看一下最终的结果

     Http.getInstance().getMessage().get(this) { it：T
            //todo something
        }

是的，这样就完了。只需要写出 api接口 一个括号（回调）就完成了所有的事情

核心代码是 kotlin 扩展函数+高阶函数(默认参数，命名参数)

fun <T> Observable<BaseModel<T>>.get(context: Context, isShowDialog: Boolean = false, message: String? = "请稍候", title: String? = "", next: (T) -> Unit, err: (mS: String?) -> Unit) {

    this.compose(RxCompose.handleResult<T>(context as LifecycleOwner)).subscribe(object : MySubscriber<T>(if (isShowDialog) context else null, message, title) {
        override fun onSucess(t: T) {
            next(t)
        }

        override fun onFail(message: String?) {
            err(message)
        }
    })
}

//线程切换 结果简单处理（其实可以放到其他操作符专门处理，这里简单处理一下），生命周期绑定
    fun <T> handleResult(context: LifecycleOwner): ObservableTransformer<BaseModel<T>, T> {

        return ObservableTransformer { upstream ->

            upstream.flatMap {

                if (it.code == 200) {
                    createData(it.data)
                } else {
                    Observable.error(ServerException(it.msg))
                }
            }.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
            .compose(RxLife.with(context).bindToLifecycle())

        }

    }

解释一下：get为 observeable 扩展函数 next: (T) -> Unit 为传入的函数（我们所需要的网络数据）， err: (mS: String?) -> Unit 为错误信息 RxCompose.handleResult(context as LifecycleOwner) 是线程切换+生命周期绑定（这里使用到了一个童鞋的生命周期库，不用继承Activity/fragment，等下在文末贴出） LifecycleOwner 为谷歌官方生命周期库 神器 （默认Activity已经实现此接口，所以传入context即可）

感谢文献

avatar
文章
阅读
粉丝