android 积累一些关于rxjava的知识点

最新推荐文章于 2021-09-07 10:42:51 发布

泡温泉的咸鱼

最新推荐文章于 2021-09-07 10:42:51 发布

阅读量970

点赞数

分类专栏： Android 文章标签： android rxjava retrofit2 变换线程切换

本文链接：https://blog.csdn.net/Coder_Hcy/article/details/53838413

版权

RxJava是Android中处理异步请求的一种规范，它以观察者模式为基础，结合Retrofit2常用于网络请求。本文介绍了RxJava的Observer/Subscriber作为事件消费者，Observable作为事件生产者的概念，并强调了其线程切换的优势。同时，提到了Subject作为可替代Observable的事件产生与发送者，以及订阅后取消订阅以防止内存泄漏的重要性。

摘要由CSDN通过智能技术生成

rxjava在我看来就是一套比较先进的asynctask，用来处理异步请求的一种规范（得益于它的代码思路清晰），在android中可以用来代替asynctask甚至是handler。常与当前流行网络请求框架retrofit2一同使用。

rxjava的采用了观察者模式:Observer/Subscriber(观察者),Observable(主题)。个人喜欢把Observer/Subscriber当做事件的消费者，Observable当做是事件的产生者。

优点：线程切换（android 网络请求与UI刷新），逻辑清晰

android-studio 环境配置:

   compile 'io.reactivex:rxjava:1.0.14'
   compile 'io.reactivex:rxandroid:1.0.1'

Observer/Subscriber(观察者)

 Observer<String>  observer=new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.i("rxjava::","onCompleted::");

            }

            @Override
            public void onError(Throwable e) {
                Log.i("rxjava::","onError::"+e.getMessage());

            }

            @Override
            public void onNext(String s) {

                /**
                 * 被观察者“发给” 观察者的消息
                 * 可以理解成 事件在这里消费
                 */

                Log.i("rxjava::","onNext::"+s);

            }
        };

 Subscriber<String>  subscriber=new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i("rxjava::","onCompleted::");

            }

            @Override
            public void onStart() {
                super.onStart();
                Log.i("rxjava::","onStart::");

            }

            @Override
            public void onError(Throwable e) {
                Log.i("rxjava::","onError::"+e.getMessage());

            }

            @Override
            public void onNext(String s) {
                Log.i("rxjava::","onNext::"+s);

            }
        };

观察者两种写法的区别:

1.Subscriber 对 Observer 接口进行了一些扩展,即Subscriber 里可以重写一个onstart的方法

2.onstart方法：在被观察者“发送”消息之前。我也不知道有什么软用，不能加载进度条（因为不在UI线程）

Observable(被观察者)

 Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //事件中心
                subscriber.onNext("hasaki");

                subscriber.onNext("mianduijifengba");


                subscriber.onCompleted();//此句话要是不调用   观察者里的oncompleted方法就不会调用

            }
        });

Subject:也是一种事件的产生与发送者,可替代Observable

PublishSubject.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("nihao");
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

                Log.i("TTTTT:::",s+"???");
            }
        });

当然被观察者还可以使用固定的方法来“发送数据给观察者”

just(传入要发送的数据序列并用逗号隔开);

/**
* 此方法默认在执行结束加上onCompleted();
*/
 Observable<String> observable =  Observable.just("hasaki","mianduijifengba");

from(可传入对象数组);

        String[]  requestArray={"hasaki","mianduijifengba"};
        /**
         * 此方法默认在执行结束加上onCompleted();
         */
        Observable<String> observable = Observable.from(requestArray);

订阅:“被观察者去订阅观察者”：原因是:流式API设计(什么鬼？)

 //订阅
 observable.subscribe(subscriber);

取消订阅:(对于异步请求结束后,要解除引用关系,避免内存泄漏)
一般订阅之后都会产生一个Subscription对象

        //订阅
        Subscription subscribe = observable.subscribe(subscriber);

        if(subscribe.isUnsubscribed()){
            //判断是否解除订阅
            Log.i("rxjava","没有解除订阅");

            subscribe.unsubscribe();//解除订阅


        }else{
            Log.i("rxjava","解除订阅");
        }

初级进阶(线程控制)

因为被观察者是"事件的产生者"，而观察者是"事件的消费者",通常在网络请求中，被观察者里开启子线程做网络请求，观察者里要在UI线程中跟新UI，主要运用到两个方法：

 observable.subscribeOn();//设置被观察者里事件产生所处的线程,即：调用call方法所处的线程
        
 observable.observeOn();//观察者，事件消费所处的线程即：onNext

线程分类:

Schedulers.immediate()//当前线程，即默认

Schedulers.newThread()//顾名思义，开启新线程
Schedulers.io()//相当于cacheThreadPool  维护一个不定数量的线程池，还可重复利用
AndroidSchedulers.mainThread()//android 专利，顾名思义，即主线程。
example:开启线程读取数据，UI线程跟新数据::
       String[] requestArray = {"hasaki", "面对疾风吧"};

        Observable.from(requestArray)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(String s) {

                        tv.setText(s);

                    }
                });

中级进阶(变换)
所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。
1.Map（转换类操作符）单个转换
什么是转成不同的事件?