RxJava 1.x核心组件介绍

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方法一次。