[Android 知识点] RxAndroid的使用(一)

最新推荐文章于 2021-05-26 23:49:06 发布

lzc5888

最新推荐文章于 2021-05-26 23:49:06 发布

阅读量2.3k

点赞数

CC 4.0 BY-SA版权

分类专栏： Android 文章标签： android

本文链接：https://blog.youkuaiyun.com/lzc5888/article/details/53957450

Android 专栏收录该内容

33 篇文章

订阅专栏

本文介绍了RxAndroid的基本概念和使用方法，包括在主线程和任意线程中观察、Observer与Observable的关系，以及如何创建各种类型的Observables，如Create、Just、Defer等。此外，还详细讲解了每种创建方法的功能和应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

GitHub：https://github.com/ReactiveX/RxAndroid
APIDoc：http://reactivex.io/RxJava/javadoc/
Documentation：http://reactivex.io/documentation/operators.html#alphabetical

概述

RxAndroid 是一个响应式编程框架。

依赖

compile 'io.reactivex:rxandroid:1.2.1'
compile 'io.reactivex:rxjava:1.2.4'

使用方法

Observing on the main thread

Observable.just("one", "two", "three", "four", "five")
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(/* an Observer */);

这代码在主线程执行Observable，然后通过OnNext提交结果

Observing on arbitrary loopers

Looper backgroundLooper = // ...
Observable.just("one", "two", "three", "four", "five")
        .observeOn(AndroidSchedulers.from(backgroundLooper))
        .subscribe(/* an Observer */)

为了在任意的线程池中使用Observable，创建一个关联的Scheduler，通过AndroidSchedulers.from。这会在新的线程backgroundLooper中执行

Observer and Observable

Observer可以在Observable进行相应的操作。

发出数据
报错
没有数据可以发送时

这三个操作被封装在Observer接口中

相应的方法为
- onNext()
- onError()
- onCompleted()

graph LR
Observable-->subscribe
subscribe-->Observer

被观察者Observable通过订阅subscribe，和Observer观察者关联。

Observable.just(getColorList()).subscribe(new Observer<List<String>>() { 

    @Override 
    public void onCompleted() { } 

    @Override 
    public void onError(Throwable e) { } 

    @Override
    public void onNext(List<String> colors) {
        mSimpleStringAdapter.setStrings(colors);
    }
});

Creating Observables 创建

Create — create an Observable from scratch by calling observer methods programmatically
从调用观察者方法上创建被观察者。
Defer — do not create the Observable until the observer subscribes, and create a fresh Observable for each observer
除非观察者订阅了，否则不会创建被观察者，为每一个观察者创建被观察者。
Empty/Never/Throw — create Observables that have very precise and limited behavior
创建非常单一的行为
From — convert some other object or data structure into an Observable
转换一些实体或者数据结构为被观察者,获取输入数组, 转变单个元素分发
Interval — create an Observable that emits a sequence of integers spaced by a particular time interval
创建一个整形序列的被观察者依照特定的时间
Just — convert an object or a set of objects into an Observable that emits that or those objects
转换一个实体或者实体集成被观察者,获取输入数据, 直接分发, 更加简洁, 省略其他回调
Range — create an Observable that emits a range of sequential integer
创建一个范围的整形序列为一个被观察者
Repeat — create an Observable that emits a particular item or sequence of items repeatedly
重复创建
Start — create an Observable that emits the return value of a function
创建一个函数返回值的被观察者
Timer — create an Observable that emits a single item after a given delay
创建一个特定时间后的被观察者

Create

static <S,T> Observable<T>  create(AsyncOnSubscribe<S,T> asyncOnSubscribe)
Returns an Observable that respects the back-pressure semantics.
static <T> Observable<T>    create(Observable.OnSubscribe<T> f)
This method requires advanced knowledge about building operators and data sources; please consider other standard methods first; Returns an Observable that will execute the specified function when a Subscriber subscribes to it.
static <S,T> Observable<T>  create(SyncOnSubscribe<S,T> syncOnSubscribe)
Returns an Observable that respects the back-pressure semantics.

      Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> mSubscriber) {
                mSubscriber.onNext("1");
                mSubscriber.onNext("2");
                mSubscriber.onNext("3");
                mSubscriber.onCompleted();
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted: ");
            }

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

            @Override
            public void onNext(String mS) {
                Log.i(TAG, "onNext: "+mS);
            }
        });
输出：
MainActivity: onNext: 1
MainActivity: onNext: 2
MainActivity: onNext: 3
MainActivity: onCompleted:

Just

