RxJava与观察者模式

RxJava以观察者模式为基础的框架

1.传统的观察者模式

Observable {
	List<Observer> observers;
	void register(Observer);
	void unregister(Observer);
	void notify(Object o);
}

Observable依赖Observer,高度耦合
需要建立绑定关系
容易造成Observer的内存泄漏(当忘记调用unregister时)

2.变形的观察者模式

Observable {
		Data data;
		void notify(Observer observer) {
				observer.notify(data);
		}
}

Observable虽然依然依赖Observer,但它们之间是松耦合，
不需要建立绑定关系，
不会造成Observer的内存泄漏，
RxJava是以这种观察者模式为基础
ObservableJust可以完成简单的对象传递

        Observable.just("Hello RxJava")
                .subscribe(new Observer<String>() {
                    @Override
                    public void onNext(String s) {
                        Log.v(TAG, "ObservableJust:传递数据:" + s);
                    }
					... ...
                });

将字符串从ObservableJust传递给Observer
ObservableFromArray批处理数据集合，依次将数据传递给Observer

class ObservableFromArray<T> {
	T[] array;
	void subscribe(Observer<? super T> observer) {
		forint i=0; i<array.len; i++) {
			T value = array[i];
			observer.onNext(t);
		}
	}
}

Observable.fromArray(students)
	.subscribe(new Observer<Student>() {
		void onNext(Student student) {
				 Log.v(TAG,  student.getName());
		}
	});

3.+中介者模式

在Observerable与Observer之间添加一个中介者，
由Observerable控制Observer，转变为允许开发者控制Observer,实现控制反转，
允许开发者将自己的代码注入RxJava中

1.ObservableCreate与ObservableOnSubscribe

ObservableOnSubscribe作为中介者，控制了Observer

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Throwable {
                String data = getData();
                emitter.onNext(data);
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
 
                    @Override
                    public void onNext(String value) {
                        Log.e(TAG,"onNext:"+value);
                    }

        });

4.+代理模式

可以为Observerable或Observer添加代理，用于控制它们，实现

• 1.线程切换
• 2.数据转换

1.线程切换

Observable与Observer

1.ObservableSubscribeOn+SubscribeOnObserver

ObservableSubscribeOn是Observable的代理对象，
将Observable的方法调用封装在Runnable中交给Scheduler处理处理

class ObservableSubscribeOn implements Observable {
	 final Scheduler scheduler;
	 ObservableSource source;
	  public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler);
	  public void subscribe(Observer observer) {
			//利用scheduler，调用source.subscribe(new SubscribeOnObserver(observer))
			//实现线程切换
			final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
			scheduler.scheduleDirect(new Runnable() {
					void run() {
						source.subscribe(parent);
					}
			});
	 }
}

2.ObservableObserveOn+ObserveOnObserver

ObserveOnObserver是Observer的代理，
将Observer的方法调用封装在Runnable中交给Scheduler处理

class ObservableObserveOn implements Observable {
	final Scheduler scheduler;
	public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler);
	public void subscribe(Observer observer) {
			Scheduler.Worker w = scheduler.createWorker();
            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
	 }
}

class ObserveOnObserver implemtents Observer,Runnable {
	//在Worker中，运行ObserveOnObserver, 调用observer.onNext(t)
}

2.数据转换

1.ObservableMap+MapObserver

ObservableMap负责传入封装转换方法的接口对象
MapObserver负责数据转换

class ObservableMap<T, U> {
	Function<? super T, ? extends U> function;
	Observable<T> source;
	void subscribe(Observer<U> observer) {
		source.subscribe(new MapObserver(observer, function);
	}
}
class MapObserver<T, U> {
	Function function;
	Observer observer;
	void onNext(T t)	{
		U u = function.apply(t);
		observer.onNext(u);
	}
}

Observable.just(student)
	.map(new Function<Student, String>() {
		String call(Student student) {
			return student.getName();
		}
	})
	.subscribe(new Observer<String>() {
		void onNext(String name) {
			... ...
		}
	});

2.ObservableFlatMap+MergeObserver

ObservableFlatMap负责传入封装转换方法的接口对象
MergeObserver负责数据转换，允许数据转换为ObservableSource

class ObservableFlatMap<T,U> {
	Function<? super T, ? extends ObservableSource<? extends U>> mapper;
	Observable source;
	void subscribe(Observer<? super U> observer) {
		source.subscribe(new MergeObserver<T,U>(observer, mapper));
	}
}
class MergeObserver<T, U> {
	final Observer<? super U> downstream;
    final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
	Queue<ObservableSource<? extends U>> sources;
	final AtomicReference<InnerObserver<?, ?>[]> observers;
	void onNext(T t) {
		ObservableSource p = mpper.apply(t);
		//1.
		if(p instanceof Supplier) {
			sources.offer(p);
			for(;;) {
				p = sources.poll();
				U u = p.get();
				observer.onNext(u);
			}
		}
		//2.
		InnerObserver inner = new InnerObserver(this);
		observers.add(observer);
		p.subscribe(inner);
	}

	class InnerObserver<T, U> {
		public void onNext(U t) {
				observer.onNext(t);
		}
	}
}

实际上处理的是Student列表中每个Student的Course列表中的每个Course
List<Student>->Student->List<Course>->Course

Observable.fromArray(students)
                .flatMap(new Function<Student, ObservableSource<Course>>() {
                    @Override
                    public ObservableSource<Course> apply(Student student) throws Throwable {
                        return Observable.fromIterable(student.getCoursesList());
                    }
                })
                .subscribe(new Observer<Course>() {
                    @Override
                    public void onNext(Course course) {
                        Log.v(TAG, "course: "+ course.getName());
                    }
 					... ...
                });