Rxjava 用到的一些场景

这是我在这段时间的开发中，一些场景对 Rxjava、retrofit的应用

1、 数据三级获取 (内存 -> 本地存储 -> 网络)
2、 延迟执行 ， 延迟 2秒 执行 xx操作
3、 轮循任务
4、 多组不同的数据源 之间的操作:(场景： 1、注册需要三个参数都满足条件；2、输出两组数组 相同的数)
5、 过滤 且返回第一个符合条件的数据
6、 Rxjava Retrofit组合使用

数据三级获取 (内存 -> 本地存储 -> 网络)

正常来讲是这样的：
新开线程 先判断对象有没有数据，没有数据就从本地赋值给对象，如果还是为空，那么从网络获取，最后切换主线程执行UI操作;

    ObservableSource<String> memory = observer1 -> {
        if (str != null) {
            observer1.onNext(str);
        } else {
            observer1.onComplete();
        }
    };
    ObservableSource<String> disk = observer1 -> {
        String localData = "localData";
        if (localData != null) {
            observer1.onNext(localData);
        } else {
            observer1.onComplete();
        }
    };
    ObservableSource<String> netWork = observer1 -> {
        String netData = null;
        if (netData != null) {
            observer1.onNext(netData);
            observer1.onComplete();
        } else {
            observer1.onComplete();
            observer1.onError(new Throwable("数据为空"));
        }
    };
    Observer observer = new Observer<String>() {

        @Override
        public void onNext(String s) {  //UI操作 }

        @Override
        public void onError(Throwable e) { // 吐司 }
    };
    
Observable.concat(memory, disk, netWork)
        .subscribeOn(Schedulers.io())//指定Observable 在哪个线程上创建执行操作，如果多次调用，只有第一次有效
        .observeOn(AndroidSchedulers.mainThread())//在指定下一事件发生的线程
        .subscribe(observer);

别看好像代码挺多的， 但是流程绝对清晰，最主要的是 不用手动切换线程；

延迟执行 ， 延迟 2秒 执行 xx操作

有个弊端,不能发射数据， 且Observer数据类型是Long 返回数为：0；

Observer<Long> longObserver = new Observer<Long>() {
 //...
    @Override
    public void onNext(Long lon) {
        out("onNext：" + lon);
    }
//...
};
Observable.timer(2, TimeUnit.MILLISECONDS)
        .subscribe(longObserver);

轮循任务

Observable.interval(2, TimeUnit.SECONDS)
        .subscribe(longObserver);


停止轮循 unSubscribe()

多组不同的数据源 之间的操作:(场景： 1、注册需要三个参数都满足条件；2、输出两组数组 相同的数)

1 注册：

Observable.combineLatest( Observable.just("111"),  Observable.just("222"), Observable.just("333"),
        (s, charSequence, charSequence2) -> {
           //判断三个数是否都满足条件  返回 true或者 false
            return false;
        })
        .subscribe(new Observer<Boolean>() {
//...
            @Override
            public void onNext(Boolean b) {
                out("onNext：" + (b ? "成功" : "失败"));
            }
        });

2 两数组输出相同数

Observable.combineLatest( Observable.just(list1),  Observable.just(list2), Observable.just("333"),
        (list1, list2) -> {
           List inputList=new ArrayList<>();
           for(int a:list1){
                for(int b:list2){
                    inputList.add(a);
                }
           }
            return inputList;
        })
        .subscribe(new Observer<List<int>>() {
//...
            @Override
            public void onNext(List<int> list) {
                out("onNext：" + list);
            }
//...
        });

过滤 且返回第一个符合条件的数据

Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
        .filter(integer -> {
            if (integer <3) {
                return false;
            } else {
                return true;
            }
        })
        .firstElement()
        .subscribe(integer -> out("accept：" + integer))

Rxjava Retrofit 组合使用

封装一下更好用哦，套路如下：

初始化 支持 rxjava的 retrofit
通过retrofit 得到 Observable
Observable 执行 网络请求

public interface HttpHealthAPI {
    @GET("index.php")
    Observable<BaseDataModel> get(@Query("controller") String controller, @Query("method") String method, @Query("app_id") String app_id);
}

// 初始化  Retrofit 
    private Retrofit retrofit;
    retrofit = new Retrofit.Builder()
            .baseUrl(NET_RETROFIT_URL)
           .client(client)
           .addConverterFactory(FastJsonConverterFactory.create())    //数据转换 我这边用的是fastjson
           .addCallAdapterFactory(RxJava2CallAdapterFactory.create())    //转换成 rxjava
           .build();
  //  获取  Observable
Observable  observable =  retrofit .create(HttpHealthAPI.class)    

// 执行 网络请求
       observable.subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(baseSubscriber);

希望我的文章不会误导在观看的你，如果有异议的地方欢迎讨论和指正。
如果能给观看的你带来收获，那就是最好不过了。

人生得意须尽欢, 桃花坞里桃花庵

点个关注呗，对，不信你点试试？