創建一個Observable
- Observable.create()
該方法接收一個Obsubscribe對象
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
}
});
來個例子：
Observable<Integer> observable=Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
for(int i=0;i<5;i++){
subscriber.onNext(i);
}
subscriber.onCompleted();
}
});
//Observable.subscribe(Observer)，Observer訂閱了Observable
Subscription subscribe = observable.subscribe(new Observer<Integer>() {
@Override
public void onCompleted() {
Log.e(TAG, "完成");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "異常");
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "接收Obsverable中發射的值：" + integer);
}
});
輸出：
接收Obsverable中發射的值：0
接收Obsverable中發射的值：1
接收Obsverable中發射的值：2
接收Obsverable中發射的值：3
接收Obsverable中發射的值：4
完成
從上面的例子可以看出，在Observer訂閱了Observable后，Observer作為OnSubscribe中call方法的參數傳入，從而調用了Observer的相關方法
- Observable.from()
該方法需要一個 數組或集合參數
假如現在我們有一個集合，我們能否也像上面一樣但不使用for循環，一個個發送給Observer，發送完后再調用onCompleted方法呢？
//創建一個集合
List<Integer> list=new ArrayList<>();
for(int i=0;i<5;i++){
list.add(i);
}
//使用Observable.from接收上面的list集合
Observable<Integer> observable=Observable.from(list);
//Observer訂閱Observable
Subscription subscribe = observable.subscribe(new Observer<Integer>() {
@Override
public void onCompleted() {
Log.e(TAG, "完成");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "異常");
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "接收Obsverable中發射的值：" + integer);
}
});
輸出：
接收Obsverable中發射的值：0
接收Obsverable中發射的值：1
接收Obsverable中發射的值：2
接收Obsverable中發射的值：3
接收Obsverable中發射的值：4
完成
可以看到使用Observable.from()和1中的效果一樣
- Observable.just()
該方法可接收 1到9 個同一任意類型的參數
假如我們有一個帶返回值的方法，我們也想使用Observable對其操作，該怎么辦呢？
private List<Integer> getDatas(){//提供數據的方法
List<Integer> list=new ArrayList<>();
for(int i=0;i<5;i++){
list.add(i);
}
return list;
}
//使用Observable.just調用上面的getDatas()方法，注意這里得到的Observable的類型為
//List<Integer>，而非Integer
Observable<List<Integer>> observable=Observable.just(getDatas());
Subscription subscribe = observable.subscribe(new Observer<List<Integer>>() {
@Override
public void onCompleted() {
Log.e(TAG, "完成");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "異常");
}
@Override
public void onNext(List<Integer> integers) {
for(Integer integer: integers)
Log.e(TAG, "接收Obsverable中發射的值：" + integer);
}
});
輸出：
接收Obsverable中發射的值：0
接收Obsverable中發射的值：1
接收Obsverable中發射的值：2
接收Obsverable中發射的值：3
接收Obsverable中發射的值：4
完成
從上面的代碼，我們可以看出just與from的區別，just是將集合直接作為一個參數發送給Observer,而from是將
集合中所有的元素一個一個的發送給Observer。假如上面代碼中的getDatas方法返回的不是一個集合，我們也就不能使用from了應該使用just。
在發送數據后，just也會自動調用onCompleted方法。
-
其他方式：
當我們需要一個Observable毫無理由的不再發射數據正常結束時，我們可以使用empty()
。我們可以使用never()
創建一個不發射數據并且也永遠不會結束的Observable。我們也可以使用throw()
創建一個不發射數據并且以錯誤結束的Observable。
特殊類Subject
為啥說它特殊呢？
因為它繼承了Observable并且實現Observer接口，所以說它即可已是一個Observer又可以是一個Observable，它包含4個子類：
- PublishSubject
- BehaviorSubject
- ReplaySubject
- AsyncSubject
- PublishSubject
//創建一個Subject這里看起來是不是缺點什么，對比上面的Observable.create()方法
PublishSubject<String> subject = PublishSubject.create();
Subscription subscription = subject.subscribe(new Observer<String>() {
@Override
public void onCompleted() {
Log.e(TAG, "完成");
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "異常");
}
@Override
public void onNext(String s) {
Log.e(TAG,"接收PublishSubject發送的值："+s);
}
});
//手動發送數據給訂閱它的Observer
subject.onNext("PublishSubject");
輸出：
接收PublishSubject發送的值：PublishSubject
從上面代碼可以看出，我們需手動發送數據給訂閱它的Observer。所以這里就與Observable不同：
在Observable中，如果有訂閱者訂閱了它，它就會馬上自動發送數據給Observer。
而對于Subject而言，它在被訂閱的時候并不會自動發送數據給Observer，發送數據的控制權交給了我們，在我們發送數據之前，訂閱的Observer會一直處于等待狀態，但是這種等待并不會阻塞線程，也不會消耗太多的資源。
當然我們也可以像Observable一樣使用Subject，沒有區別。
- ReplaySubject
//PublishSubject<Integer> subject=PublishSubject.create();
ReplaySubject<Integer> subject= ReplaySubject.create();
subject.onNext(1);// 1
subject.subscribe(new Action1<Integer>() {// 2
@Override
public void call(Integer integer) {
Log.e(TAG,""+integer);
}
});
subject.onNext(2);// 3
subject.onNext(3);// 4
subject.onNext(4);// 5
這里沒有給出輸出，那我們先來猜猜如果上面的subject是PublishSubject情況下輸出的是什么吧？
執行到1時，由于subject沒有訂閱者訂閱，所以發送出去的數據1也就沒有訂閱者接收
執行到2時，subject有訂閱者訂閱了（這里的Action1相當于一個實現了onNext方法的Observer對象）
執行到3 4 5時，subject發送的數據都會被2中的訂閱者接收到，從而輸出2、3、4。
PublishSubject發送數據時，會將數據發送給訂閱了它的所有Observer
那subject是ReplaySubject輸出的是怎樣呢？
Replay是不是重新播放的意思呢，這里的重新播放是指 當Observer訂閱ReplaySubject時，會將ReplaySubject之前發送過的數據，重新發送給該Observer，所以這里會輸出1 2 3 4。
再來看看另外2個ReplaySubject.createXXX()方法
- ReplaySubject.createWithSize(int size)
如果在Observer訂閱該ReplaySubject前，ReplaySubject發送數據的個數大于size,那么超出size部分的數據
不會發送給Observer。
ReplaySubject<Integer> subject= ReplaySubject.createWithSize(2);
subject.onNext(1);
subject.onNext(2);
subject.onNext(3);
subject.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e(TAG,""+integer);
}
});
subject.onNext(4);
輸出：2 3 4
- ReplaySubject.createWithTime(int time, TimeUnit unit, Scheduler scheduler);
需要3個參數，第12個用來確定時間，第3個傳入一個Scheduler
該方法表示如果ReplaySubject發送數據的時間超過了指定的時間，將不會重新發送給新訂閱的Observer
- BehaviorSubject
BehaviorSubject subject=BehaviorSubject.create();
subject.onNext(1);
subject.onNext(2);
subject.onNext(3);
subject.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e(TAG,""+integer);
}
});
subject.onNext(4);
subject.onNext(5);
輸出：
3 4 5
BehaviorSubject可以當作ReplaySubject來看，它只接收Observer訂閱前BehaviorSubject發送的最后一條數據。
- AsyncSubject
AsyncSubject subject=AsyncSubject.create();
subject.onNext(1);
subject.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e(TAG,"A"+integer);
}
});
subject.onNext(2);
subject.onNext(3);
subject.onCompleted();
subject.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e(TAG,"B"+integer);
}
});
輸出：
A3 B3
AsyncSubject會將執行過的一個完整的事件緩存起來（最后一個subject.onNext() +subject.onCompleted()）,然后會發送給所有訂閱它的Observer。