static <T> Observable<T>        just(T value)
Returns an Observable that emits a single item and then completes.
static <T> Observable<T>    just(T t1, T t2)
Converts two items into an Observable that emits those items.
static <T> Observable<T>    just(T t1, T t2, T t3)
Converts three items into an Observable that emits those items.
static <T> Observable<T>    just(T t1, T t2, T t3, T t4)
Converts four items into an Observable that emits those items.
static <T> Observable<T>    just(T t1, T t2, T t3, T t4, T t5)
Converts five items into an Observable that emits those items.
static <T> Observable<T>    just(T t1, T t2, T t3, T t4, T t5, T t6)
Converts six items into an Observable that emits those items.
static <T> Observable<T>    just(T t1, T t2, T t3, T t4, T t5, T t6, T t7)
Converts seven items into an Observable that emits those items.
static <T> Observable<T>    just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8)
Converts eight items into an Observable that emits those items.
static <T> Observable<T>    just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9)
Converts nine items into an Observable that emits those items.
static <T> Observable<T>    just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9, T t10)
Converts ten items into an Observable that emits those items.

返回一项或多项作为被观察者，对多10个

just将单个数据转换为发射那个数据的Observable，Just类似于From，但是From会将数组或Iterable的数据取出然后逐个发射，而Just只是简单的原样发射，将数组或Iterable当做单个数据，如果你传递null给Just，它会返回一个发射null值的Observable。不要误认为它会返回一个空Observable（完全不发射任何数据的Observable）。对于just可以接收1到10个数据，返回一个按参数列表顺序发射这些数据的Observable

Observable.just(1 2, 3, 4)
    .subscribe(new SubscriberInteger>() {
        @Override
        public void onCompleted() {
            Log.e(TAG, "onCompleted: ");
        }

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

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

对于just参数类型可以是多种，如下，传入两个类型数据

Observable.just(0, "one", 6, "two", 8, "three")
    .subscribe(new Subscriber() {
        @Override
        public void onCompleted() {
            Log.e(TAG, "onCompleted: " );
        }

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

        @Override
        public void onNext(Serializable serializable) {
            Log.e(TAG, "onNext: "+serializable.toString());
        }
    });

Defer

static <T> Observable<T>    defer(Func0<Observable<T>> observableFactory)
Returns an Observable that calls an Observable factory to create an Observable for each new Observer that subscribes.

直到有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable，该操作符能保证订阅执行时数据源是最新的数据。

test="旧数据";
Observable observable=Observable.defer(new Func0>() {
    @Override
    public Observablecall() {
        return Observable.just(test);
    }
});
Subscriber subscriber=new Subscriber() {
    public String TAG="RXJAVA";

    @Override
    public void onCompleted() {
        Log.e(TAG, "onCompleted: " );
    }

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

    @Override
    public void onNext(Object o) {
        Log.e(TAG, "onNext: "+o );
    }
};
test="新数据";
observable.subscribe(subscriber);

Empty/Never/Throw

static <T> Observable<T>    empty()
Returns an Observable that emits no items to the Observer and immediately invokes its onCompleted method

static <T> Observable<T>    never()
Returns an Observable that never sends any items or notifications to an Observer.

Empty:创建一个不发射任何数据但是正常终止的Observable，此时会回调onCompleted（）
Never:创建一个不发射数据也不终止的Observable
Error:创建一个不发射数据以一个错误终止的Observable

error操作符需要一个Throwable参数，你的Observable会以此终止。这些操作符默认不在任何特定的调度器上执行，但是empty和error有一个可选参数是Scheduler，如果你传递了Scheduler参数，它们会在你指定的调度器上发送通知。

From

static <T> Observable<T>    from(java.util.concurrent.Future<? extends T> future)
Converts a Future into an Observable.
static <T> Observable<T>    from(java.util.concurrent.Future<? extends T> future, long timeout, java.util.concurrent.TimeUnit unit)
Converts a Future into an Observable, with a timeout on the Future.
static <T> Observable<T>    from(java.util.concurrent.Future<? extends T> future, Scheduler scheduler)
Converts a Future, operating on a specified Scheduler, into an Observable.
static <T> Observable<T>    from(java.lang.Iterable<? extends T> iterable)
Converts an Iterable sequence into an Observable that emits the items in the sequence.
static <T> Observable<T>    from(T[] array)
Converts an Array into an Observable that emits the items in the Array.
static <T> Observable<T>    fromCallable(java.util.concurrent.Callable<? extends T> func)
Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.
static <T> Observable<T>    fromEmitter(Action1<AsyncEmitter<T>> emitter, AsyncEmitter.BackpressureMode backpressure)
Provides an API (via a cold Observable) that bridges the reactive world with the callback-style, generally non-backpressured world.

该操作符是将其它种类的对象和数据类型转换为Observable，如果当你发射的的数据是同一种类型，而不是混合使用Observables和其它类型的数据，会非常方便

Integer[] integers = {1,2, 3, 4};
        Observable observable=Observable.from(integers);
         Subscriber subscriber = new Subscriber() {
            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted");
            }
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, e.getMessage());
            }
            @Override
            public void onNext(Integer i) {
                Log.e(TAG, "onNext："+i);
            }
        };
        observable.subscribe(subscriber);

输出：

onNext：1
onNext：2
onNext：3
onNext：4
onCompleted

