RxJava1学习过程部分总结

###create()+subscribe()：
这是Rx经常写的代码

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
       @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("content");
            subscriber.onCompleted();
        }
    });
Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onCompleted() {
        Log.e("onCompleted", "onCompleted");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        Log.e("onNext", s);
    }
};
observable.subscribe(subscriber);

1.这段代码返回一个Observable对象，hook.onCreate(f)作为参数传递过去。

public static <T> Observable<T> create(OnSubscribe<T> f) {
	return new Observable<T>(hook.onCreate(f));
}

2.看代码可知，其实返回的就是传入的参数f；

public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
	return f;
}

3.调用create其实就是将OnSubscribe的实现类赋值给了Observable的成员：onSubscribe

protected Observable(OnSubscribe<T> f) {
	this.onSubscribe = f;
}
public class Observable<T> {
   	final OnSubscribe<T> onSubscribe;
	...
}
然后从外面拿到这个onSubscribe.

4.observable在调用subscribe的时候，看onSubscribeStart（xx,xx,xx）可知，会发现返回的就是传入的第二个参数observable.onSubscribe，3中所提到的onSubscribe。

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
 	...
    try {
        hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
        return hook.onSubscribeReturn(subscriber);
    } catch (Throwable e) {
        ...
        return Subscriptions.unsubscribed();
    }
}
这时调用onSubsribe.call(subscriber)就会回调我们在获取observble时实现的call方法，在call中调用相应的onNext...

###map():

return Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext(text);
    }
}).map(new Func1<String, List<String>>() {
    @Override
    public List<String> call(String s) {
        List<String> list = new ArrayList<>();
        list.add(s + 1);
        list.add(s + 2);
        return list;
    }
});

1.可知，可通过map获取新的Observable对象，并将“new OnSubscribeLift(onSubscribe, operator)”此对象赋值给onSubscribe。调用map之前要调用create(),所以这个对象的构造参数之一onSubscribe就是create（）中的实现类参数（相当于上一级的onSubscribe）。

public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
	return lift(new OperatorMap<T, R>(func));
}
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
    return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
}
protected Observable(OnSubscribe<T> f) {
    this.onSubscribe = f;
}

2.map后调用subscribe，根据之前分析可以写成：new OnSubscribeLift(onSubscribe, operator).call(subsriber)。

hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);

3.再看看OnSubscribeLift，必然会回调次call方法，可以看到hook.onLift(operator)返回的就是operator。

@Override
public void call(Subscriber<? super R> o) {
    try {
        Subscriber<? super T> st = hook.onLift(operator).call(o);
        try {
            st.onStart();
            parent.call(st);
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            st.onError(e);
        }
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        o.onError(e);
    }
}	

public <T, R> Operator<? extends R, ? super T> onLift(final Operator<? extends R, ? super T> lift) {
	return lift;
}

4.刚开始调用map的时候，new了一个OperatorMap，这里的operator就是它的实例。必然会调用这个call方法，这里的o就是我们在subscribe中传入的实现类参数，transformer就是map传入的实现call方法的实现类参数。将MapSubscriber实例返回。

public final class OperatorMap<T, R> implements Operator<R, T> {

	final Func1<? super T, ? extends R> transformer;
	
	public OperatorMap(Func1<? super T, ? extends R> transformer) {
	    this.transformer = transformer;
	}
	
	@Override
	public Subscriber<? super T> call(final Subscriber<? super R> o) {
	    MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
	    o.add(parent);
	    return parent;
	}
}

5.在3中，代码走到parent.call(st);将4中返回的MapSubscriber实例传入。（特别说明一下：这个parent就是1中所说的调用create后传入的实现类，给onSubscribe第一次赋的值，也就是上一级的onSubscribe）。所以：此时回调，create方法传入的实现了call方法的实现类，走到subscriber.onNext();就会回调下面的代码

static final class MapSubscriber<T, R> extends Subscriber<T> {
       ...
        
    public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
        this.actual = actual;
        this.mapper = mapper;
    }
    
    @Override
    public void onNext(T t) {
        R result;
        try {
            result = mapper.call(t);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            unsubscribe();
            onError(OnErrorThrowable.addValueAsLastCause(ex, t));
            return;
        }
        actual.onNext(result);
    }
    
    @Override
    public void onError(Throwable e) {
       ...
        actual.onError(e);
    }

    @Override
    public void onCompleted() {
        ...
        actual.onCompleted();
    }
    ...
}

6.走到result = mapper.call(t);就会回调map参数中实现call方法的实现类，进行转换，得到新的类型，再次调用actual.onNext(result);就会回调我们在subscribe方法中传入的实现类中的onNext（），将转型后的类型，发送回来。