RxJava 学习使用心得

最新推荐文章于 2024-08-21 13:30:00 发布

Leo.me

最新推荐文章于 2024-08-21 13:30:00 发布

阅读量1.1k

点赞数 2

本文链接：https://blog.csdn.net/qq_34603736/article/details/53304286

版权

扔物线（好奇怪的名字啊）的blog 我写的这个就来自他的博客的在思考

思考

1 为什么要看 RxJava ?
答：项目越大的时候逻辑越复杂，被复杂的逻辑搞的自己写过的代码看起来都要好好想一想当时自己是怎么写出来的了。

2 为什么要学 RxJava ?
答：不想自己再去控制复杂的线程问题了

3 学了 RxJava 能干什么用？
答：给你把刀，从此你的亿万身家就靠它了。

逻辑

我先要大概了解一下 RxJava,大概知道她都有哪些内容，
最基础写个小demo 熟悉一下用法，理解一下基础概念
理解一下的他的逻辑，拿到刀
能不能成为亿万富豪就看他了，在自己的项目中尝试加入他
第一步了解 RxJava

RxJava 包含三个部分 observer (观察者), observable(被观察者)，subscribe(订阅桥梁的作用)，一切都在上帝的掌握之中。

首先我们来做一件事情，我从SD卡中加载图片到 imageView 中。
做这个事情之前，1 从SD卡中拿照片出来是个耗时动作，这个要放在后台来做。 2 将获得的Bitmap 放在 imageView中这个要放在主线程中。

那我们用RxJava怎么做这件事？

我们的流程是 observable （被观察者干活的）取出bitmap 交给 subscriber（上帝监工），subscribe() 把 bitmap 交给observer （观察者主人）。
按照这个流程我们写的代码是

Observable.create(new Observable.OnSubscribe<Bitmap>() {
            @Override
            public void call(Subscriber<? super Bitmap> subscriber) {
                Log.d(TAG, "call");
                Bitmap bitmap = new RxLoadImage(urls[0]).create();// 取出bitmap

                subscriber.onNext(bitmap);// 交给上帝
                subscriber.onCompleted(); //干完活打报告

            }
        }).subscribe(new Observer<Bitmap>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted");
                Toast.makeText(MainActivity.this, "图片放置完毕主人", Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Bitmap bitmap) {
                Log.d(TAG, "onNext");
                mImageView1.setImageBitmap(bitmap);// 在从上帝监工那 拿bitmap

            }
        });

这里写图片描述

可以看到上面的顺序依次是observable -> subscribe -> observer，什么？没看懂？好吧，那我们在换种方法来写，就按照上面的流程来写。

    private void mRxJava(){
//        observable 被观察者 干活的
        Observable observable = Observable.create(new Observable.OnSubscribe<Bitmap>() {
            @Override
            public void call(Subscriber<? super Bitmap> subscriber) {
                Log.d(TAG, "observable-call");
                Bitmap bitmap = BitmapFactory.decodeFile(urls[0]);// 干活拿bitmap
                subscriber.onNext(bitmap);
                subscriber.onCompleted();

            }

        });

//        subscribe 上帝
        Subscriber<Bitmap> subscriber = new Subscriber<Bitmap>() {
            @Override
            public void onCompleted() {
                Log.d("MainActivity", "subscriber-onCompleted");

            }

            @Override
            public void onError(Throwable e) {
                Log.d("MainActivity", "subscriber-onError");

            }

            @Override
            public void onNext(Bitmap bitmap) {
                Log.d("MainActivity", "subscriber-onNext");

            }
        };

//       observer 观察者 地主 只负责拿东西的
        Observer<Bitmap> observer = new Observer<Bitmap>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "observer-onCompleted");
                Toast.makeText(MainActivity.this, "活干完了", Toast.LENGTH_SHORT).show();
            }

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

            @Override
            public void onNext(Bitmap bitmap) {
                Log.d(TAG, "observer-onNext");
                mImageView1.setImageBitmap(bitmap);
            }
        };

//       干完活将bitmap交给上帝，observer 地址从上帝那里拿到bitmap

        observable.subscribe(observer);
    }

运行之后打印log
这里写图片描述

逻辑上你会发现，我擦完全没有subscriber 什么事啊 ? 我们看一下代码会发现 subscriber 实现了 observer的接口。

public abstract class Subscriber<T> implements Observer<T>, Subscription {
many code ...
}

Observable.from的使用

observable.from 可以从一个集合中不断的发射


    private void rxFrom() {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        Observable<Integer> integerObservable = Observable.from(list);
        integerObservable.subscribe(new Observer<Integer>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "completed");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "integer:----->" + integer);
            }
        });
    }

打印log

这里写图片描述

Observable.just() 的使用

 private void rxJust() {
        Observable<String> just = Observable.just(
                justTest(1)
                ,justTest(2)
                ,justTest(3)
                ,justTest(4)
                ,justTest(5)
                ,justTest(6)
                ,justTest(7)
                ,justTest(8)
                ,justTest(9)
                ,justTest(10)
        );

        just.subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "completed");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }
        });
    }

    private String justTest(int i) {

        return "哈哈哈 justTest "+i;
    }

这里写图片描述

.from 和 .just 有什么区别？
待研究

Observable.empty() 的使用
不发射数据，但是可以正常结束，走completed方法。

private void rxEmpty() {
        Observable<String> just = Observable.empty(

        );

        just.subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "completed");
            }

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

            @Override
            public void onNext(String s) {
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }
        });
    }

Observable.never() 的使用
不发射数据，也永远不会结束，不走 completed方法

Observable.error() 的使用
不发射数据，走 onError 方法。

 private void rxError() {
        Observable<String> just = Observable.error(
            new Throwable()
        );

        just.subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "completed");
            }

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

            }


            @Override
            public void onNext(String s) {
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }
        });
    }
    ```
**以上这些方法用于什么场景？ 我暂时也没有想到**

**PublishSubject 的使用**

private void publishSubject() {
PublishSubject stringPublishSubject = PublishSubject.create();

    stringPublishSubject.subscribe(new Observer<String>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(String s) {
            Log.d(TAG, s);
            Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
        }
    });

    stringPublishSubject.onNext("publishSubject");

}

“`