Android ：RxJava学习笔记之Single

Posted 2021-11-23 JMW1407

RxJava ——Single

• 1、Single介绍
• 2、使用
• 3、Single的操作符
• • 1、使用
• 参考

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的操作符

Single使用及示例

1、使用

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操作符

参考

1、https://www.jianshu.com/p/6569b170fd4a
2、