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();
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值