RxJava

最基本的使用方式：

角色有：Observable（可观察的，被观察者），Observer（观察者）Subscriber（订阅者，也可认为是观察者）

Observer接口定义了三种方法：

public interface Observer {
    //Observable  通知 Observer 已经正常完成数据传输，Observable在最后一次调用onNext后调用该方法
    void onCompleted();
    // Observable 通知 Observer 遇到了error，如果Obverable调用了该方法，它将不会再调用onCompleted 也不会再调用onNext
    void onError(Throwable e);
    //当Observer订阅的事件发生时，Observable调用该方法通知Observer，Observable可以多次调用该方法，但一旦Observable调用了onCompleted或者 onError就不会再调用该方法
    void onNext(T t);
}

Subscriber 是一个实现了Observer的抽象类，提供了订阅，取消订阅，判断当前订阅状态一些功能

package rx;

import rx.internal.util.SubscriptionList;


public abstract class Subscriber implements Observer, Subscription {
    private static final long NOT_SET = Long.MIN_VALUE;

    private final SubscriptionList subscriptions;
    private final Subscriber subscriber;
    private Producer producer;
    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();
    }

    /**
     * 只要list没有被标识为取消订阅（SubscriptionList中有个字段标识），则把当前的Subscription加入。如果list已经被标识为取消订阅，该方法会将当前的Subscription也取消
     */
    public final void add(Subscription s) {
        subscriptions.add(s);
    }

    @Override
    public final void unsubscribe() {
        subscriptions.unsubscribe();
    }

    /**
     * Indicates whether this Subscriber has unsubscribed from its list of subscriptions.
     */
    @Override
    public final boolean isUnsubscribed() {
        return subscriptions.isUnsubscribed();
    }    
}

Observable 中维护了Subscriber的对象，当调用observable的subscribe (Subscriber)方法时，会执行Subscriber中的call方法，这个描述跨度有点大，先理解为当这样调用的时候，表示被观察者（Observable）触发了通知事件，执行观察者（Subscriber）想执行的操作，具体怎么到call方法的后面再分析。

一个简单的使用例子

public class TestRxj {
    public static void main(String[] args) {
        Subscriber subscriber = new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.println("Yeah!Complete!");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("No!Error!");
            }

            @Override
            public void onNext(String t) {
                processData(t);
            }

            private void processData(String data) {
                System.out.println("Hello,I'm received something,i'm going to process it "+data);
            }

        };

        Observable.OnSubscribe onSubscribe = new Observable.OnSubscribe() {

            @Override
            public void call(Subscriber t) {
                if(!t.isUnsubscribed()){
                    t.onNext("this is the first data");
                    t.onCompleted();
                }
            }
        };
        Observable observable = Observable.create(onSubscribe);

        observable.subscribe(subscriber);
    }
}


/** 结果
*Hello,I'm received something,i'm going to process it this is the first data
*Yeah!Complete!
*/

Observable 的subscribe 做的事情：

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

    static  Subscription subscribe(Subscriber subscriber, Observable observable) {
        if (subscriber == null) {
            throw new IllegalArgumentException("subscriber 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(subscriber);
        }


        try {

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

            return RxJavaHooks.onObservableReturn(subscriber);

        } catch (Throwable e) {

            Exceptions.throwIfFatal(e);

            if (subscriber.isUnsubscribed()) {

                RxJavaHooks.onError(RxJavaHooks.onObservableError(e));

            } else {

                try {

                    subscriber.onError(RxJavaHooks.onObservableError(e));

                } catch (Throwable e2) {

                    Exceptions.throwIfFatal(e2);

                    RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);

                    RxJavaHooks.onObservableError(r);
 
                    throw r; // NOPMD

                }
            }
            return Subscriptions.unsubscribed();
        }
    }

Hystrix中的一段

 final protected Observable getExecutionObservable() {

        return Observable.defer(new Func0>() {

            @Override

            public Observable call() {

                try {

                    return Observable.just(run());

                } catch (Throwable ex) {

                    return Observable.error(ex);

                }

            }

        }).doOnSubscribe(new Action0() {

            @Override

            public void call() {

                // Save thread on which we get subscribed so that we can interrupt it later if needed

                executionThread.set(Thread.currentThread());

            }

        });

    }