from操作符可以转换Future、Iterable和数组。对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据。对于Future，它会发射Future.get()方法返回的单个数据，并且还可以增加通过: from(Future,timeout, timeUnit)指定超时时间，如果执行的时候Future超时会回调onError（）方法。

Interval

static Observable<java.lang.Long>   interval(long initialDelay, long period, java.util.concurrent.TimeUnit unit)
Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter.
static Observable<java.lang.Long>   interval(long initialDelay, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter, on a specified Scheduler.
static Observable<java.lang.Long>   interval(long interval, java.util.concurrent.TimeUnit unit)
Returns an Observable that emits a sequential number every specified interval of time.
static Observable<java.lang.Long>   interval(long interval, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.

该操作符按固定的时间间隔发射一个无限递增的整数序列，它接受一个表示时间间隔的参数和一个表示时间单位的参数，当然该操作符合Timer一样，是在computation调度器上执行的，若想更新UI需要指定Scheduler 为AndroidSchedulers.mainThread()。

 Subscription   subscription = Observable.interval(1, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1() {
                    @Override
                    public void call(Long aLong) {
                        tv.append(" " + aLong + "   ");
                    }
                });

Range

static Observable<java.lang.Integer>    range(int start, int count)
Returns an Observable that emits a sequence of Integers within a specified range.
static Observable<java.lang.Integer>    range(int start, int count, Scheduler scheduler)
Returns an Observable that emits a sequence of Integers within a specified range, on a specified Scheduler.

该操作符创建特定整数序列的Observable，它接受两个参数，一个是范围的起始值，一个是范围的数据的数目。如果你将第二个参数设为0，将导致Observable不发射任何数据（如果设置为负数，会抛异常）。

Observable.range(1,4)
.subscribe(new SubscriberInteger>() {
    public String TAG="RXJAVA";

    @Override
    public void onCompleted() {
        Log.e(TAG, "onCompleted: " );
    }

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

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

Repeat

Observable<T>   repeat()
Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely.
Observable<T>   repeat(long count)
Returns an Observable that repeats the sequence of items emitted by the source Observable at most count times.
Observable<T>   repeat(long count, Scheduler scheduler)
Returns an Observable that repeats the sequence of items emitted by the source Observable at most count times, on a particular Scheduler.
Observable<T>   repeat(Scheduler scheduler)
Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely, on a particular Scheduler.

该操作符是重复的发射某个数据序列，并且可以自己设置重复的次数。当接收到onComplete()会触发重订阅再次重复发射数据,当重复发射数据次数到达后执行onCompleted()。

     String[] strs = {"也许当初忙着微笑和哭泣", "忙着追逐天空中的流星"};
        Observable.from(strs).repeat(2)..subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted: " );
            }

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

            @Override
            public void onNext(String s) {
                Log.e(TAG, "onNext: "+s );
                tv1.append("\n" + s);
            }
        });

Timer

static Observable<java.lang.Long>   timer(long initialDelay, long period, java.util.concurrent.TimeUnit unit)
Deprecated. 
use interval(long, long, TimeUnit) instead
static Observable<java.lang.Long>   timer(long initialDelay, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Deprecated. 
use interval(long, long, TimeUnit, Scheduler) instead
static Observable<java.lang.Long>   timer(long delay, java.util.concurrent.TimeUnit unit)
Returns an Observable that emits one item after a specified delay, and then completes.
static Observable<java.lang.Long>   timer(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits one item after a specified delay, on a specified Scheduler, and then completes.

fromCallable

使用Observable.fromCallable()方法有两点好处：

获取要发送的数据的代码只会在有Observer订阅之后执行。
获取数据的代码可以在子线程中执行。

Observable<List<String>> tvShowObservable = Observable.fromCallable(new Callable<List<String>>() { 

    @Override 
    public List<String> call() { 
        return mRestClient.getFavoriteTvShows(); 
    }
});

注：mRestClient.getFavoriteTvShows(); 是一个网络请求

mTvShowSubscription = tvShowObservable
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Observer<List<String>>() {

        @Override 
        public void onCompleted() { }

        @Override 
        public void onError(Throwable e) { }

        @Override 
        public void onNext(List<String> tvShows){
            displayTvShows(tvShows);
        }
    });

Single

Observable还有一个精简版，叫做Single。Single几乎和Observable一模一样，但其回调方法不是onComplete()/onNext()/onError()，而是onSuccess()/onError()。

Single<List<String>> tvShowSingle = Single.fromCallable(new Callable<List<String>>() { 
    @Override
    public List<String> call() throws Exception {
        mRestClient.getFavoriteTvShows(); 
    }
});

mTvShowSubscription = tvShowSingle
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new SingleSubscriber<List<String>>() {

        @Override 
        public void onSuccess(List<String> tvShows) {
            displayTvShows(tvShows); 
        }

        @Override 
        public void onError(Throwable error) {
            displayErrorMessage(); 
        } 
    });