RxJava 1.x核心的组件一共有四个,分别是Observer、Subscriber、Observable、Schedulers,从而实现了基于推送,并且可以异步接收通知的响应式开发框架。
Observer
Observer 是观察者模式中的“观察者”,提供用于接收基于推送机制的通知。
在整个框架中,Observer订阅Observable后。Observer会对Observable发出的任何事件做出响应。 这种模式有利于并发操作,因为它不需要在等待Observable发出对象时阻塞,而是以观察者的形式创建一个监听回调,随时准备在Observable所做的任何时候做出适当的响应。
具体方法说明如下方代码所示:
public interface Observer<T> {
/**
*如果Observable在最后一次调用onNext,如果它没有遇到任何错误,则调用此方 法。
*/
void onCompleted();
/**
* Observable调用此方法以指示它无法生成预期数据或遇到其他一些错误。
* 它不会进一步调用onNext或onCompleted。 onError方法将参数指示导致错误的原因。
*/
void onError(Throwable e);
/**
* 只要Observable发出一个项目,Observable就会调用此方法。 此方法将Observable发出的项作为参数。
*/
void onNext(T t);
}
由上可知,Observer是一个interface,并含有一个未指定类型的泛型参数。当需要接收Observable通知的话就需要订阅并实现指定接收类型的Observer。
Subscriber
Subscriber 也是观察者模式中的“观察者”,提供用于接收基于推送机制的通知。但Subscriber可以手动取消订阅Observable 。
由于Subscriber实现了Observer接口,故Observer在整个框架中起到的作用与Observer大体上是一致的,Subscriber订阅Observable后。Subscriber会对Observable发出的任何事件做出响应。 这种模式有利于并发操作,因为它不需要在等待Observable发出对象时阻塞,而是以观察者的形式创建一个监听回调,随时准备在Observable所做的任何时候做出适当的响应。
具体方法说明如下方代码所示:
public abstract class Subscriber<T> implements Observer<T>, Subscription {
//表示请求尚未设置
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; // 默认为未设置
protected Subscriber() {
this(null, false);
}
/**
*
* 构造一个订阅者(Subscriber)通过使用另外一个订阅者(Subscriber)针对背压和持有subscription列表。
*/
protected Subscriber(Subscriber<?> subscriber) {
this(subscriber, true);
}
/**
*
* 构造一个订阅者(Subscriber)通过使用另外一个订阅者(Subscriber)针对背 压和持有subscription列表。
*
*/
protected Subscriber(Subscriber<?> subscriber, boolean shareSubscriptions) {
this.subscriber = subscriber;
this.subscriptions = shareSubscriptions && subscriber != null ? subscriber.subscriptions : new SubscriptionList();
}
/**
*
* 如果subscriptions列表为未订阅的话,则添加一个Subscription到订阅者的 subscriptions列表
*/
public final void add(Subscription s) {
subscriptions.add(s);
}
//取消订阅
@Override
public final void unsubscribe() {
subscriptions.unsubscribe();
}
/**
* 该订阅者是否为未取消订阅
*/
@Override
public final boolean isUnsubscribed() {
return subscriptions.isUnsubscribed();
}
/**
*
* 当 Subscriber和Observable关系建立以后,该方法将被调用。
* 尚未开始向订阅者发送项目或发送通知。 重写此方法以添加任何
* 对订阅有用的初始化,例如启动背压。
*/
public void onStart() {
// do nothing by default
}
/**
* 从此订阅者订阅的Observable请求特定最大数量的已发出项目。
* 这是一种请求背压的方法。 要禁用背压,请将Long.MAX_VALUE传递给此
*/
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;
}
}
}
/**
* 该方法主要向所包含的Subscriber传递请求。
* 调用该方法,如果在构造器Subscriber(Subscriber)或者Subscriber(Subscriber, boolean))中设置了Subscriber,则会在该方法中设置Producer。如果未设置Subscriber并且未设置请求数,则p.request(Long.MAX_VALUE)被调用;如果未设置Subscriber并且未设置请求数,则会调用p.request(n)(其中n为累计请求数)。
**/
public void setProducer(Producer p) {
long toRequest;
boolean passToSubscriber = false;
synchronized (this) {
toRequest = requested;
producer = p;
if (subscriber != null) {
// middle operator ... we pass thru unless a request has been made
if (toRequest == NOT_SET) {
// we pass-thru 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);
}
}
}
}
Observable
该类提供订阅Observerable以及各类Observers的代理方法。该对象调用Subscriber的onNext,onError以及onCompleted。
一个完整的Observable必须调用Subscriber的onCompleted方法或者onError方法一次。