基本使用
Observable.just(1, 2, 3)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
>>>>>>
开始采用subscribe连接
接收到了事件1
接收到了事件2
接收到了事件3
对Complete事件作出响应
源码分析
Observable中的函数
在Observable抽象类中有如下几个函数：
- just
/**
* 创建操作符just - 一个参数
* @param item: 所要发射的数据
*/
public static <T> Observable<T> just(T item) {
ObjectHelper.requireNonNull(item, "The item is null");
return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
}
/**
* 创建操作符just - 多个参数，但不超过10个
* @param item: 所要发射的数据
*/
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
ObjectHelper.requireNonNull(item5, "The fifth item is null");
ObjectHelper.requireNonNull(item6, "The sixth item is null");
ObjectHelper.requireNonNull(item7, "The seventh item is null");
ObjectHelper.requireNonNull(item8, "The eighth item is null");
ObjectHelper.requireNonNull(item9, "The ninth item is null");
ObjectHelper.requireNonNull(item10, "The tenth item is null");
return fromArray(item1, item2, item3, item4, item5, item6, item7, item8, item9, item10);
}
- fromArray
/**
* 创建操作符fromArray
* @param item: 所要发射的数据数组
*/
public static <T> Observable<T> fromArray(T... items) {
ObjectHelper.requireNonNull(items, "items is null");
if (items.length == 0) {
//长度是0的时候，调用empty()方法
return empty();
} else
if (items.length == 1) {
//长度是0的时候，调用just()一个参数的方法
return just(items[0]);
}
return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
}
- fromIterable
/**
* 创建操作符fromIterable
* @param item: 所要发射的数据集合
*/
public static <T> Observable<T> fromIterable(Iterable<? extends T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableFromIterable<T>(source));
}
由此可以看出:
- just发射空数据的时候, 是调用Observable.empty()方法
- just发射一条数据的时候, 是通过Observable实例ObservableJust
- just发射多条数据的时候, 是通过Observable实例ObservableFromArray
ObservableJust实现类
public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {
private final T value;
public ObservableJust(final T value) {
this.value = value;
}
@Override
protected void subscribeActual(Observer<? super T> s) {
// 订阅时调用
ScalarDisposable<T> sd = new ScalarDisposable<T>(s, value);
s.onSubscribe(sd);
sd.run();
}
@Override
public T call() {
return value;
}
}
ScalarDisposable类
public static final class ScalarDisposable<T>
extends AtomicInteger
implements QueueDisposable<T>, Runnable {
<---省略--->
// 调用run方法就会触发Observer的onNext和onComplete
@Override
public void run() {
if (get() == START && compareAndSet(START, ON_NEXT)) {
observer.onNext(value);
if (get() == ON_NEXT) {
lazySet(ON_COMPLETE);
observer.onComplete();
}
}
}
}
ObservableFromArray实现类
public final class ObservableFromArray<T> extends Observable<T> {
final T[] array;
public ObservableFromArray(T[] array) {
this.array = array;
}
@Override
public void subscribeActual(Observer<? super T> s) {
// 订阅时调用
FromArrayDisposable<T> d = new FromArrayDisposable<T>(s, array);
s.onSubscribe(d);
if (d.fusionMode) {
return;
}
d.run();
}
}
FromArrayDisposable类
static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {
<---省略--->
// 调用run方法就会触发Observer的onNext和onComplete
void run() {
T[] a = array;
int n = a.length;
for (int i = 0; i < n && !isDisposed(); i++) {
T value = a[i];
if (value == null) {
downstream.onError(new NullPointerException("The " + i + "th element is null"));
return;
}
downstream.onNext(value);
}
if (!isDisposed()) {
downstream.onComplete();
}
}
}
ObservableFromIterable实现类
public final class ObservableFromIterable<T> extends Observable<T> {
final Iterable<? extends T> source;
public ObservableFromIterable(Iterable<? extends T> source) {
this.source = source;
}
@Override
public void subscribeActual(Observer<? super T> observer) {
// 订阅时调用
Iterator<? extends T> it;
try {
it = source.iterator();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
EmptyDisposable.error(e, observer);
return;
}
boolean hasNext;
try {
hasNext = it.hasNext();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
EmptyDisposable.error(e, observer);
return;
}
if (!hasNext) {
EmptyDisposable.complete(observer);
return;
}
FromIterableDisposable<T> d = new FromIterableDisposable<T>(observer, it);
observer.onSubscribe(d);
if (!d.fusionMode) {
d.run();
}
}
static final class FromIterableDisposable<T> extends BasicQueueDisposable<T> {
<---省略--->
void run() {
boolean hasNext;
do {
if (isDisposed()) {
return;
}
T v;
try {
v = ObjectHelper.requireNonNull(it.next(), "The iterator returned a null value");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
downstream.onError(e);
return;
}
downstream.onNext(v);
if (isDisposed()) {
return;
}
try {
hasNext = it.hasNext();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
downstream.onError(e);
return;
}
} while (hasNext);
if (!isDisposed()) {
downstream.onComplete();
}
}
<---省略--->
}
}
