RxJava 学习笔记（二）

给 Android 开发者的 RxJava 详解

这篇文章已经写的很详细了。但是毕竟是别人的东西 ，既然是学习笔记，我当然要写写自己的总结或者摘要，剔除那些不需要的话

https://github.com/ReactiveX/RxJava

https://github.com/ReactiveX/RxAndroid

本人感觉只要掌握了 map 和 flatmap 其实就已经可以算入门了

一.RxJava的观察者模式

• 上一篇已经写了两个demo 来重温 传统观察者模式 还有Rxjava的配置Rxjava 学习笔记（一）
• Rxjava 是什么 –> 异步

• Rxjava 优点 –> 简洁，在一条链上（链式编程），当然最重要的是可以用来装逼！！！装逼！装逼！装逼！重要的事情说三篇！

• RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer

RxJava的观察者模式：

                    onNext(param)
                    onCompleted()
                    onError(error)
Observable ——————> Observer

二.基本实现

• 步骤：创建Observer（观察者），创建Observable（被观察者），Subscribe（订阅）

1）创建Observer（观察者）

Observer<String> observer = new Observer<String>() {
    @Override
    public void onNext(String s) {
            Log.d(tag, "Item: " + s);
    }

    @Override
    public void onCompleted() {
        Log.d(tag, "Completed!");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(tag, "Error!");
    } 
};  

除了 Observer 接口之外，RxJava 还内置了一个实现了 Observer 的抽象类：Subscriber。 Subscriber 对 Observer 接口进行了一些扩展，但他们的基本使用方式是完全一样的：

Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onNext(String s) {
        Log.d(tag, "Item: " + s);
    }

    @Override
    public void onCompleted() {
        Log.d(tag, "Completed!");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(tag, "Error!");
    }
};

不仅基本使用方式一样，实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能，选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点：

onStart(): 这是 Subscriber 增加的方法。它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， onStart() 就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用 doOnSubscribe() 方法，具体可以在后面的文中看到。

unsubscribe(): 这是 Subscriber 所实现的另一个接口 Subscription 的方法，用于取消订阅。在这个方法被调用后，Subscriber 将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed() 先判断一下状态。 unsubscribe() 这个方法很重要，因为在 subscribe() 之后， Observable 会持有 Subscriber 的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如 onPause() onStop() 等方法中）调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。

2）创建Observable（被观察者）

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("Hello");
        subscriber.onNext("Hi");
        subscriber.onNext("Aloha");
        subscriber.onCompleted();
    }
});

create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法， RxJava 还提供了一些方法用来快捷创建事件队列，例如：

• just(T...): 将传入的参数依次发送出来。

Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

• from(T[]) / from(Iterable<? extends T>): 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。

String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

3） Subscribe (订阅)

observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);

有人可能会注意到， subscribe() 这个方法有点怪：它看起来是『observalbe 订阅了 observer / subscriber』而不是『observer / subscriber 订阅了 observalbe』，这看起来就像『杂志订阅了读者』一样颠倒了对象关系。这让人读起来有点别扭，不过如果把 API 设计成 observer.subscribe(observable) / subscriber.subscribe(observable) ，虽然更加符合思维逻辑，但对流式 API 的设计就造成影响了，比较起来明显是得不偿失的。

Observable.subscribe(Subscriber) 的源代码

public final Subscription subscribe(Subscriber<? super T> subscriber) {
// 首先进入这个方法，返回Subscription，好像是为了方便 取消订阅
    return Observable.subscribe(subscriber, this);
}


private static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {

    if (subscriber == null) {
        throw new IllegalArgumentException("observer can not be null");
    }
    if (observable.onSubscribe == null) {
        throw new IllegalStateException("onSubscribe function can not be null.");
    }

    // ☆ 在这里调用了onStart（）
    subscriber.onStart();

    // 转换为SafeSubscriber 不知道为什么转为他 但是看名字应该是安全的意思，无非就是做了些安全的操作，懒得往下看
    if (!(subscriber instanceof SafeSubscriber)) {
        subscriber = new SafeSubscriber<T>(subscriber);
    }

    try {
        // hook.onSubscribeStart(observable, observable.onSubscribe)--> return onSubscribe
        // ☆ 所以相当于调用了onSubscriber 的 call 方法
        hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
        // 下面其实他就是直接返回 subscriber 没有做别的操作
        return hook.onSubscribeReturn(subscriber);
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // 如果执行onSubscribe出现未处理的错误,我们会传播的
        try {
            subscriber.onError(hook.onSubscribeError(e));
        } catch (Throwable e2) {
            // 表示调用本身的onError失败 ， 所以就 throw 出去
            Exceptions.throwIfFatal(e2);
            RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
            // TODO 这边标记为TODO ，其实看他的源码他是直接返回了r，并没有做什么事情，我们其实可以在这边自定义导致错误的错误处理
            hook.onSubscribeError(r);
            // TODO why aren't we throwing the hook's return value.
            throw r;
        } 
        return Subscriptions.unsubscribed();  // 取消订阅
    }
}

可以看到，subscriber() 做了3件事：
>
1. 调用 Subscriber.onStart() 。这个方法在前面已经介绍过，是一个可选的准备方法。
2. 调用 Observable 中的 OnSubscribe.call(Subscriber) 。在这里，事件发送的逻辑开始运行。从这也可以看出，在 RxJava 中， Observable 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当 subscribe() 方法执行的时候。
3. 将传入的 Subscriber 作为 Subscription 返回。这是为了方便 unsubscribe().

不完整定义的回调

除了 subscribe(Observer) 和 subscribe(Subscriber) ，subscribe()还支持不完整定义的回调，RxJava 会自动根据定义创建出 Subscriber 。形式如下：

Action1<String> onNextAction = new Action1<String>() {
    // onNext()
    @Override
    public void call(String s) {
            Log.d(tag, s);
    }
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
    // onError()
    @Override
    public void call(Throwable throwable) {
      // Error handling
    }
};
Action0 onCompletedAction = new Action0() {
    // onCompleted()
    @Override
    public void call() {
        Log.d(tag, "completed");
    }
};

// 自动创建 Subscriber ，并使用 onNextAction 来定义 onNext()
observable.subscribe(onNextAction);
// 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()
observable.subscribe(onNextAction, onErrorAction);
// 自动创建 Subscriber ，并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()
observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

简单解释一下这段代码中出现的 Action1和Action0。 Action0是 RxJava 的一个接口，它只有一个方法 call()，这个方法是无参无返回值的；由于 onCompleted() 方法也是无参无返回值的，因此Action0 可以被当成一个包装对象，将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe()以实现不完整定义的回调。这样其实也可以看做将 onCompleted()方法作为参数传进了 subscribe()，相当于其他某些语言中的『闭包』。 Action1 也是一个接口，它同样只有一个方法 call(T param)，这个方法也无返回值，但有一个参数；与 Action0同理，由于onNext(T obj) 和 onError(Throwable error)也是单参数无返回值的，因此 Action1 可以将 onNext(obj) 和 onError(error)打包起来传入 subscribe() 以实现不完整定义的回调。事实上，虽然Action0和 Action1在 API 中使用最广泛，但 RxJava 是提供了多个 ActionX 形式的接口 (例如 Action2, Action3) 的，它们可以被用以包装不同的无返回值的方法。