Observable
Observable 是第一个核心类。该类包含了 Rx 中的很多实现，以及所有核心的操作函数（operator、或者说 操作符）。
Observer/Consumer
Observer是一个接口，定义了onSubscribe(),onNext(),onError(),onComplete()可以操作Observable 发射的事件流
Subscriber 是 Observer 的一个实现。 Subscriber 实现了其他一些额外的功能，可以作为我们实现 Observer 的基类。
Subject
Subject 是 Observable 的一个扩展，同时还实现了 Observer 接口。第一眼看上去可能有点奇怪，但是在有些场合下使用 Subject 将会非常便捷。他们可以像 Observer 一样接收事件，同时还可以像 Observable 一样把接收到的事件再发射出去。这种特性非常适合 Rx 中的接入点，当你的事件来至于 Rx 框架之外的代码的时候，你可以把这些数据先放到 Subject 中，然后再把 Subject转换为一个 Observable，就可以在 Rx 中使用它们了。你可以把 Subject 当做 Rx 中的 事件管道。
subscribe()
subscribe()是联系Observable和Observer的桥梁。
使用RxJava的基本流程
1.创建Observable
Observable observable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter e) throws Exception {
try {
e.onNext("A");
e.onNext("A");
e.onNext("A");
e.onComplete();
} catch (Exception ex) {
e.onError(ex);
}
}
});
2.创建Observer
Observer observer = new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(@NonNull String s) {
Log.i(TAG, "onNext: s = " + s);
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(TAG, "onError: ", e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
3.subscribe()
subscribe()有多个重载的方法:
public final Disposable subscribe(Consumer onNext) {}
public final Disposable subscribe(Consumer onNext, Consumer onError) {}
public final Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete) {}
public final Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete, Consumer onSubscribe) {}
public final void subscribe(Observer observer) {}
- 不带任何参数的subscribe() 表示下游不关心任何事件
- 带有一个Consumer参数的方法表示下游只关心onNext事件, 其他的事件我假装没看见, 因此我们如果只需要onNext事件可以这么写:
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
Log.d(TAG, "emit 1");
emitter.onNext(1);
Log.d(TAG, "emit 2");
emitter.onNext(2);
Log.d(TAG, "emit 3");
emitter.onNext(3);
Log.d(TAG, "emit complete");
emitter.onComplete();
Log.d(TAG, "emit 4");
emitter.onNext(4);
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "onNext: " + integer);
}
});
- 其余同理
这里我们使用最后一个
observable.subscribe(observer);
运行结果:
08-24 08:03:25.041 6134-6134/com.example.wty.learnrxjava I/MainActivity: onSubscribe:
08-24 08:03:25.042 6134-6134/com.example.wty.learnrxjava I/MainActivity: onNext: s = A
08-24 08:03:25.042 6134-6134/com.example.wty.learnrxjava I/MainActivity: onNext: s = B
08-24 08:03:25.042 6134-6134/com.example.wty.learnrxjava I/MainActivity: onNext: s = C
08-24 08:03:25.042 6134-6134/com.example.wty.learnrxjava I/MainActivity: onComplete:
4.链式调用
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter e) throws Exception {
try {
e.onNext("A");
e.onNext("B");
e.onNext("C");
e.onComplete();
} catch (Exception ex) {
e.onError(ex);
}
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(@NonNull String s) {
Log.i(TAG, "onNext: s = " + s);
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(TAG, "onError: ", e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
ObservableEmitter和Disposable
ObservableEmitter： Emitter是发射器的意思，那就很好猜了，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。
但是，请注意，并不意味着你可以随意乱七八糟发射事件，需要满足一定的规则：
上游可以发送无限个onNext, 下游也可以接收无限个onNext.
- 当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
- 当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
- 上游可以不发送onComplete或onError.
- 最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然
关于onComplete和onError唯一并且互斥这一点, 是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则, 并不一定会导致程序崩溃. 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃。
介绍了ObservableEmitter, 接下来介绍Disposable, 这个单词的字面意思是一次性用品,用完即可丢弃的. 那么在RxJava中怎么去理解它呢,对应于观察者模式相当于取消订阅, 对应于上面的水管的例子, 我们可以把它理解成两根管道之间的一个机关, 当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件.
注意: 调用dispose()并不会导致上游不再继续发送事件, 上游会继续发送剩余的事件.
来看个例子, 我们让上游依次发送1,2,3,complete,4,在下游收到第二个事件之后, 切断水管, 看看运行结果:
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
e.onNext(4);
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.i(TAG, "onSubscribe: ");
disposable = d;
}
@Override
public void onNext(@NonNull Integer integer) {
Log.i(TAG, "onNext: integer = " + integer);
if (integer == 2) {
disposable.dispose();
}
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(TAG, "onError: ", e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
08-24 16:27:15.856 25856-25856/com.example.wty.learnrxjava I/MainActivity: onSubscribe:
08-24 16:27:15.857 25856-25856/com.example.wty.learnrxjava I/MainActivity: onNext: integer = 1
08-24 16:27:15.857 25856-25856/com.example.wty.learnrxjava I/MainActivity: onNext: integer = 2