Rxjava学习笔记

最新推荐文章于 2024-07-23 22:08:49 发布

villa_mou

最新推荐文章于 2024-07-23 22:08:49 发布

阅读量176

点赞数

分类专栏： android Rxjava 文章标签： Rxjava 笔记

本文链接：https://blog.csdn.net/villa_mou/article/details/78664744

版权

android 同时被 2 个专栏收录

39 篇文章 2 订阅

订阅专栏

Rxjava

1 篇文章 0 订阅

订阅专栏

just(T...): 将传入的参数依次发送出来。
Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。
String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

3
* 知识点1;FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里.
* 知识点2:flatmap发射下去的是无序的,如果想发射的有序得用concatMap

private fun useFaltMap() {
    Observable.create(object : ObservableOnSubscribe<Int> {
        override fun subscribe(e: ObservableEmitter<Int>) {
            e.onNext(10)
            e.onNext(20)
            e.onNext(30)
        }

    }).flatMap(object : Function<Int, ObservableSource<String>> {
        override fun apply(t: Int): ObservableSource<String> {
            val list = mutableListOf<String>()
            for (i in 1..5) {
                list.add("数据" + t)
            }
            return Observable.fromIterable(list)
        }

    }).subscribe(object : Consumer<String> {
        override fun accept(t: String?) {
            println(t)
        }

    })
}

map是RxJava中最简单的一个变换操作符了, 它的作用就是对上游发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化

private fun useMap() {
    Observable.create(object : ObservableOnSubscribe<Int> {
        override fun subscribe(e: ObservableEmitter<Int>) {
            e.onNext(50)
            e.onNext(50)
            e.onNext(50)
        }

    }).map(object : Function<Int, String> {
        override fun apply(t: Int): String = "haha" + t

    }).subscribe(object : Consumer<String> {
        override fun accept(t: String?) {
            println(t)
        }

    })
}

5
* Consumer是简易版的Observer，他有多重重载，可以自定义你需要处理的信息，我这里调用的是只接受onNext消息的方法，他只提供一个回调接口accept，由于没有onError和onCompete，无法再接受到onError或者onCompete之后，实现函数回调。
* 无法回调，并不代表不接收，他还是会接收到onCompete和onError之后做出默认操作，也就是监听者（Consumer）不在接收
* Observable发送的消息，下方的代码测试了该效果。

private fun useConsumer() {
    val consumerOnNext = object : Consumer<Int> {
        override fun accept(t: Int) {
            println(t)
        }

    }

    val consumerOnError = object : Consumer<Throwable> {
        override fun accept(t: Throwable) {
            println(t.message)
        }

    }

    val consumerOnComplete = object : Action {
        override fun run() {
            println("完成")
        }

    }
    Observable.create(object : ObservableOnSubscribe<Int> {
        override fun subscribe(e: ObservableEmitter<Int>) {
            e.onNext(5)
            e.onNext(6)
            e.onNext(7)
            e.onComplete()
        }
    }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(consumerOnNext, consumerOnError, consumerOnComplete)
}

6
observeOn表示指定消费事件的线程,为什么可以实现多次切换

答案是：能。因为 observeOn() 指定的是 Subscriber 的线程，
而这个 Subscriber 并不是（严格说应该为『不一定是』，
但这里不妨理解为『不是』）subscribe() 参数中的 Subscriber ，
而是 observeOn() 执行时的当前 Observable 所对应的 Subscriber ，即它的直接下级 Subscriber 。
换句话说，observeOn() 指定的是它之后的操作所在的线程。
因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次 observeOn() 即可。上代码：

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.newThread())
    .map(mapOperator) // 新线程，由 observeOn() 指定
    .observeOn(Schedulers.io())
    .map(mapOperator2) // IO 线程，由 observeOn() 指定
    .observeOn(AndroidSchedulers.mainThread) 
    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

7
不同于 observeOn() ， subscribeOn() 的位置放在哪里都可以，但它是只能被调用一次的。

