RxJavaing

Observable.just("123").lift(new Observable.Operator<Integer, String>() {
            @Override
            public Subscriber<? super String> call(final Subscriber<? super Integer> subscriber) {
                return new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                        System.out.println("s====================onCompleted======");
                    }

                    @Override
                    public void onError(Throwable throwable) {

                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println("s=========================="+s);
                        subscriber.onNext(Integer.parseInt(s));
                    }

                    @Override
                    public void onStart() {
                        super.onStart();
                        System.out.println("s====================onStart======");
                    }
                };
            }
        }).subscribe();

怎么调用的啊?

Observable.just("123")? 它干了什么.分析源码
Observable observable = Observable.create(
	OnSubscribe  小a = new JustOnSubscribe("123");
); // 小A = observable  
------------------------------------------->
Observable.just("123") 等效与 小A
------------------------------------------->
perator 小B = new Observable.Operator<Integer, String>() {
  @Override    
 public Subscriber<? super String> call(final Subscriber<? super Integer> subscriber) 
  {          
    return 小C;    
  }
}
Subscriber 小C = new Subscriber<String>() {
        @Override 
	public void onCompleted() {  
   		System.out.println("s====================onCompleted======");            
	}           
 	@Override
	public void onError(Throwable throwable) { 
  	}            
	@Override            
	public void onNext(String s) {                
		System.out.println("s=========================="+s);                
		subscriber.onNext(Integer.parseInt(s));  // subscriber 在小B call中传入 
		Subscriber action= new ActionSubscriber(onNext,onError,onCompleted);
		// subscriber 就是它---------------------------------------------->>>	          
	}            
		
			
	@Override           
	public void onStart() {                
		super.onStart();                
		System.out.println("s====================onStart======");            
	}        
}
==========================================================================
Observable.just("123").lift(小B).subscribe();
---------->小A.lift(小B).subscribe();
------------->
小A.lift(小B) = 大A
Observable 大A = Observable.create(
	OnSubscribe  大a = new OnSubscribeLift(小a,小B);
); 
------------------------->大A.subscribe();
static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
            ((Subscriber)subscriber).onStart(); // 1
	    RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber); //2
            return RxJavaHooks.onObservableReturn((Subscription)subscriber); // 3
        }
    }
}
Subscriber action= new ActionSubscriber(onNext,onError,onCompleted);
// 1 --> action.start // 不关注,
subscribe方法会构造一个 内容观察者,暂时没用到它,不关注
RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
RxJavaHooks.onObservableStart(observable, observable.onSubscribe) = 
RxJavaHooks.onObservableStart(大A, 大a).call(action);
RxJavaHooks.onObservableStart(大A, 大a) = 大a
RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
翻译后是
--------->大a.call(action); // action 此时不用关注,
-----------> 大a = new OnSubscribeLift(小a,小B);
    OnSubscribeLift call 方法如下
this.operator = 小B
this.parent = 小a
public void call(Subscriber<? super R> o) {
        Subscriber e = (Subscriber)RxJavaHooks.onObservableLift(this.operator).call(o);
        e.onStart();
        this.parent.call(e);
}
------------------------>小C = 小B.call(action)
--------------------------->小C.onStart()----------------------------------------->OnStart调用
------------------------------>小a.call(小C);
OnSubscribe  小a = new JustOnSubscribe("123");
public void call(Subscriber<? super T> s) {
    s.setProducer(ScalarSynchronousObservable.createProducer(s, this.value));
    等效与
    小C.setProducer(WeakSingleProducer(小C,"123"));
}
public void setProducer(Producer p) {
    boolean passToSubscriber = false;
    long toRequest;
    synchronized(this) {
        toRequest = this.requested;
        this.producer = p;
        if(this.subscriber != null && toRequest == -9223372036854775808L) {
            passToSubscriber = true;
        }
    }

    if(passToSubscriber) {
        this.subscriber.setProducer(this.producer);
    } else if(toRequest == -9223372036854775808L) {
        this.producer.request(9223372036854775807L); // 会执行到它9223372036854775807L

    } else {
        this.producer.request(toRequest);
    }
}
---------------------------->
this.producer = WeakSingleProducer
------------------------------------------------->>request(9223372036854775807L);
static final class WeakSingleProducer<T> implements Producer {
    final Subscriber<? super T> actual;
    final T value;
    boolean once;

    public WeakSingleProducer(Subscriber<? super T> actual, T value) {
        this.actual = actual;
        this.value = value;
	等效与
	this.actual = 小C;
        this.value = "123";
    }    public void request(long n) {        if(!this.once) {            if(n < 0L) {                throw new IllegalStateException("n >= required but it was " + n);            } else if(n != 0L) {                this.once = true;                Subscriber a = this.actual; // a = 小C                if(!a.isUnsubscribed()) {                    Object v = this.value;                    try {                        a.onNext(v); // onNext
			----------------------------------------->
			onNext调用

                    } catch (Throwable var6) {
                        Exceptions.throwOrReport(var6, a, v);
                        return;
                    }

                    if(!a.isUnsubscribed()) {
                        a.onCompleted(); // onCompleted
			----------------------------------------->
			onCompleted
			调用

                    }                }            }        }    }}
最终  小C 的onStart onNext onCompleted  得以执行
Subscriber 小C = new Subscriber<String>() {
        @Override 
	public void onCompleted() {  
   		System.out.println("s====================onCompleted======");            
	}           
 	@Override
	public void onError(Throwable throwable) { 
  	}            
	@Override            
	public void onNext(String s) {                
		System.out.println("s=========================="+s);                
		subscriber.onNext(Integer.parseInt(s));  // subscriber 在小B call中传入 
		Subscriber action= new ActionSubscriber(onNext,onError,onCompleted);
		// subscriber 就是它---------------------------------------------->>>	          
	}            
		
			
	@Override           
	public void onStart() {                
		super.onStart();                
		System.out.println("s====================onStart======");            
	}        
}