Rxjava2 Observable的创建详解及实例

简要：

几种主要的需求

• 直接创建一个Observable（创建操作）
• 组合多个Observable（组合操作）
• 对Observable发射的数据执行变换操作（变换操作）
• 从Observable发射的数据中取特定的值（过滤操作）
• 转发Observable的部分值（条件/布尔/过滤操作）
• 对Observable发射的数据序列求值（算术/聚合操作）

创建Observable的各种方式

• create()：使用一个函数从头创建一个Observable
• defer()：只有当订阅者订阅才创建Observable；为每个订阅创建一个新的 Observable
• empty() ：创建一个什么都不做直接通知完成的Observable
• never()：创建一个不发射任何数据的Observable
• error()：—创建一个什么都不做直接通知错误的Observable
• just()：将一个或多个对象转换成发射这个或这些对象的一个Observable
• from()：将一个Iterable, 一个Future, 或者一个数组转换成一个Observable
• repeat()：创建一个重复发射指定数据或数据序列的Observable
• repeatWhen() ：创建一个重复发射指定数据或数据序列的Observable，它依赖于另一 个Observable发射的数据
• repeatUntil()：根据条件（函数BooleanSupplier）判断是否需要继续订阅
• range()：创建一个发射指定范围的整数序列的Observable
• interval()：创建一个按照给定的时间间隔发射整数序列的Observable
• timer()：—创建一个在给定的延时之后发射单个数据的Observable

1. Create

使用 Create 操作符从头开始创建一个Observable，给这个操作符传递一个接受观察者作为参数的函数，编写这个函数可以调用观察者的 onNext，onError 和 onCompleted 方法，当发生订阅的时候会自动调用观察者的 onSubscribe 方法。

通过 Subscribe 进行Observable 与 Observer 的订阅，其中 subscribe 方法可以接收一个完整通知参数的 Observer 对象，也可以接收部分通知参数的 Consumer(接收数据) 或者 Action (仅接收通知) 对象。

实例代码：

	// 创建Observable(被观察者)
	Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
   

		public void subscribe(ObservableEmitter<String> emitter) throws Exception {
   
			emitter.onNext("Hello");
			emitter.onNext("World");
			emitter.onComplete();
		}
	});
	
	// 创建Observer(观察者), 可以接受所有通知
	Observer<String> observer = new Observer<String>() {
   

		public void onSubscribe(Disposable d) {
   
			System.out.println("--> onSubscribe");
		}

		public void onNext(String t) {
   
			System.out.println("--> onNext = " + t);
		}

		public void onError(Throwable e) {
   
			System.out.println("--> onError");
		}

		public void onComplete() {
   
			System.out.println("--> onComplete");
		}
	};
	
	// 创建只接受 onNext(item) 通知的Consumer(观察者)
	Consumer<String> nextConsumer = new Consumer<String>() {
   

		@Override
		public void accept(String t) throws Exception {
   
			System.out.println("--> accept nextConsumer: " + t);
		}
	};
	
	// 创建只接受 onError(Throwable) 通知的Consumer(观察者)
	Consumer<Throwable> errorConsumer = new Consumer<Throwable>() {
   

		@Override
		public void accept(Throwable t) throws Exception {
   
			System.out.println("-- accept errorConsumer: " + t);
		}
	};
	
	// 创建只接受 onComplete() 通知的Action(观察者)
	Action completedAction = new Action() {
   
		
		@Override
		public void run() throws Exception {
   
			System.out.println("--> run completedAction");
		}
	};
	
	// 创建只接受 onSubscribe 通知的Consumer(观察者)
	Consumer<Disposable> onSubscribeComsumer = new Consumer<Disposable>() {
   

		@Override
		public void accept(Disposable t) throws Exception {
   
			System.out.println("--> accept onSubscribeComsumer ");
		}
	};

	// 1. 进行订阅，subscribe(Observer)
	observable.subscribe(observer);
	
	System.out.println("---------------------------------------------");
	// 2. 进行订阅，subscribe(Consumer onNext)
	observable.subscribe(nextConsumer);
	
	System.out.println("---------------------------------------------");
	// 3. 进行订阅，subscribe(Consumer onNext, Consumer onError)
	observable.subscribe(nextConsumer, errorConsumer);
	
	System.out.println("---------------------------------------------");
	// 4. 进行订阅，subscribe(Consumer onNext, Consumer onError, Action onCompleted)
	observable.subscribe(nextConsumer, errorConsumer, completedAction);
	
	System.out.println("---------------------------------------------");
	// 5. 进行订阅，subscribe(Consumer onNext, Consumer onError, Action onCompleted, Consumer onSubscribe)
	observable.subscribe(nextConsumer, errorConsumer, completedAction, onSubscribeComsumer);

输出：

--> onSubscribe
--> onNext = Hello
--> onNext = World
--> onComplete
---------------------------------------------
--> accept nextConsumer: Hello
--> accept nextConsumer: World
---------------------------------------------
--> accept nextConsumer: Hello
--> accept nextConsumer: World
---------------------------------------------
--> accept nextConsumer: Hello
--> accept nextConsumer: World
--> run completedAction
---------------------------------------------
--> accept onSubscribeComsumer 
--> accept nextConsumer: Hello
--> accept nextConsumer: World
--> run completedAction

注意：create 方法默认不在任何特定的调度器上执行。

• onSubscribe(Disposable): 在发生订阅时接收。

• onNext(item): 在被观察者发射数据接收。

• onError(Throwable): 在被观察者发射Error时接收。

• onComplete(): 在被观察者完成数据发送时接收。

  Javadoc: create(OnSubscribe)
  Javadoc: subscribe()
  Javadoc: subscribe(observer)
  Javadoc: subscribe(onNext)
  Javadoc: subscribe(onNext, onError)
  Javadoc: subscribe(onNext, onError, onComplete)
  Javadoc: subscribe(onNext, onError, onComplete, onSubscribe)

2. Defer

直到有观察者订阅时才创建 Observable，并且为每个观察者创建一个新的 Observable.

Defer 操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个 Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个 Observable，事实上每个订阅者获取的是它们自己的单独的数据序列。

实例代码：

	// 创建一个Defer类型的Observable
	Observable<Integer> deferObservable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
   
		public ObservableSource<? extends Integer> call() throws Exception {
   
			// 创建每个观察者订阅所返回的 Observable
			Observable<Integer> observable = Observable.create(new