En la última sección aprendimos sobre el cambio de subprocesos en RxJava. Hoy comenzaremos a conocer sus potentes operadores. Algunas personas pueden preguntar, ¿para qué se utilizan los operadores? En mi opinión, el operador es como el alma de rxjava, que recorre todo el ciclo de vida de lo observado y el observador, desde la creación hasta la suscripción, la transmisión de datos, la cancelación de la suscripción y otros enlaces. Bien, comencemos nuestro estudio a continuación.
Crear operador
operador create ()
- Vista previa del método:
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
- Papel:
Crea un observador
- Como usar
Observable<String> mObservable = Observable.create(new ObservableOnSubscribe<String>() {
emitter.onNext(" 1");
emitter.onNext("2");
emitter.onNext("3");
emitter.onNext("4");
emitter.onComplete();
emitter.onNext(" 1");
emitter.onNext(" 2");
}
});
- Combate real
Observable<String> mObservable = Observable.create(new ObservableOnSubscribe<String>() { // 1.创建 Observable对象
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext(" 1");
emitter.onNext("2");
emitter.onNext("3");
emitter.onNext("4");
emitter.onComplete();
emitter.onNext(" 1");
emitter.onNext(" 2");
}
});
Observer<String> mObserver = new Observer<String>() { // 2.创建observer
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError: " + e);
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete: ");
}
};
mObservable.subscribe(mObserver);// 3.开始调用
Como puede ver, a través del operador create (), creamos un observador Observable, reescribiendo el método subscribe () para emitir datos a través del ObservableEmitter.
operador just ()
- Vista previa del método
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6) { }
- Función y características
Cree una persona observada y envíe eventos. El número de eventos enviados no puede exceder de 10.
- Como usar
Observable.just(1,2,3,4,5,6).subscribe(new Observer<Integer>() {
private Disposable mDisposable;
@Override
public void onSubscribe(Disposable d) {
mDisposable=d;
Log.d(TAG, "onSubscribe: " + d.isDisposed());
}
@Override
public void onNext(Integer s) {
Log.d(TAG, "onNext: 接收到的数据是:"+s);
if (s>3){
mDisposable.dispose();
}
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
del operador
El RxJava2 del operador opera principalmente los siguientes cuatro: puede crear Observables que envían matrices, Iterables y tareas asincrónicas.
//数组
public static <T> Observable<T> fromArray(T... items)
//集合
public static <T> Observable<T> fromIterable(Iterable<? extends T> source)
//异步任务
public static <T> Observable<T> fromFuture(Future<? extends T> future)
//异步任务+超时时间
public static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit)
//异步任务+超时时间+线程调度器
public static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit, Scheduler scheduler)
//异步任务+线程调度器
public static <T> Observable<T> fromFuture(Future<? extends T> future, Scheduler scheduler)
//Reactive Streams中的发布者，使用方式类似create操作符，事件的发送由发布者(被观察者)自行决定
public static <T> Observable<T> fromPublisher(Publisher<? extends T> publisher)
Operador fromArray ()
- Vista previa del método
public static <T> Observable<T> fromArray(T... items) { ...}
-
Función y características:
- Al igual que solo, puede enviar datos, cargar los datos en forma de matriz y luego enviar, puede enviar más de 10 datos.
- Al observar el código fuente de just (), podemos ver que los datos enviados por just () en realidad están cargando los datos en una matriz y enviándolos desde fromArray (), por lo que just () significa que fromArray () envía menos de 10 datos Versión Lite en caso.
@CheckReturnValue @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> just(T item1, T item2, T item3, T item4) { ObjectHelper.requireNonNull(item1, "item1 is null"); ObjectHelper.requireNonNull(item2, "item2 is null"); ObjectHelper.requireNonNull(item3, "item3 is null"); ObjectHelper.requireNonNull(item4, "item4 is null"); return fromArray(item1, item2, item3, item4); } -
Como usar
String[] strArray = {"kotlin","java","python","C++"};
Observable<String>observable1=Observable.fromArray(strArray);
Operador fromIterable ()
- Vista previa del método
public static <T> Observable<T> fromIterable(Iterable<? extends T> source) {...}
- Efecto
Cree un observador y envíe la colección directamente al observador. Sabemos que, dado que los datos enviados pueden ser subdesarrollados de forma individual o múltiple, o pueden enviarse en forma de matriz, podemos enviar la colección directamente, por supuesto, a través del operador formIterable () Realizado
- Como usar
List<String> list = new ArrayList<>();
list.add("kotlin");
list.add("java");
list.add("C++");
list.add("python");
Observable.fromIterable(list);
Operador fromCallable ()
- Vista previa del método
public static <T> Observable<T> fromCallable(Callable<? extends T> supplier) { }
- Efecto
Callable se encuentra debajo del paquete java.util.concurrent, similar a Runnable, pero con un valor de retorno. El evento emitido desde fromCallable se envía desde el hilo principal. Para recibir el valor de emisión de Observable, use observeOn para cambiar al hilo Principal.
- Como usar
Observable.fromCallable(new Callable<String>() {
@Override
public String call() throws Exception {
return "测试一下";
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
System.out.println("onNext():"+"接收到的数据为"+s+"\n所在线程为:"+Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
Operador fromFuture ()
public static <T> Observable<T> fromFuture(Future<? extends T> future) {...}
Cuando presentamos el operador from, fromFuture () tiene cuatro métodos sobrecargados, a saber:
//异步任务
public static <T> Observable<T> fromFuture(Future<? extends T> future)
//异步任务+超时时间
public static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit)
//异步任务+超时时间+线程调度器
public static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit, Scheduler scheduler)
//异步任务+线程调度器
public static <T> Observable<T> fromFuture(Future<? extends T> future, Scheduler scheduler)
Para fromFuture (), en realidad es similar a Runnable, pero la diferencia es que Runnable no devolverá el resultado después de la ejecución, y fromFuture () devolverá el resultado de la ejecución al observador.
// 异步任务
FutureTask<Integer> mFutureTask = new FutureTask<>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("---------开始执行任务------"+Thread.currentThread().getName());
Thread.sleep(3000); // 延时3秒以计算1+2+3+4+...并将结果返回
int sum = 0;
for (int i = 0; i <= 10; i++) {
sum += i;
}
return sum;
}
});
Observable.
fromFuture(mFutureTask)
.doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
mFutureTask.run();
}
})
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
System.out.println("---------处理完毕并接收数据为:------"+integer+" "+Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
System.out.println("---------处理失败了:------"+e+Thread.currentThread().getName());
}
@Override
public void onComplete() {
}
} );
}
En el programa anterior, retrasamos el cálculo en 3 segundos y luego devolvimos el resultado al observador suscrito.
Bueno, hoy presentaré mucho sobre todo. El próximo artículo continuará aprendiendo otros operadores poderosos de Rxjava.
