Today,學習RxJava 的操作符,首先獻出官方文檔 0 。操作符比較多,我們學習重要的常用的就好啦,就按照官方文檔中操作符的分類來學習,今天學習的是 ** Creating Observables ** —— 創建被觀察者的操作符。
文中的圖 或 測試代碼 部分來官方文檔
Create
-
1.作用分析
create 是最簡單的操作符,就是創建一個Observable (被觀察者),然后適當的調用執行 Observer(觀察者)的 onNext ,onCompleted 或 onError 方法。
-
2.代碼示例
// 測試代碼
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> observer) {
try {
if (!observer.isUnsubscribed()) {
for (int i = 1; i < 5; i++) {
observer.onNext(i);
}
observer.onCompleted();
}
} catch (Exception e) {
observer.onError(e);
}
}
} ).subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});
輸出結果:
Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.
-
3.源碼分析
源碼分析可以查看上一篇文章 RxJava 源碼學習之最簡單的Demo
Just
-
1.作用分析
Just操作符可以接收1~9個參數,將參數轉為Observable對象,并按原來的順序將參數逐個發送出來。其訂閱過程與create一樣,均是在執行subscribe(observer)時產生事件。
-
2.代碼示例
//測試代碼
Observable.just(1, 2, 3)
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});
輸出結果:
Next: 1
Next: 2
Next: 3
Sequence complete.
-
3.源碼分析
- part 1
//找到查看 Just 方法
public static <T> Observable<T> just(final T value) {
return ScalarSynchronousObservable.create(value);
}
......
public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) {
return from((T[])new Object[] { t1, t2, t3, t4, t5, t6, t7, t8, t9 });
}
我們可以找到9個just
對應的方法,除當只有一個參數時,進入ScalarSynchronousObservable.create
,其他的都轉換成了 from操作符(后面會分析)。所以,我們這里分析一下當只有一個參數的情況。
- part 2
public final class ScalarSynchronousObservable<T> extends Observable<T> {
public static <T> ScalarSynchronousObservable<T> create(T t) {
return new ScalarSynchronousObservable<T>(t);
}
protected ScalarSynchronousObservable(final T t) {
super(hook.onCreate(new JustOnSubscribe<T>(t)));
this.t = t;
}
.......省略其他代碼......
}
ScalarSynchronousObservable 是 Observable 的繼承類,t 就是我們傳入的參數,hook(RxJavaObservableExecutionHook)就是一個代理類(RxJava 源碼學習之最簡單的Demo中有分析過),hook.onCreate 返回的就是這個JustOnSubscribe類型的對象。從上面可以看出來,是將一個JustOnSubscribe類型的對象賦值給了 Observable.onSubscribe(RxJava 源碼學習之最簡單的Demo中分析過,subscribe()其實就是調用的 Observable.onSubscribe.call())。所以,看一下JustOnSubscribe這個類。
- part 3
static final class JustOnSubscribe<T> implements OnSubscribe<T> {
final T value;//傳遞的參數
JustOnSubscribe(T value) {
this.value = value;
}
@Override
public void call(Subscriber<? super T> s) {
// s 就是 Observable.subsrcibe()傳遞的 觀察者對象
s.setProducer(createProducer(s, value));
}
}
//將 觀察者s 和 參數v 進行處理
static <T> Producer createProducer(Subscriber<? super T> s, T v) {
if (STRONG_MODE) {
return new SingleProducer<T>(s, v);
}
return new WeakSingleProducer<T>(s, v);
}
.......
//Subscriber 觀察者的方法
public void setProducer(Producer p) {
long toRequest;
boolean passToSubscriber = false;
//同步鎖
synchronized (this) {
toRequest = requested;
producer = p;
if (subscriber != null) {
//是否需要排隊
if (toRequest == NOT_SET) {
//不需要排隊
passToSubscriber = true;
}
}
}
// 排隊
if (passToSubscriber) {
subscriber.setProducer(producer);
} else {
//不排隊
if (toRequest == NOT_SET) {
producer.request(Long.MAX_VALUE);
} else {
producer.request(toRequest);
}
}
}
從上面代碼中,我們明白 JustOnSubscribe 實現了 OnSubscribe接口,在 call() 方法中對觀察者s 和 參數v 進行了處理,合成了一個 Producer 對象。且,Subscriber 是同步調用了 Producer.request()。所以,我們再看下 Producer類。
- part 4
public final class SingleProducer<T> extends AtomicBoolean implements Producer {
...省略其他代碼...
public SingleProducer(Subscriber<? super T> child, T value) {
this.child = child; //傳遞的 觀察者參數
this.value = value; //傳遞的 數據參數
}
@Override
public void request(long n) {
...省略其他代碼...
c.onNext(v);
c.onCompleted();
}
}
我們可以看到在 Producer 中調用了 Subscriber(觀察者)的 onNext,onComplement,并在onNext 中傳遞了 數據參數 v。
- part 5
好的,我們明白了,Just 操作符其實就是將參數們創建成一個個Observable對象,然后按原本順序逐個的發送出來給 Observer處理。(當然這個順序情況,因為沒分析多個參數的情況,這里還不是很清楚;多個參數情況,在 From 操作符中分析)
From
-
1.作用分析
如果你想使用的所有數據都可以表示為Observables,而不是Observables和其他類型的混合,你就可以很方便地通過使用 From(單組運算符)來管理數據流的整個生命周期。
多種參數傳遞方式:
Javadoc: from(array)
Javadoc: from(Iterable)
Javadoc: from(Future)
Javadoc: from(Future,Scheduler)
Javadoc: from(Future,timout,timeUnit)
-
2.1代碼示例
//測是代碼
Integer[] nums = {1,3,7,2,5};
Observable.from(nums)
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});
輸出結果:
Next: 1
Next: 3
Next: 7
Next: 2
Next: 5
Sequence complete.
-
2.2示例代碼
/**
{@code Future}表示異步計算的結果。 提供了檢查計算是否完成,等待其完成以及檢索計算結果的方法。
只有當計算完成時,才能使用方法{@code get}檢索結果,必要時阻止,直到準備好為止。
取消由{@code cancel}方法執行。 提供了附加的方法來確定任務是否正常完成或被取消。
一旦計算完成,計算就不能取消。 如果您希望使用{@code Future}以取消可用性,但不提供可用的結果,
則可以聲明{@code Future <?>}格式的類型,并返回{@code null} 基礎任務。
**/
Observable.from(new Future<String>() {
@Override
public boolean cancel(boolean mayInterruptIfRunning) { return false; }
@Override
public boolean isCancelled() { return false; }
@Override
public boolean isDone() { return false; }
@Override
public String get() throws InterruptedException, ExecutionException { return "Hello world !"; }
@Override
public String get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
System.out.println("timeout-"+timeout+"--unit-"+unit);
return "Hello world!";
}})
.subscribe(new Subscriber<String>() {
@Override
public void onNext(String item) { System.out.println("Next: " + item); }
@Override
public void onError(Throwable error) { System.err.println("Error: " + error.getMessage()); }
@Override
public void onCompleted() { System.out.println("Sequence complete."); }});
輸出結果:
Next: Hello world !
Sequence complete.
Defer
-
1.作用分析
直到 Observer(觀察者)訂閱時,才去創建Observable(被觀察者),并且是給每一個 Observer(觀察者) 創建一個新的 Observable(被觀察者)。雖然,每個Observer 認為他們正在訂閱同一個 Observable,但事實上每個Observer 都是擁有自己獨立的序列的,獨立的Observable。
-
2.代碼示例
private Integer[] nums = {1,2,3,4};
private Integer[] yy = {7,8,9,0};
public void operatorDefer(){
Observable<Integer> mObservable = Observable.defer(new Func0<Observable<Integer>>() {
@Override
public Observable<Integer> call() {
return Observable.from(nums);
}
});
//改變數組值
nums = yy;
mObservable.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) { System.out.println("Next: " + item); }
@Override
public void onError(Throwable error) { System.err.println("Error: " + error.getMessage()); }
@Override
public void onCompleted() { System.out.println("Sequence complete."); } });}
輸出結果:
Next: 7
Next: 8
Next: 9
Next: 0
Sequence complete.
defer 操作符輸出的結果是 7,8,9,0
,說明直到 觀察者訂閱時,才去創建Observable(被觀察者)
Start
-
1.作用分析
返回一個Observable,它發射一個類似于函數聲明的值。可以在Observables調用鏈中與其它Observable搭配使用。
注意:這個函數只會被執行一次,即使多個觀察者訂閱這個返回的Observable。
-
2.示例代碼
Timer
-
1.作用分析
創建一個Observable,它在一個給定的延遲后發射一個特殊的值。
-
2.示例代碼
System.out.println("開始:"+System.currentTimeMillis()/1000);
Observable.timer(3,TimeUnit.SECONDS)
.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
System.out.println("執行:"+System.currentTimeMillis()/1000);
System.out.println("hello world");
}
});
輸出結果:
開始:1478419551
執行:1478419554
hello world
參考文檔:
結束語
Perfect!!! 我們分析完RxJava的創建類操作符了,當然還深入的不夠,但是我們一步一個腳印,慢慢來。下一篇,我們就來源碼分析 RxJava 的變換操作符。
歡迎大家一起討論學習!