rxjava1基本元素源码分析

代码示例

Observable observable = Observable.create(new Observable.OnSubscribe() {
	@Override
	public void call(Subscriber subscriber) {
		LogUtils.loge("subscriber call ...");
		if (!subscriber.isUnsubscribed()) {
			subscriber.onNext("test1");
			subscriber.onCompleted();
		}
	}
});

Observer observer = new Observer() {

	@Override
	public void onCompleted() {
		LogUtils.loge("Observer onCompleted");
	}

	@Override
	public void onError(Throwable e) {
	}

	@Override
	public void onNext(String s) {
		LogUtils.loge("Observer onNext s = " + s);
	}
};
Subscription subscription = observable.subscribe(observer);

常用类说明

被观察者

rx.Observable

订阅

rx.Subscription

public interface Subscription {
    void unsubscribe();
    boolean isUnsubscribed();
}

观察者

rx.Observer

public interface Observer {
    void onCompleted();
    void onError(Throwable e);
    void onNext(T t);
}

执行流程

rx.Observable#create(rx.Observable.OnSubscribe)

public static  Observable create(OnSubscribe f) {			
	// 加载RxJavaHooks的static,初始化资源
	// 返回一个Observable对象
    return new Observable(RxJavaHooks.onCreate(f));
}

rx.plugins.RxJavaHooks#onCreate(rx.Observable.OnSubscribe)

public static  Observable.OnSubscribe onCreate(Observable.OnSubscribe onSubscribe) {
    Func1 f = onObservableCreate;
    if (f != null) {
		// 这里其实是调用到了onObservableCreate的call方法
        return f.call(onSubscribe);
    }
    return onSubscribe;
}

rx.plugins.RxJavaHooks

static {
    init();
}

static void init() {
	onObservableStart = new Func2() {
		@Override
		public Observable.OnSubscribe call(Observable t1, Observable.OnSubscribe t2) {
			// 调用开始订阅的方法
			return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeStart(t1, t2);
		}
	};
	
	onObservableReturn = new Func1() {
		@Override
		public Subscription call(Subscription f) {
			return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeReturn(f);
		}
	};
    
	initCreate();
}

static void initCreate() {
    onObservableCreate = new Func1() {
        @Override
        public Observable.OnSubscribe call(Observable.OnSubscribe f) {
			/*
			这里1. 初始化RxJavaObservableExecutionHook 
			    2. 返回我们传入的Observable.OnSubscribe
			*/
            return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);
        }
    };
}

rx.plugins.RxJavaPlugins#getObservableExecutionHook

public RxJavaObservableExecutionHook getObservableExecutionHook() {
    if (observableExecutionHook.get() == null) {
        // 从系统配置文件中查找一个RxJavaObservableExecutionHook的实现类
        Object impl = getPluginImplementationViaProperty(RxJavaObservableExecutionHook.class, System.getProperties());
		// impl = null
        if (impl == null) {
            // 没有找到就使用这个默认的RxJavaObservableExecutionHookDefault实现类
            observableExecutionHook.compareAndSet(null, RxJavaObservableExecutionHookDefault.getInstance());
            // we don't return from here but call get() again in case of thread-race so the winner will always get returned
        } else {
            // we received an implementation from the system property so use it
            observableExecutionHook.compareAndSet(null, (RxJavaObservableExecutionHook) impl);
        }
    }
    return observableExecutionHook.get();
}

rx.plugins.RxJavaObservableExecutionHookDefault

rx.Observable#subscribe(rx.Observer)

public final Subscription subscribe(final Observer observer) {
	// 使用ObserverSubscriber对observer进行包装
	return subscribe(new ObserverSubscriber(observer));
}

rx.Observable#subscribe(rx.Subscriber)

public final Subscription subscribe(Subscriber subscriber) {
    return Observable.subscribe(subscriber, this);
}

rx.Observable#subscribe(rx.Subscriber, rx.Observable)

static  Subscription subscribe(Subscriber subscriber, Observable observable) {
	
    // new Subscriber so onStart it
    subscriber.onStart();
    
	// 保证线程安全
    if (!(subscriber instanceof SafeSubscriber)) {
        // assign to `observer` so we return the protected version
        subscriber = new SafeSubscriber(subscriber);
    }

    try {
        // 调用先RxJavaHooks的onObservableStart的call方法，然后再调用我们在activity中定义的onSubscribe的call方法
		// 这里其实就是调用了开始订阅
        RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
        return RxJavaHooks.onObservableReturn(subscriber);
    } 
}

rx.plugins.RxJavaHooks#onObservableStart

public static  Observable.OnSubscribe onObservableStart(Observable instance, Observable.OnSubscribe onSubscribe) {
    Func2 f = onObservableStart;
    if (f != null) {
        return f.call(instance, onSubscribe);
    }
    return onSubscribe;
}	

rx.plugins.RxJavaHooks#onObservableReturn

public static Subscription onObservableReturn(Subscription subscription) {
    Func1 f = onObservableReturn;
    if (f != null) {
        return f.call(subscription);
    }
    return subscription;
}

ObserverSubscriber类

public final class ObserverSubscriber extends Subscriber {
    final Observer observer;

    public ObserverSubscriber(Observer observer) {
        this.observer = observer;
    }

    @Override
    public void onNext(T t) {
		// 调用observer方法
        observer.onNext(t);
    }

    @Override
    public void onError(Throwable e) {
        observer.onError(e);
    }

    @Override
    public void onCompleted() {
		// 调用observer方法
        observer.onCompleted();
    }
}	

源码阅读总结

Subscription关联观察者和订阅者

static  Subscription subscribe(Subscriber subscriber, Observable observable) {
    try {
        // 调用先RxJavaHooks的onObservableStart的call方法，然后再调用我们在activity中定义的onSubscribe的call方法
		// 这里其实就是调用了开始订阅
        RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
        return RxJavaHooks.onObservableReturn(subscriber);
    } 
}

observable.onSubscribe执行

RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);

课堂总结

Observable

1. 观察得到的-被观察者
2. 通过Observable创建一个可观察的序列(create方法)
3. 通过subscribe去注册一个观察者

Observer

1. 用于接收数据-观察者
2. 作为Observable的subsceibe方法的参数

Subscription

1. 订阅，用于描述被观察者和观察者之间的关系
2. 用于取消订阅和获取当前订阅状态

OnSubscribe

1. 当订阅时会触发此接口的调用
2. 在Observable内部，实际作用是向订阅者发射数据

Subscribe

1. 实现了Observer和Subscription
2. 只有自己才能阻止自己