8
Observable.doOnSubscribe() 是和Subscriber.onStart()对应的一个方法
但是 Subscriber.onStart()不能单独指定线程,Observable.doOnSubscribe() 就可以更好的单独指定线程了

Observable.create(onSubscribe)
    .subscribeOn(Schedulers.io())
    .doOnSubscribe(new Action0() {
        @Override
        public void call() {
            progressBar.setVisibility(View.VISIBLE); // 需要在主线程执行
        }
    })
    .subscribeOn(AndroidSchedulers.mainThread()) // 指定主线程
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(subscriber);

9,
Zip通过一个函数将多个Observable发送的事件结合到一起，然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。

Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {           
    @Override                                                                                        
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {                     
        Log.d(TAG, "emit 1");                                                                        
        emitter.onNext(1);                                                                           
        Thread.sleep(1000);                                                                          

        Log.d(TAG, "emit 2");                                                                        
        emitter.onNext(2);                                                                           
        Thread.sleep(1000);                                                                          

        Log.d(TAG, "emit 3");                                                                        
        emitter.onNext(3);                                                                           
        Thread.sleep(1000);                                                                          

        Log.d(TAG, "emit 4");                                                                        
        emitter.onNext(4);                                                                           
        Thread.sleep(1000);                                                                          

        Log.d(TAG, "emit complete1");                                                                
        emitter.onComplete();                                                                        
    }                                                                                                
});                                                                                                  

Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {             
    @Override                                                                                        
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {                      
        Log.d(TAG, "emit A");                                                                        
        emitter.onNext("A");                                                                         
        Thread.sleep(1000);                                                                          

        Log.d(TAG, "emit B");                                                                        
        emitter.onNext("B");                                                                         
        Thread.sleep(1000);                                                                          

        Log.d(TAG, "emit C");                                                                        
        emitter.onNext("C");                                                                         
        Thread.sleep(1000);                                                                          

        Log.d(TAG, "emit complete2");                                                                
        emitter.onComplete();                                                                        
    }                                                                                                
});                                                                                                  

Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {                 
    @Override                                                                                        
    public String apply(Integer integer, String s) throws Exception {                                
        return integer + s;                                                                          
    }                                                                                                
}).subscribe(new Observer<String>() {                                                                
    @Override                                                                                        
    public void onSubscribe(Disposable d) {                                                          
        Log.d(TAG, "onSubscribe");                                                                   
    }                                                                                                

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

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

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

什么事背压式，背压是流速控制的一种策略

背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略

RxJava 2.x 相比于Rxjava1拥有了新的特性，其依赖于4个基础接口，它们分别是

Publisher
Subscriber
Subscription
Processor

在 RxJava 2.x 中，Observable 用于订阅 Observer，不再支持背压（1.x 中可以使用背压策略），而 Flowable 用于订阅 Subscriber ，是支持背压（Backpressure）的。

Observable ( 被观察者 ) / Observer ( 观察者 ) 不具备背压式
Flowable （被观察者）/ Subscriber （观察者） 具备背压式

interval 操作符实现心跳间隔任务

private Disposable mDisposable;
    @Override
    protected void doSomething() {
        mDisposable = Flowable.interval(1, TimeUnit.SECONDS)
                .doOnNext(new Consumer<Long>() {
                    @Override
                    public void accept(@NonNull Long aLong) throws Exception {
                        Log.e(TAG, "accept: doOnNext : "+aLong );
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(@NonNull Long aLong) throws Exception {
                        Log.e(TAG, "accept: 设置文本 ："+aLong );
                        mRxOperatorsText.append("accept: 设置文本 ："+aLong +"\n");
                    }
                });
    }

    /**
     * 销毁时停止心跳
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mDisposable != null){
            mDisposable.dispose();
        }
    }

villa_mou

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Rxjava学习笔记

1just(T...): 将传入的参数依次发送出来。Observable observable = Observable.just("Hello", "Hi", "Aloha");// 将会依次调用：// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();2from(T[]) / from(Iterab
复制链接

扫一扫

专栏目录