需要在buld.gradle中加入compile 'io.reactivex:rxjava-async-util:0.21.0'
一、start
返回一个Observable,它发射一个类似于函数声明的值。编程语言有很多种方法可以从运算结果中获取值,它们的名字一般叫functions, futures, actions, callables, runnables
等等。在Start
目录下的这组操作符可以让它们表现得像Observable,因此它们可以在Observables调用链中与其它Observable搭配使用。Start
操作符的多种RxJava实现都属于可选的rxjava-async
模块。
rxjava-async
模块包含start
操作符,它接受一个函数作为参数,调用这个函数获取一个值,然后返回一个会发射这个值给后续观察者的Observable。
注意:这个函数只会被执行一次,即使多个观察者订阅这个返回的Observable。
Observable<Integer> observable = Async.start(new Func0<Integer>() {
@Override
public Integer call() {
//函数内为异步操作
try {
Thread.sleep(5 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 20;
}
});
Subscriber<Integer> subscriber = new Subscriber<Integer>() {
@Override
public void onNext(Integer v) {
Log.e(TAG, "onNext................." + v);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
observable.subscribe(subscriber);
5s后才输出打印结果
运行结果:
二、toAsync
rxjava-async
模块还包含这几个操作符:toAsync
, asyncAction
, 和asyncFunc
。它们接受一个函数或一个Action作为参数。对于函数(functions),这个操作符调用这个函数获取一个值,然后返回一个会发射这个值给后续观察者的Observable(和start
一样)。对于动作(Action),过程类似,但是没有返回值,在这种情况下,这个操作符在终止前会发射一个null
值。
注:这个函数或动作只会被执行一次,即使多个观察者订阅这个返回的Observable。
Func0<Observable<Integer>> func0 = Async.toAsync(new Func0<Integer>() {
@Override
public Integer call() {
//函数内为异步操作
try {
Thread.sleep(5 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 20;
}
});
Observable<Integer> observable = func0.call();
Subscriber<Integer> subscriber = new Subscriber<Integer>() {
@Override
public void onNext(Integer v) {
Log.e(TAG, "onNext................." + v);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
observable.subscribe(subscriber);
运行结果:
三、startFuture
xjava-async
模块还包含一个startFuture
操作符,传递给它一个返回Future
的函数,startFuture
会立即调用这个函数获取Future
对象,然后调用Future
的get()
方法尝试获取它的值。它返回一个发射这个值给后续观察者的Observable。
final Future<Integer> future = Executors.newCachedThreadPool().submit(new Task());
Observable<Integer> observable = Async.startFuture(new Func0<Future<Integer>>() {
@Override
public Future<Integer> call() {
//函数内为异步操作
return future;
}
});
Subscriber<Integer> subscriber = new Subscriber<Integer>() {
@Override
public void onNext(Integer v) {
Log.e(TAG, "onNext................." + v);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
observable.subscribe(subscriber);
运行结果:
10s后才输出打印结果
四、deferFuture
deferFuture中的函数可以异步执行一些操作,当完成后返回一个Observable,但是这个Observable不会立刻发射数据,直到开始订阅时。
rxjava-async
模块还包含一个deferFuture
操作符,传递给它一个返回Future
的函数(这个Future
返回一个Observable
),deferFuture
返回一个Observable,但是不会调用你提供的函数,知道有观察者订阅它返回的Observable。这时,它立即调用Future
的get()
方法,然后镜像发射get()
方法返回的Observable发射的数据。
用这种方法,你可以在Observables调用链中包含一个返回Observable的Future
对象。
Observable<Long> observable = Observable.interval(1,TimeUnit.SECONDS).take(5);
final Future<Observable<Integer>> future = Executors.newCachedThreadPool().submit(new ObservableTask());
final Observable<Integer> observable1 = Async.deferFuture(new Func0<Future<Observable<Integer>>>() {
@Override
public Future<Observable<Integer>> call() {
return future;
}
});
final Subscriber<Integer> subscriber1 = new Subscriber<Integer>() {
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext1................." + integer);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted1.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError1.....................");
}
};
Subscriber<Long> subscriber = new Subscriber<Long>() {
@Override
public void onNext(Long integer) {
Log.e(TAG, "onNext................." + integer);
if(integer == 4){
observable1.subscribe(subscriber1);
}
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
observable.subscribe(subscriber);
运行结果:
五、fromAction
当fromAction()中的函数Action0执行完成后发射数据。Action无返回结果。rxjava-async
模块还包含一个fromAction
操作符,它接受一个Action
作为参数,返回一个Observable,一旦Action终止,它发射这个你传递给fromAction
的数据。
final int result = 1;
final Observable<Integer> observable = Async.fromAction(new Action0() {
@Override
public void call() {
for(int i=1;i<10;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},result);
final Subscriber<Integer> subscriber = new Subscriber<Integer>() {
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext1................." + integer);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted1.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError1.....................");
}
};
observable.subscribe(subscriber);
六、fromCallable
当fromCallable中的函数运行完成后将其结果发射出去。rxjava-async
模块还包含一个fromCallable
操作符,它接受一个Callable
作为参数,返回一个发射这个Callable
的结果的Observable。
final Observable<Integer> observable = Async.fromCallable(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int result = 1;
for(int i=1;i<10;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
result *= i;
}
return result;
}
});
final Subscriber<Integer> subscriber = new Subscriber<Integer>() {
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext1................." + integer);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted1.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError1.....................");
}
};
observable.subscribe(subscriber);
运行结果:
七、fromRunnable
当run方法执行完成后发送传入的参数数据。rxjava-async
模块还包含一个fromRunnable
操作符,它接受一个Runnable
作为参数,返回一个Observable,一旦Runnable终止,它发射这个你传递给fromRunnable
的数据。
//当runnable执行完成后所需发射的数据
int result = 20;
Observable<Integer> observable = Async.fromRunnable(new Runnable() {
@Override
public void run() {
for(int i=1;i<10;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},result);
Subscriber<Integer> subscriber = new Subscriber<Integer>() {
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext1................." + integer);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted1.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError1.....................");
}
};
observable.subscribe(subscriber);
运行结果:
八、forEachFuture
rxjava-async
模块还包含一个forEachFuture
操作符。它其实不算Start
操作符的一个变体,而是有一些自己的特点。你传递一些典型的观察者方法(如onNext, onError和onCompleted)给它,Observable会以通常的方式调用它。但是forEachFuture
自己返回一个Future
并且在get()
方法处阻塞,直到原始Observable执行完成,然后它返回,完成还是错误依赖于原始Observable是完成还是错误。
如果你想要一个函数阻塞直到Observable执行完成,可以使用这个操作符。
private void testForEachFuture() {
Async.forEachFuture(Observable.just(1, 2, 3, 4, 5),
new Action1<Integer>() {
@Override
public void call(Integer integer) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
newInfo(integer);
}
});
}
private void newInfo(Integer integer){
Log.e(TAG, "newInfo.................收到的数据是:" + integer+"..............转换成:"+integer*20);
}
九、runAsync
任何时候都可以通过subscription的unsubscrip来停止订阅。rxjava-async
模块还包含一个runAsync
操作符。它很特殊,返回一个叫做StoppableObservable
的特殊Observable。传递一个Action
和一个Scheduler
给runAsync
,它返回一个使用这个Action
产生数据的StoppableObservable
。这个Action
接受一个Observable
和一个Subscription
作为参数,它使用Subscription
检查unsubscribed
条件,一旦发现条件为真就立即停止发射数据。在任何时候你都可以使用unsubscribe
方法手动停止一个StoppableObservable
(这会同时取消订阅与这个StoppableObservable
关联的Subscription
)。
由于runAsync
会立即调用Action
并开始发射数据,在你创建StoppableObservable之后到你的观察者准备好接受数据之前这段时间里,可能会有一部分数据会丢失。如果这不符合你的要求,可以使用runAsync
的一个变体,它也接受一个Subject
参数,传递一个ReplaySubject
给它,你可以获取其它丢失的数据了。在RxJava中还有一个版本的From
操作符可以将Future转换为Observable,与start
相似。
//action所需要执行的线程
Scheduler scheduler = Schedulers.newThread();
Action2<? super Observer<? super Integer>, ? super Subscription> action = new Action2<Observer<? super Integer>, Subscription>() {
@Override
public void call(Observer<? super Integer> observer, Subscription subscription) {
int i = 1;
while (!subscription.isUnsubscribed()){
Log.e(TAG, "call................observer.onNext");
observer.onNext(i);
i += 1;
if(i == 4){
subscription.unsubscribe();
observer.onCompleted();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
StoppableObservable<Integer> stoppableObservable = Async.runAsync(scheduler, action);
Subscriber<Integer> subscriber = new Subscriber<Integer>() {
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext................." + integer);
}
@Override
public void onCompleted() {
Log.e(TAG, "onCompleted.................");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError.....................");
}
};
stoppableObservable.subscribe(subscriber);
运行结果: