###简单回顾
如果抛开Rxjava的操作符以及其线程控制的话，Rxjava的最基本使用是比较简单的 第一步，创建被观察者Observable； 第二步，创建观察者Observer/Subscriber； 第三步，subscribe；
###三个关键对象和一个核心方法
- 三个关键对象
-
Observable（被观察者）
-
OnSubscribe 此对象是
Observable内部的对象， 可以对等地理解成是观察者模式中，被观察者用来通知观察者的notifyObservers()方法； -
Subscriber（观察者）
-
- 一个核心方法
- subscribe()
订阅方法， 完成观察者和被观察者之间的订阅；
- subscribe()
###Rxjava源码相关分析
######Observable类中的create()源码：
public class Observable<T> {
final OnSubscribe<T> onSubscribe;
protected Observable(OnSubscribe<T> f) {
this.onSubscribe = f;
}
static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
public static <T> Observable<T> create(OnSubscribe<T> f) {
return new Observable<T>(hook.onCreate(f));
}
@Beta
public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe) {
return new Observable<T>(hook.onCreate(syncOnSubscribe));
}
@Experimental
public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscribe) {
return new Observable<T>(hook.onCreate(asyncOnSubscribe));
}
...
}
- 第一步，调用
Observable.create()方法完成Observable的创建； 下面跟进create()源码，-
我们发现
create方法内部， 会传入一个OnSubscribe的参数， 其实这个从外部传进来的OnSubscribe参数， 最终也会通过new调用Observable的构造方法， 最终传给Observable的全局变量 onSubscribe -
而关于
全局变量 Observable.OnSubscribe类型的对象 onSubscribe， 我们刚刚提到， 可以对等地理解成是观察者模式中，被观察者用来通知观察者的notifyObservers()方法； -
接着我们看源码中第一个
create()的重载方法， 其最后都是return，返回一个new调用构造方法创建好的Observable对象； -
而在
create()内部， 赋值给构造函数的参数是调用了一个hook.onCreate()方法；
下面关注一下hook， 可以看到关于hook的定义——static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
事实上我们可以把hook理解成为一个抽象的代理类对象； 默认情况下，hook不会的OnSubscribe对象做任何的处理；
一句话总结一下，Observable的就是通过代理类对象hook创建的， 而默认情况下，hook不会的OnSubscribe对象做任何的处理； 当然，默认不处理， 但是我们需要的话自然是可以个性化地重写这个方法的；
所以create()所做的工作是， 构造一个新的Observable对象， 同时借助Observable类的原生构造方法， 将传进来的OnSubscribe对象赋给类中的全局变量onSubscribe； 如此便完成了被观察者Observable的创建生成；
-
示例代码如下：
//第一步：创建被观察者：create Observable observable = Observable.create(new >Observable.OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { subscriber.onNext("Hello"); subscriber.onNext("Imooc"); subscriber.onCompleted(); } }); //通过just方法来创建被观察者 Observable observableJust = Observable.just("hello", "Imooc"); //通过from方法来创建被观察者 String[] parameters = {"hello", "Imooc"}; Observable observableFrom = Observable.from(parameters);可以看到，创建
Observable的实质， 就是new一个OnSubscribe接口并实现其call()方法， 然后把实现了call()方法的整个OnSubscribe接口对象作为参数赋值给Observable的create()方法；
创建Observable 实例之后， 会把这个OnSubscribe 对象参数存到本Observable示例的全局变量中；
等到回调call()方法时候， 其实就是Observable.subscribe() - subscribe()中call()， 这个call()方法现在是“存储在”Observable 实例中的方法， 也是方才传进来的， 实现了call()方法的整个OnSubscribe接口对象参数； ##！！！这个地方实际上就跟onClick()的实现逻辑相当类似！！！！
**```观察者创建```以及```订阅```实例代码：** ``` //第二步：创建观察者 Observer observer = new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Object s) {
}
};
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
}
@Override
public void onStart() {
super.onStart();
}
};
public void doRxjava(){
//第三步：订阅
observable.subscribe(observer);
observable.subscribe(subscriber);
}
- **第二步，创建```Observer```观察者对象；**
这里有两个接口——```Observer```和```Subscriber```
- 其实```Subscriber```内部也只对```Observer```做了一些拓展，
它们两个的使用方式基本是相同的；
当然就是有一些```回调接口```的差异；
- Rxjava内部最终会将```Observer```转换成```Subscriber```；
接下来是```Rxjava的SDK```中```subscribe()```的传入参数
是```Observer```时候（```observable.subscribe(observer);```）的源码：
public final Subscription subscribe(final Observer<? super T> observer) {
if (observer instanceof Subscriber) {
return subscribe((Subscriber<? super T>)observer);
}
return subscribe(new Subscriber<T>() {
@Override
public void onCompleted() {
observer.onCompleted();
}
@Override
public void onError(Throwable e) {
observer.onError(e);
}
@Override
public void onNext(T t) {
observer.onNext(t);
}
});
}
```Rxjava的SDK```中```subscribe()```的传入参数
是```Subscriber```时候（```observable.subscribe(subscriber);```）的源码：
public final Subscription subscribe(Subscriber<? super T> subscriber) { return Observable.subscribe(subscriber, this); }
- .
- 这里可以看到如果传给```subscribe()```的对象是```Observer```，
则会在源码Rxjava的```源码```中首先被转换成```Subscriber```，
之后再进行后续操作；
**也即应证了之前所说的Rxjava内部
最终会将```Observer```转换成```Subscriber```再进行后续处理；**
---
<br>
#####Subscriber源码分析
package rx;
import rx.internal.util.SubscriptionList;
public abstract class Subscriber implements Observer, Subscription {
// represents requested not set yet
private static final Long NOT_SET = Long.MIN_VALUE;
private final SubscriptionList subscriptions;
private final Subscriber<?> subscriber;
/* protected by `this` */
private Producer producer;
/* protected by `this` */
private long requested = NOT_SET; // default to not set
protected Subscriber() {
this(null, false);
}
protected Subscriber(Subscriber<?> subscriber) {
this(subscriber, true);
}
protected Subscriber(Subscriber<?> subscriber, boolean shareSubscriptions) {
this.subscriber = subscriber;
this.subscriptions = shareSubscriptions && subscriber != null ? subscriber.subscriptions : new SubscriptionList();
}
public final void add(Subscription s) {
subscriptions.add(s);
}
@Override
public final void unsubscribe() {
subscriptions.unsubscribe();
}
@Override
public final boolean isUnsubscribed() {
return subscriptions.isUnsubscribed();
}
public void onStart() {
// do nothing by default
}
protected final void request(long n) {
if (n < 0) {
throw new IllegalArgumentException("number requested cannot be negative: " + n);
}
// if producer is set then we will request from it
// otherwise we increase the requested count by n
Producer producerToRequestFrom = null;
synchronized (this) {
if (producer != null) {
producerToRequestFrom = producer;
} else {
addToRequested(n);
return;
}
}
// after releasing lock (we should not make requests holding a lock)
producerToRequestFrom.request(n);
}
private void addToRequested(long n) {
if (requested == NOT_SET) {
requested = n;
} else {
final long total = requested + n;
// check if overflow occurred
if (total < 0) {
requested = Long.MAX_VALUE;
} else {
requested = total;
}
}
}
public void setProducer(Producer p) {
long toRequest;
boolean passToSubscriber = false;
synchronized (this) {
toRequest = requested;
producer = p;
if (subscriber != null) {
// middle operator ... we pass through unless a request has been made
if (toRequest == NOT_SET) {
// we pass through to the next producer as nothing has been requested
passToSubscriber = true;
}
}
}
// do after releasing lock
if (passToSubscriber) {
subscriber.setProducer(producer);
} else {
// we execute the request with whatever has been requested (or Long.MAX_VALUE)
if (toRequest == NOT_SET) {
producer.request(Long.MAX_VALUE);
} else {
producer.request(toRequest);
}
}
}
}
public abstract class Subscriber implements Observer, Subscription {...
- ```Subscriber```实现了```Observer```、```Subscription```两个接口；
```Observer```接口即前面所提的另一个```观察者接口```；
- **```Subscription```源码**
- unsubscribe()：**解绑；
当```“订阅事件的列表”```
（也即```当前观察者```中的一个放着```所有订阅事件的列表```的```成员变量```）
之中不再有订阅事件时，
调用这个方法来对“订阅事件列表”进行解绑；**
- isUnsubscribed()：判断是否已经解绑订阅事件；
package rx;
import rx.subscriptions.Subscriptions;
public interface Subscription { void unsubscribe();
boolean isUnsubscribed();
}
- ``` private final SubscriptionList subscriptions;```
这个```List```即前面```unsubscribe()```中提到的“订阅事件的列表”；
其中包含的是```观察者所有的订阅事件```；
<br>当```Subscriber 取消订阅```的时候，
这个```List```中就会有```事件```被```删除```（得益于实现了```Subscription```接口）；
<br>当这个```List```中没有任何```事件```了，
即**列表中所有的事件都被取消订阅了；**
那么这个```List```也就```为空```；
**以上则是```Subscriber```的核心逻辑；**
---
#####第三步，下面具体分析```订阅```的实现
>**下面小结一下，```call()```方法在```subscribe()```方法之中```被调用```
（从下面```subscribe()```方法的源码中可以见得），
<br>也即默认```subscribe()```方法被调用之后
（```observable.subscribe(observer);```或者```observable.subscribe(subscriber);```），
<br>会```触发```在```创建Observable```时候实现的```OnSubscribe<>```中的```call()```方法，
完成回调；
```call()```方法中可以实现```一系列事件消费的过程```——```onNext()、onCompleted()```等；**
>```observable```中调用了```onNext、onCompleted()```的时候，
相应订阅了的```Observer/Subscriber```中的```onNext、onCompleted()```也就被```调用执行```；
>```
>//第一步：创建被观察者：create
> Observable observable = Observable.create(new >Observable.OnSubscribe<String>() {
> @Override
> public void call(Subscriber<? super String> subscriber) {
> subscriber.onNext("Hello");
> subscriber.onNext("Imooc");
> subscriber.onCompleted();
> }
> });
>
> //通过just方法来创建被观察者
> Observable observableJust = Observable.just("hello", "Imooc");
>
> //通过from方法来创建被观察者
> String[] parameters = {"hello", "Imooc"};
> Observable observableFrom = Observable.from(parameters);
>```
>**以上便是Rxjava```最基本的使用方式```；**
```Rxjava的SDK```中```subscribe()```的传入参数
是```Subscriber```时候（```observable.subscribe(subscriber);```）的源码：
public final Subscription subscribe(Subscriber<? super T> subscriber) { return Observable.subscribe(subscriber, this); }
- 可以看到```Subscription subscribe()```中，
又调用了另外一个```“同名的订阅方法”Observable.subscribe()```，
传入的是```subscriber```和```this```两个参数；
- ######跟进```Observable.subscribe()```的源码：
private static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
if (subscriber == null) {
throw new IllegalArgumentException("observer can not be null");
}
if (observable.onSubscribe == null) {
throw new IllegalStateException("onSubscribe function can not be null.");
}
subscriber.onStart();
if (!(subscriber instanceof SafeSubscriber)) {
subscriber = new SafeSubscriber<T>(subscriber);
}
try {
hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
try {
subscriber.onError(hook.onSubscribeError(e));
} catch (Throwable e2) {
Exceptions.throwIfFatal(e2);
RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
hook.onSubscribeError(r);
throw r;
}
return Subscriptions.unsubscribed();
}
}
- 首先是对```subscriber```和```observable.onSubscribe```判空，
空则抛出异常；
```if (subscriber == null) {... }```
```if (observable.onSubscribe == null) {...}```
接着，
- ```subscriber.onStart();```，
跟进一下```onStart()```，
可以发现它其实是```Subscriber```类中的一个空方法；
默认什么都不做，需要我们自己调用的时候去实现；
- 要把传进来的```subscriber```包装成```SafeSubscriber```来进行后续操作，
而这个```SafeSubscriber```其实就是比```subscriber```多做了一系列更完善的处理，
当然它也包含了```subscriber```拥有的```onCompleted()```、```onError()```等方法：
if (!(subscriber instanceof SafeSubscriber)) { subscriber = new SafeSubscriber(subscriber); }
- ```hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber); ```
```return hook.onSubscribeReturn(subscriber);```
接着我们可以看到源码以```subscriber```为参数，
调用了```call()```回调方法；
**调用完了```call()```方法，
意味着完成了一次```订阅```；**
接着通过代理类```hook```将```subscriber```以```Subscription```的类型返回
（```public <T> Subscription onSubscribeReturn(Subscription subscription) {...}```）
（此处```subscriber对象```向上转型，
当成接口```Subscription```类型使用，
因为```Subscriber类```实现了接口```Subscription```，乃其```子类```）；
<br>前面提到过，
接口```Subscription```是每一个观察者```Subscriber```必须实现的接口，
同时```Subscriber```的实例都有一个```SubscriptionList```，
这个```List```包含的是观察者所有的订阅事件；
<br>至此便完成了```Subscriber```核心的主要的```订阅流程```；
<br>
----
- ######跟进```SafeSubscriber```源码：
public class SafeSubscriber extends Subscriber {
private final Subscriber<? super T> actual;
boolean done = false;
public SafeSubscriber(Subscriber<? super T> actual) {
super(actual);
this.actual = actual;
}
@Override
public void onCompleted() {
if (!done) {
done = true;
try {
actual.onCompleted();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
RxJavaPluginUtils.handleException(e);
throw new OnCompletedFailedException(e.getMessage(), e);
} finally {
try {
unsubscribe();
} catch (Throwable e) {
RxJavaPluginUtils.handleException(e);
throw new UnsubscribeFailedException(e.getMessage(), e);
}
}
}
}
@Override
public void onError(Throwable e) {
Exceptions.throwIfFatal(e);
if (!done) {
done = true;
_onError(e);
}
}
@Override
public void onNext(T args) {
try {
if (!done) {
actual.onNext(args);
}
} catch (Throwable e) {
Exceptions.throwOrReport(e, this);
}
}
protected void _onError(Throwable e) {
RxJavaPluginUtils.handleException(e);
try {
actual.onError(e);
} catch (Throwable e2) {
if (e2 instanceof OnErrorNotImplementedException) {
try {
unsubscribe();
} catch (Throwable unsubscribeException) {
RxJavaPluginUtils.handleException(unsubscribeException);
throw new RuntimeException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException)));
}
throw (OnErrorNotImplementedException) e2;
} else {
RxJavaPluginUtils.handleException(e2);
try {
unsubscribe();
} catch (Throwable unsubscribeException) {
RxJavaPluginUtils.handleException(unsubscribeException);
throw new OnErrorFailedException("Error occurred when trying to propagate error to Observer.onError and during unsubscription.", new CompositeException(Arrays.asList(e, e2, unsubscribeException)));
}
throw new OnErrorFailedException("Error occurred when trying to propagate error to Observer.onError", new CompositeException(Arrays.asList(e, e2)));
}
}
try {
unsubscribe();
} catch (RuntimeException unsubscribeException) {
RxJavaPluginUtils.handleException(unsubscribeException);
throw new OnErrorFailedException(unsubscribeException);
}
}
public Subscriber<? super T> getActual() {
return actual;
}
}
- 从源码可以看到```SafeSubscriber类```中，
也有```onCompleted() 、onError()、onNext()```等方法；
它就是对```subscriber类```做了一个包装；
- 注意```onCompleted() 或者onError()```方法被执行的时候，
就不会再执行```onNext()```（注意布尔变量```done```）；
（因```完成状态/Completed```或者```异常状态/Error```发生后，
就没必要在进行```下一步/Next```的操作了）
（```onComplete()```和```onError()```是互斥的，
也就是一次只能调用其中一个，不能同时调用）
<br><br>
<br><br>
---
参考自 慕课网
