Rxjava1.0 lift方法

package com.yue.test;

import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.Observable.Operator;
import rx.exceptions.Exceptions;
import rx.internal.operators.OnSubscribeLift;
import rx.plugins.RxJavaHooks;
import rx.Subscriber;

/**
 * 使用lift进行转换
 * 
 * @ClassName: RxTest4
 * @Description: TODO
 * @author shimingyue
 * @date 2016-7-14 下午5:29:32
 * 
 */
public class RxTest4 {

	public static void main(String[] args) {
		/**
		 * 声明一个观察者
		 */
		Subscriber<Integer> subscriber = new Subscriber<Integer>() {
			
			@Override
			public void onNext(Integer t) {
				System.out.println("lift转换后：" + t);
			}
			
			@Override
			public void onError(Throwable e) {
				// TODO Auto-generated method stub
				
			}
			
			@Override
			public void onCompleted() {
				// TODO Auto-generated method stub
				
			}
		};
		/**
		 * 创建一个被观察者
		 */
		Observable<String> observable = Observable
				.create(new OnSubscribe<String>() {

					@Override
					public void call(Subscriber<? super String> subscriber) {
						//subscriber:下面operator的call方法的返回
						subscriber.onNext("123");
						subscriber.onNext("124");
						subscriber.onNext("125");
						subscriber.onCompleted();
					}
				});
		/**
		 * 使用lift进行转换
		 */
		Observable<Integer> observable2 = observable
				.lift(new Operator<Integer, String>() {

					//call(subscriber)里subscriber:源观察者
					@Override
					public Subscriber<? super String> call(
							final Subscriber<? super Integer> subscriber) {
						
						return new Subscriber<String>() {

							@Override
							public void onCompleted() {}

							@Override
							public void onError(Throwable e) {}

							@Override
							public void onNext(String t) {
								subscriber.onNext(Integer.parseInt(t));
							}
						};
					}
				});
		/**
		 * 订阅
		 */
		observable2.subscribe(subscriber);
		/**
		 * 泛型参数：
		 * T:源被观察者的参数类型，也就是调用者
		 * R:转换后的被观察者的参数类型
		 * 
		 * 
		 * lift转换出来的被观察者会是怎样的？
		 * 和flatMap一样，不同的是flatMap还有一步map转换，而后才将map转换来的结果调用lift在做进一步转换
		 * 而这里是直接使用lift进行转换，所以后面的就跟map转换后的过程一样啦
		 * 
		 * 看一看lift源码
		 *     public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
    	 * onSubscribe:源被观察者，调用者的监听实例
    	 * operator:转换实例，这是我们自己生命传入的
        	return create(new OnSubscribeLift<T, R>(onSubscribe, operator));
    		}
		 * 
		 * lift会返回一个新的被观察者，它持有一个new OnSubscribeLift<T, R>(onSubscribe, operator)
		 * 所以我们在订阅方法执行的时候会执行这个OnSubscribeLift的call方法
		 * 
		 * call方法的部分源码
		 *   @Override
    		public void call(Subscriber<? super R> o) {
        	try {
            Subscriber<? super T> st = RxJavaHooks.onObservableLift(operator).call(o);
            try {
                // new Subscriber created and being subscribed with so 'onStart' it
                st.onStart();
                parent.call(st);
            }
    		}
    		里面的参数：
    		o:是我们的源观察者
    		parent:源被观察者的监听实例
    		operator:我们自己声明传入的
    		RxJavaHooks.onObservableLift(operator)这半段代码做了一下异常判断，没有意外就将operator原样返回
    		所以这里调到了operator的call方法，并将源观察者传入
    		
    		看一看call方法，哦不用看啦，在我们自己的代码里，sorry
    		看上面我们的call方法:返回了一个观察者，好我们自己声明一个观察者就行啦返回行了，st是这个观察者的引用，
    		并且call方法内还有我们的源观察者引用，我们可以做些什么呢，好吧现在还不知道要做些什么
    		只知道需要返回一个和我们源被观察者相同泛型参数的观察者
    		
    		ok，向下看在OnSubscribeLift的call方法，里面有这样一句parent.call(st);
    		st:我们声明的operator的call方法返回的观察者，
    		parent:源被观察者的监听实例
    		
    		调用了源被观察者监听实例的call方法，并将operator的call方法返回的观察者传入，
    		哦，即使传入了又能做什么呢，调用其onNext方法？这又能做什么呢
    		
    		ok，看一看我们声明的源被观察者实例，它调用了operator的call方法返回的观察者的onNext并传入了需要转换的参数。，
    		在看我们Operator的call方法里返回的Subscriber，所以只需在这个返回的Subscriber里调用传入Operator call方法
    		的源观察者并传入转换参数就可以了
		 * 
		 * 
		 * 
		 * 好，总结以上的步骤
		 * 1.lift方法转换
		 * 2.lift里面需要传入一个Operator对象
		 * 3.Operator对象的call方法需返回一个subscriber，和源被观察者泛型参数相同，他会传到源被观察者监听实例的call方法内
		 * 所以被观察者调用的观察者是operator call方法的返回
		 * 4. 3调用观察者的onNext方法并传入参数，在operator的call方法里返回的subscriber的onNext方法里接收到参数
		 * 5.在operator的call方法里返回的subscriber的onNext方法里，把onNext接收的参数进行转换得到结果，
		 * 再调用传入其中的subscriber的onNext方法，并将转换结果传入，
		 * 
		 */
		
	}

}