RxJava ——Single
1、Single介绍
特点：
- 总是只发送一个数据值或者发送一个错误；发送完后就会终止订阅关系，而不是发射一系列的值。
使用说明：
订阅Single Observable 主要需要实现onSuccess ,OnError两个方法；他只会调用这两个方法中的其中一个，调用后订阅关系就会终止。
总结：
- 1、Single适合执行相对独立的单次任务；
- 2、Single 发送的要不是成功，要不是失败，仅有两种情况 ；
- 3、Single的执行完一次发射任务后，后续任务不再执行。
2、使用
private void testSigngleOperator(){
Single.create(new Single.OnSubscribe<String>() {
@Override
public void call(SingleSubscriber<? super String> singleSubscriber) {
singleSubscriber.onSuccess("success");
}
}).subscribe(new SingleSubscriber<String>() {
@Override
public void onSuccess(String value) {
System.out.print("onSuccess:"+value);
}
@Override
public void onError(Throwable error) {
System.out.print("onError:"+error);
}
});
}
输出的结果是：
onSuccess:success
Single也是可以使用onNext, onError, onCompleted这个回调的：
private void testSigngleOperator(){
Single.create(new Single.OnSubscribe<String>() {
@Override
public void call(SingleSubscriber<? super String> singleSubscriber) {
singleSubscriber.onSuccess("success");
}
}).subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println("onError:"+e.getMessage());
}
@Override
public void onNext(String s) {
System.out.println("onNext:"+s);
}
});
}
输出的结果是：
onNext:success
onCompleted
3、Single的操作符
使用
1、“just”，在RxJava中Single的just支持传入任意参数。
使用方法如:
Single.just(T value).subscribe();
public class MapTest {
public static void main(String[] args) {
MapTest mapTest = new MapTest();
mapTest.singleTest1();
}
private int addValue(int a, int b) {
return a + b;
}
private void singleTest1() {
Single
.just(addValue(1, 2))
.doOnError(throwable -> System.out.println(throwable.toString()))
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
System.out.println("just: " + integer);
}
});
}
}
或者简化lambda表达式
private void singleTest1() {
Single
.just(addValue(1, 2))
.subscribe(
integer -> System.out.println("just: " + integer),
throwable -> System.out.println(throwable.getMessage())
);
}
输出
just: 3
这里仅仅只是RxJava的开始，其中just()方法无论如何都只会在当前线程里执行。所以即使看上去有异步的过程，但其实这是个同步的过程！
2、create操作符
public class MapTest {
public static void main(String[] args) {
MapTest mapTest = new MapTest();
mapTest.singleTest();
}
private int addValue(int a, int b) {
return a + b;
}
private void singleTest() {
Single.create((SingleOnSubscribe<Integer>) singleEmitter -> {
singleEmitter.onSuccess(addValue(1, 2));
System.out.println("subscribe:" );
})
.doOnSuccess(integer -> System.out.println("doOnSuccess:" + integer))
.doOnError(throwable -> System.out.println(throwable.toString()))
.doAfterSuccess(integer -> System.out.println("doAfterSuccess: "))
.subscribeOn(Schedulers.io())
.subscribe(integer -> System.out.println("onSuccess:" + integer)
);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
值得注意的是之前我们使用的just()是一种特殊的create()，它不能指定Schedulers。只能在当前线程中运行，而create()可以指定Schedulers实现异步处理。且just()不管是否被subscribe()订阅均会被调用，而create()如果不被订阅是不会被调用的。所以我们通常可以用just()传递简单参数，而用create()处理复杂异步逻辑。
3、map操作符
private void singleTest3() {
Single
.just(addValue(1, 2))
.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "test: " + integer;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println(s);
}
}
);
}
简化
private void singleTest3() {
Single
.just(addValue(1, 2))
.map(integer -> "test: " + integer)
.subscribe(s -> System.out.println(s)
);
}
4、flatMap操作符
List<String> s = Arrays.asList("Java", "Android", "Ruby", "Ios", "Swift");
Single
.just(s)
.toObservable()
.flatMapIterable( list -> list)
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println(s);
}
});
或者：
Observable
.just(s)
.flatMap(new Function<List<String>, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(List<String> strings) throws Exception {
return Observable.fromIterable(strings);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println(s);
}
});
5、flatMapObservable操作符
刚刚说到flatMap()和map()类似，区别在于flatMap可以返回多个值，而map只能返回一个。但在Single中flatMap只能返回Single，几乎等同于map实用性不高。而flatMapObservable就不同了，它支持将Single转化为Observable对象，可以返回多个值。下面这个例子介绍如何将Single转化为Observable。
Single
.just(1)
.flatMapObservable(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
return Observable.just("Java", "Android", "Ruby", "Ios", "Swift");
}
})
.subscribe(
str -> System.out.println(str)
);
输出
Java
Android
Ruby
Ios
Swift
subscribeOn操作符、observeOn
subscribeOn操作符
- 用于指定异步任务的线程，常见的有:
Schedulers.computation( )；// 计算线程
Schedulers.from(executor);// 自定义
Schedulers.immediate();// 当前线程
Schedulers.io();// io线程
Schedulers.newThread();// 创建新线程
Schedulers.trampoline();// 当前线程队列执行
observeOn
- 指定回调所在线程
// 常见的为，即Android UI线程
AndroidSchedulers.mainThread();