RxJava基础知识

关注

原创 2022-08-26 09:25:50 823 阅读 AI 写同款· GEO 优化 ›

京东联盟API实战：5分钟搞定商品返利链接生成（附Python代码）本文详细介绍了如何利用京东联盟API快速构建自动化商品返利链接生成系统。通过Python代码实战，从API申请、环境配置到核心功能封装，手把手教你实现批量商品信息查询与推广链接生成，帮助内容创作者和开发者大幅提升电商推广效率。阅读详情

RxJava基础知识

一、引入依赖

    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
    implementation 'io.reactivex.rxjava2:rxjava:2.2.7'

二、转换操作符

2.1 create

 private void testCrate() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("first");
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.d(TAG,"onSubscribe " + d);
            }

            @Override
            public void onNext(@NonNull String o) {
                Log.d(TAG,"onSubscribe " + o);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.d(TAG,"onError " + e);
            }

            @Override
            public void onComplete() {
                Log.d(TAG,"onComplete ");
            }
        });
    }

输出结果

2022-08-13 20:41:05.253 12124-12124/com.yhcode.rxjava D/MainActivity: onSubscribe CreateEmitter{null}
2022-08-13 20:41:05.255 12124-12124/com.yhcode.rxjava D/MainActivity: onSubscribe first
2022-08-13 20:41:05.255 12124-12124/com.yhcode.rxjava D/MainActivity: onComplete

2.2 just

just 1-10个参数，内部调用的是fromArray方法

private void testJust() {
        Observable.just("first","second","third").subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.d(TAG,"onSubscribe");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.d(TAG,"onNext:" + s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.d(TAG,"onError:" + e);
            }

            @Override
            public void onComplete() {
                Log.d(TAG,"onComplete");
            }
        });
    }

输出结果

2022-08-13 20:56:48.905 12737-12737/com.yhcode.rxjava D/MainActivity: onSubscribe
2022-08-13 20:56:48.905 12737-12737/com.yhcode.rxjava D/MainActivity: onNext:first
2022-08-13 20:56:48.905 12737-12737/com.yhcode.rxjava D/MainActivity: onNext:second
2022-08-13 20:56:48.909 12737-12737/com.yhcode.rxjava D/MainActivity: onNext:third
2022-08-13 20:56:48.909 12737-12737/com.yhcode.rxjava D/MainActivity: onComplete

2.3 fromArray

和just的区别是，just内部调用的是fromArray,并且最多只能10个参数，而fromArray参数没有限制

 private void testFromArray() {
        Observable.fromArray("one","two","three","four").subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.d(TAG,"onSubscribe");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.d(TAG,"onNext " + s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.d(TAG,"onError " + e);
            }

            @Override
            public void onComplete() {
                Log.d(TAG,"onComplete");
            }
        });
    }

输出结果

2022-08-13 21:09:33.794 13144-13144/com.yhcode.rxjava D/MainActivity: onSubscribe
2022-08-13 21:09:33.794 13144-13144/com.yhcode.rxjava D/MainActivity: onNext one
2022-08-13 21:09:33.795 13144-13144/com.yhcode.rxjava D/MainActivity: onNext two
2022-08-13 21:09:33.795 13144-13144/com.yhcode.rxjava D/MainActivity: onNext three
2022-08-13 21:09:33.802 13144-13144/com.yhcode.rxjava D/MainActivity: onNext four
2022-08-13 21:09:33.802 13144-13144/com.yhcode.rxjava D/MainActivity: onComplete

2.4 fromIterable

参数可以接收为实现了Iterable接口的对象

 private void testFromIterable() {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        Observable.fromIterable(list).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"accept" + s);
            }
        });

输出结果

2022-08-13 21:17:52.470 13383-13383/com.yhcode.rxjava D/MainActivity: acceptone
2022-08-13 21:17:52.470 13383-13383/com.yhcode.rxjava D/MainActivity: accepttwo

2.5 fromFuture

private void testFromFuture() {
        Observable.fromFuture(new Future<String>() {
            @Override
            public boolean cancel(boolean mayInterruptIfRunning) {
                return false;
            }

            @Override
            public boolean isCancelled() {
                return false;
            }

            @Override
            public boolean isDone() {
                return false;
            }

            @Override
            public String get() throws ExecutionException, InterruptedException {
                return "from future result";
            }

            @Override
            public String get(long timeout, TimeUnit unit) throws ExecutionException, InterruptedException, TimeoutException {
                return null;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"accept:" + s);
            }
        });

