RxJava简单知识

8. 函数响应式编程

• 响应式编程是一种面向数据流和变化传播的编程范式，数据更新更是相关联的。把函数编程里的一套思路和响应式编程合起来就是函数响应式编程。
• 函数响应式编程可以极大地简化项目，特别是处理嵌套回调的异步事件、复杂的列表过滤和变换或者时间相关问题。 在Android开发中使用函数响应式编程的主要有两大框架：一个是RxJava，另一个是Google推出的Agera。
• 个人：响应式编程是一种编程范式，将数据流视为事件流，用操作符构建异步、非阻塞的数据处理管道。数据流可以视为一个事件序列，可以通过观察者模式来监视和处理这个序列中的事件

RxJava概述

1. ReactiveX 与 RxJava

• 在讲到RxJava之前我们首先了解ReactiveX，RxJava是ReactiveX的一种实现。
• 微软给的定义是Rx是一个函数库，开发者可以利用可观察序列和LINQ风格查询操作符来编写异步和基于事件的程序。
• 用Observables表示异步数据流，用LINQ操作符查询异步数据流，用Schedulers参数化异步数据流的并发处理。

2. 为何要用RxJava

• 当请求数量很大的时候，AsyncTask和Handler的代码逻辑会变得复杂。但是RxJava可以创建一个Observable对象来干活，然后使用各种操作符建立起来的链式操作，就如同流水线一样。

3. RxJava与观察者模式

• RxJava拓展了观察者模式，RxJava也有四个角色：Observable、Observer、Subscriber和Subject。
• Observable和Observer通过subscribe方法实现订阅关系，Observable就可以在需要的时候通知Observer。

RxJava的基本实现

• 配置gradle

implementation 'io.reactivex.rxjava3:rxandroid:3.0.2'
implementation 'io.reactivex.rxjava3:rxjava:3.1.5'

• RxAndroid是RxJava在Android平台的拓展。它包含了一些能够简化Android开发的工具，比如特殊的调度器。

1. 创建Observer(观察者)

• 这里使用了Subscriber，如果我们要实现简单的功能，也可以用到Observer来创建观察者。Observer是一个接口，而上面用到的Subscribr是在Observer的基础上进行了拓展。
• 重点：在RxJava3中，不再使用Subscriber作为Observer的实现类。取而代之的是Disposable和Consumer。其中Consumer可以用来处理Observable发射的每个元素，而Disposable则用于取消订阅。
  

package com.example.rxjava;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;

import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        
        String TAG = "Ning_RxJava";
        
        //1.创建Observer(观察者)
        Subscriber subscriber = new Subscriber() {
            @Override
            public void onSubscribe(Subscription s) {
                Log.d(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Object o) {
                Log.d(TAG, "onNext");
            }

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

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        } ;
    }
}

• 下面是简单的功能，用到Observer来实现。

Observer<String> observer = new Observer<String>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {
        Log.d(TAG, "onSubscribe");
    }

    @Override
    public void onNext(@NonNull String s) {
        Log.d(TAG, "onNext");
    }

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

    @Override
    public void onComplete() {
        Log.d(TAG, "onComplete");
    }
};

2. 创建Observable(被观察者)

• 被观察者决定什么时候触发事件、以及触发怎样的事件。理解为事件的发布者
• RxJava使用create方法来创建一个Observable，并为它定义事件触发规则。
  

Observable observable = Observable.create(new ObservableOnSubscribe<Object>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<Object> emitter) throws Throwable {
        emitter.onNext("杨影枫");
        emitter.onNext("月眉儿");
        emitter.onComplete();
    }
});

• just操作符会依次调用onNext(“杨影枫”)、onNext(“月眉儿”)、onComplete()。

Observable observable1 = Observable.just("杨影枫" , "月眉儿");

• 还可以用from操作符实现。
• 当前代码的调用顺序和just一样。

String[] words = {"杨影枫" , "月眉儿"};
Observable observable2 = Observable.fromArray(words);

3. subscribe（订阅）

• 订阅只需要一行代码就可以。 被观察者.订阅(观察者)

observable.subscribe(observer);
observable1.subscribe(observer);
observable2.subscribe(observer);

4. 消费者Consumer

• 相比Observer更加简化，日常开发使用的更多
  

Disposable d = Observable.create(new ObservableOnSubscribe<Object>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<Object> emitter) throws Throwable {
        emitter.onNext("1");
        emitter.onNext("22");
        emitter.onNext("333");
        emitter.onError(new Throwable("手动丢出异常"));
    }
}).subscribe(new Consumer<Object>() {
    @Override
    public void accept(Object o) throws Throwable {
        Log.d(TAG, "accept: " + o);
    }
}, new Consumer<Throwable>() {
    @Override
    public void accept(Throwable throwable) throws Throwable {
        Log.d(TAG, "accept: " + throwable);
    }
});

RxJava的不完整回调

• 前面介绍了回调的接收主要依赖于subscribe(Observer)、subscribe(Consumer)。此外，RxJava还提供了另一种回调方式，也就是不完整回调。
• 在了解不完整回调前，我们要先了解Action。

public interface Action {
    /**
     * Runs the action and optionally throws a checked exception.
     * @throws Throwable if the implementation wishes to throw any type of exception
     */
    void run() throws Throwable;
}

• 来看Function和Function9
• Function后的数字表示回调的参数类型数量

public interface Function<@NonNull T, @NonNull R> {
    /**
     * Apply some calculation to the input value and return some other value.
     * @param t the input value
     * @return the output value
     * @throws Throwable if the implementation wishes to throw any type of exception
     */
    R apply(T t) throws Throwable;
}

public interface Function9<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R> {
    /**
     * Calculate a value based on the input values.
     * @param t1 the first value
     * @param t2 the second value
     * @param t3 the third value
     * @param t4 the fourth value
     * @param t5 the fifth value
     * @param t6 the sixth value
     * @param t7 the seventh value
     * @param t8 the eighth value
     * @param t9 the ninth value
     * @return the result value
     * @throws Throwable if the implementation wishes to throw any type of exception
     */
    R apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) throws Throwable;
}

• 实现了apply，相当于定义了一个不完整的回调函数，并将其作为参数传递给map方法。
• 可以将我们的字符串类型的数据流，进行某种处理，并返回一个新的字符串类型的数据流。

Function<String , String> onNextFunction = new Function<String, String>() {
    @Override
    public String apply(String s) throws Throwable {
        Log.d(TAG, "apply " + s);
        return s + "!";
    }
};

observable1.map(onNextFunction).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Throwable {
        Log.d(TAG, "accept: " + s);
    }

});

RxJava的Subject

• RxJava3.0中的Subject是一种特殊的Observable，它可以充当Observer和Observable两个角色，即既可以发射数据，也可以订阅数据。Subject可以将多个Observable转换成一个Observable，并且可以动态添加和删除订阅者。