rxjava :观察者与被观察者

观察者模式GitHub示例

JamesZBL/java_design_patterns: observer

youlookwhat/DesignPattern : observer

iluwatar/java-design-patterns : observer

类型	描述
Observable	能够发射0或n个数据onNext ，并以成功onComplete或错误onError事件终止。
Flowable	能够发射0或n个数据onNext ，并以成功onComplete或错误onError事件终止。 【支持Backpressure】，可以控制数据源发射的速度。
Single	只发射单个数据onSuccess或错误onError事件。【没有onComplete】
Completable	它【从来不发射数据】，只处理 onComplete 和 onError 事件。可以看成是Rx的Runnable。
Maybe	能够发射0或者1个数据onSuccess，要么成功onComplete，要么失败onError。有点类似于Optional

• Single的SingleObserver中只有onSuccess、onError，并没有onComplete。这是 Single 跟其他四种被观察者最大的区别。

• 只有Flowable是支持Backpressure的，其余四种都不支持。

• Single 可以通过toXXX方法转换成Observable、Flowable、Completable以及Maybe。

• Completable 也可以通过toXXX方法转换成Observable、Flowable、Single以及Maybe。

rxjava的五组观察者与被观察者

• ObservableSource/Observer

可通过onNext方法发送单条数据或者数据序列，通过onComplete发送完成通知或通过onError发送异常通知，不支持背压策略。

public interface ObservableSource<T> {
    void subscribe(@NonNull Observer<? super T> observer);
}
//被观察者
public abstract class Observable<T> implements ObservableSource<T> {}
//观察者
public interface Observer<T> {
    void onSubscribe(@NonNull Disposable d);	
    void onNext(@NonNull T t);					//发送 onNext （单条数据或数据序列）
    void onError(@NonNull Throwable e);			//发送 onError
    void onComplete();							//发送 onComplete

}

• Publisher/Subscriber

在ObservableSource/Observer基础上进行了改进，可通过背压策略处理背压问题，但效率没有第一组高。

public interface Publisher<T> {
    public void subscribe(Subscriber<? super T> s);
}
//被观察者
public abstract class Flowable<T> implements Publisher<T> {}
//观察者
public interface Subscriber<T> {
    public void onSubscribe(Subscription s);
    public void onNext(T t);				//发送 onNext （单条数据或数据序列）
    public void onError(Throwable t);		//发送 onError
    public void onComplete();				//发送 onComplete
}

以下三组是新的响应式关系的实现，在Rxjava1中没有，可看做是ObservableSource/Observer的简化版

• SingleSource/SingleObserver

参考： https://mcxiaoke.gitbooks.io/rxdocs/content/Single.html

不能发送数据序列或完成通知，只能通过onSuccess方法发送单条数据，或者通过onError发送异常通知

public interface SingleSource<T> {
    void subscribe(@NonNull SingleObserver<? super T> observer);
}
//被观察者
public abstract class Single<T> implements SingleSource<T> {}
//观察者
public interface SingleObserver<T> {
    void onSubscribe(@NonNull Disposable d);
    void onSuccess(@NonNull T t);				//发送单条数据
    void onError(@NonNull Throwable e); 		//发送 onError
}

• CompletableSource/CompletableObserve

不能发送任何形式的数据（单条数据或数据序列），只能通过onComplete发送完成通知或者通过onError发送异常通知

public interface CompletableSource {
    void subscribe(@NonNull CompletableObserver co);
}
//被观察者
public abstract class Completable implements CompletableSource {}
//观察者
public interface CompletableObserver {
    void onSubscribe(@NonNull Disposable d);
    void onComplete();						//发送 onComplete
    void onError(@NonNull Throwable e);		//发送 onError 
}

• MaybeSource/MaybeObserver

可通过onSuccess发送单条数据，通过onComplete发送完成通知或者通过onError发送一条异常通知

public interface MaybeSource<T> {
    void subscribe(@NonNull MaybeObserver<? super T> observer);
}
//被观察者
public abstract class Maybe<T> implements MaybeSource<T> {}
//观察者
public interface MaybeObserver<T> {
    void onSubscribe(@NonNull Disposable d);
    void onSuccess(@NonNull T t);			//发送单条数据
    void onError(@NonNull Throwable e);		//发送 onError
    void onComplete();						//发送 onComplete
}

示例：

//Observable ： 
private void observable() {
	DisposableObserver<Integer> observer = Observable.just(1, 2, 3)
			.subscribeWith(new DisposableObserver<Integer>() {
				@Override
				public void onNext(Integer integer) {
					System.out.println("========Observable onNext" + integer);
				}

				@Override
				public void onError(Throwable e) {
					System.out.println("========Observable onError");
				}

				@Override
				public void onComplete() {
					System.out.println("========Observable onComplete");
				}
			});

	observer.dispose();
}




//Flowable ： 
private void flowable() {
	DisposableSubscriber<Integer> disposableSubscriber = Flowable.just(1, 2, 3)
			.subscribeWith(new DisposableSubscriber<Integer>() {

				@Override
				public void onNext(Integer integer) {
					System.out.println("========Flowable onNext======" + integer);
				}

				@Override
				public void onError(Throwable t) {
					System.out.println("========Flowable onError");
				}

				@Override
				public void onComplete() {
					System.out.println("========Flowable onComplete");
				}
			});

	disposableSubscriber.dispose();
}



//Completable ：   error 或 complete
private void completable() {
	Disposable d = Completable.complete()
			.delay(10, TimeUnit.SECONDS, Schedulers.io())
			.subscribeWith(new DisposableCompletableObserver() {
			
				@Override
				public void onComplete() {
					System.out.println("========Completable onComplete");
				}

				@Override
				public void onError(Throwable e) {
					System.out.println("========Completable onError");
				}
			});

	try {
		Thread.sleep(5000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}

	d.dispose();
}



//Maybe ： 单条数据 或 error 或 complete
private void maybe() {
	Disposable d = Maybe.just(9999)
			.delay(10, TimeUnit.SECONDS, Schedulers.io())
			.subscribeWith(new DisposableMaybeObserver<Integer>() {

				@Override
				public void onSuccess(Integer integer) {
					System.out.println("=======Maybe onSuccess: " + integer);
				}

				@Override
				public void onError(Throwable e) {
					e.printStackTrace();
				}

				@Override
				public void onComplete() {
					System.out.println("=========Maybe onComplete");
				}
			});

	try {
		Thread.sleep(5000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}

	d.dispose();
}



//Single : 单条数据 或 error
private void single() {
	Disposable d = Single.just("Hello World")
			.delay(10, TimeUnit.SECONDS, Schedulers.io())
			.subscribeWith(new DisposableSingleObserver<String>() {

				@Override
				public void onSuccess(String s) {
					System.out.println("==========Single Success: " + s);
				}

				@Override
				public void onError(Throwable e) {
					e.printStackTrace();
				}
			});

	try {
		Thread.sleep(5000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}

	d.dispose();
}