输出结果

2022-08-13 21:21:24.496 13560-13560/com.yhcode.rxjava D/MainActivity: accept:from future result

2.6 fromCallable

private void testFromCallback() {
        Observable.fromCallable(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "Callable";
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"accept " + s);
            }
        });
    }

输出结果

2022-08-13 21:24:43.179 13681-13681/com.yhcode.rxjava D/MainActivity: accept Callable

2.7 map

map 对事件进行处理

 private void testMap() {
        //把aaa字符串转为大写
        Observable.just("aaa").map(new Function<String, String>() {
            @Override
            public String apply(@NonNull String s) throws Exception {
                return s.toUpperCase();
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"aaa upper letter :" + s);
            }
        });
    }

输出结果

2022-08-13 21:35:29.839 13952-13952/com.yhcode.rxjava D/MainActivity: aaa upper letter :AAA

2.8 flatMap

flatMap会产生新的被观察者，模拟实现先注册账号，然后登录账号流程

private void testFlatMap() {
        Observable.just("user register for accont libo").flatMap(new Function<String, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(@NonNull String s) throws Exception {
                return Observable.just(s + "begin login");
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                Log.d(TAG,"login result:" + o);
            }
        });
    }

输出结果

2022-08-13 21:49:41.780 14359-14359/com.yhcode.rxjava D/MainActivity: login result:user register accountbegin login

2.9 Buffer

把事件按照传入buffer的数量为一组一起发送

 Observable.just("li1","li2","li3","zhang1","zhang2","zhang3","wang1").buffer(3).subscribe(new Consumer<List<String>>() {
            @Override
            public void accept(List<String> strings) throws Exception {
                Log.d(TAG,"result:" + strings);
            }
        });

输出结果

2022-08-26 08:49:03.639 13941-13941/com.yhcode.rxjava D/MainActivity: result:[li1, li2, li3]
2022-08-26 08:49:03.639 13941-13941/com.yhcode.rxjava D/MainActivity: result:[zhang1, zhang2, zhang3]
2022-08-26 08:49:03.639 13941-13941/com.yhcode.rxjava D/MainActivity: result:[wang1]

未完待续，持续更新

三、组合操作符

3.1 contact

contact 操作符将多个观察者组合在一起然后顺序发送，最多可以支持4个，如果需要支持超过4个，可以使用contactArray

 Observable.concat(Observable.just("one"),Observable.just("two"))
                .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"result:" + s);
            }
        });

输出结果

2022-08-26 09:00:39.715 14158-14158/com.yhcode.rxjava D/MainActivity: result:one
2022-08-26 09:00:39.716 14158-14158/com.yhcode.rxjava D/MainActivity: result:two

3.2 contactArray操作符

与contact操作符功能一样，差异是可以传入超过4个参数

        Observable.concatArray(Observable.just("A"),Observable.just("B"),Observable.just("C"),Observable.just("D"),Observable.just("E"),Observable.just("F"))
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.d(TAG,s);
                    }
                });

输出结果

2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: A
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: B
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: C
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: D
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: E
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: F

3.3 merge

merge操作符与contact 类似都是将多个观察者组合在一起发送，区别是contact（contactArray）是串行发送，merge是并行发送

Observable observableOne = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                Thread.sleep(2000);
                emitter.onNext("First Emitter");
                emitter.onComplete();
            }
        });

        Observable observableTwo = Observable.just("Second Emitter");

        Observable observableThree = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                Thread.sleep(5000);
                emitter.onNext("Three Emitter");
                emitter.onComplete();
            }
        });

        Observable.merge(observableOne,observableTwo,observableThree).subscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                Log.d(TAG,"result:" + o);
            }
        });

输出结果

2022-08-26 09:13:16.974 14297-14297/com.yhcode.rxjava D/MainActivity: result:First Emitter
2022-08-26 09:13:16.974 14297-14297/com.yhcode.rxjava D/MainActivity: result:Second Emitter
2022-08-26 09:13:21.975 14297-14297/com.yhcode.rxjava D/MainActivity: result:Three Emitter