RxJava的简单使用（一）

1.RxJava的介绍

主要特点有：

1. 易于并发从而更好的利用服务器的能力。
2. 易于有条件的异步执行。
3. 一种更好的方式来避免回调地狱。
4. 一种响应式方式。

2.RxJava的与众不同

有三个重要的功能：

1. 生产者在没有更多的数据可用时能够发出信号通知：onCompleted()事件。
2. 生产者在发生错误时能够发出信号通知：onError()事件。
3. RxJava Observables 能够组合而不是嵌套，从而避免开发者陷入回调。 onNext()事件

有三个重要的角色：
1. Observable(被观察者)
2. Observer(观察者)
3. Subjects(订阅者)

三者的关联:
Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。

3.常用的操作符

create，just，from，empty，never，error

1. create()方法创建一个Observable(被观察者)。需要传一个OnSubscribe < T >对象，该对象继承Action1，当Observer(观察者)订阅，被Observable(被观察者)时，它作为一个参数传入并执行Call（）函数。

源码

 /**     * Constructs an Observable in an unsafe manner, that is, unsubscription and backpressure handling is the responsibility of the OnSubscribe implementation.     * @param <T> the value type emitted     * @param f the callback to execute for each individual Subscriber that subscribes to the     *          returned Observable     * @return the new Observable instance     * @deprecated 1.2.7 - inherently unsafe, use the other create() methods for basic cases or     * see {@link #unsafeCreate(OnSubscribe)} for advanced cases (such as custom operators)     * @see #create(SyncOnSubscribe)     * @see #create(AsyncOnSubscribe)     * @see #create(Action1, rx.Emitter.BackpressureMode)     */    @Deprecated    public static <T> Observable<T> create(OnSubscribe<T> f) {        return new Observable<T>(RxJavaHooks.onCreate(f));    }/**     * Invoked when Observable.subscribe is called.     * @param <T> the output value type     */    public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {        // cover for generics insanity    }/** * A one-argument action. * @param <T> the first argument type */public interface Action1<T> extends Action {    void call(T t);}

通过以上的源码，看看怎么使用该方法

 Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {            @Override            public void call(Subscriber<? super Integer> observer) {                for (int i = 0; i < 5; i++) {                    observer.onNext(i);                }                observer.onCompleted();            }        });        Subscription subscription = observable.subscribe(new Subscriber<Integer>() {            @Override            public void onCompleted() {                System.out.println("RxJavaActivity.onCompleted,生产者数据已经走完");            }            @Override            public void onError(Throwable e) {                System.out.println("e = " + e.getMessage().toString());            }            @Override            public void onNext(Integer integer) {                System.out.println("integer = " + integer);            }        });

打印日志：
06-27 17:40:36.111 6016-6016/test.demo I/System.out: integer = 0
06-27 17:40:36.112 6016-6016/test.demo I/System.out: integer = 1
06-27 17:40:36.112 6016-6016/test.demo I/System.out: integer = 2
06-27 17:40:36.112 6016-6016/test.demo I/System.out: integer = 3
06-27 17:40:36.112 6016-6016/test.demo I/System.out: integer = 4
06-27 17:40:36.112 6016-6016/test.demo I/System.out: RxJavaActivity.onCompleted,生产者数据已经走完

还有一个要说的是，当我们onCompleted()与onError()两个方法调用之后，onNext()该方法就不会在执行。可以自行测试，将代码修改成这样：

 Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {            @Override            public void call(Subscriber<? super Integer> observer) {                 observer.onCompleted();                for (int i = 0; i < 5; i++) {                    observer.onNext(i);                }            }        });

Log日志：
06-27 17:40:36.112 6016-6016/test.demo I/System.out: RxJavaActivity.onCompleted,生产者数据已经走完

所以说，该调用与先后顺序也有一定的关系。我们在看源码：

 public final Subscription subscribe(Subscriber<? super T> subscriber) {        return Observable.subscribe(subscriber, this);    }    static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {     // 判断我们subscriber是否为null        if (subscriber == null) {            throw new IllegalArgumentException("subscriber can not be null");        }        if (observable.onSubscribe == null) {            throw new IllegalStateException("onSubscribe function can not be null.");          //  the subscribe function can also be overridden but generally that's not the appropriate approach so I won't mention that in the exception        }        // 调用订阅者的onStart()方法，由此可以得出，该方法是必走的        subscriber.onStart();        // 将(subscriber不安全)的订阅者转换成(SafeSubscriber安全)的订阅者        if (!(subscriber instanceof SafeSubscriber)) {            // assign to `observer` so we return the protected version            //返回一个受保护的subscriber            subscriber = new SafeSubscriber<T>(subscriber);        }//        后面代码不必追究        .......            return Subscriptions.unsubscribed();        }    }//我们看SafeSubscriber类的代码public class SafeSubscriber<T> extends Subscriber<T> {    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; //这里可以看出，当该方法调用之后，done设置成了 true;            try {                actual.onCompleted();            } catch (Throwable e) {                throw new OnCompletedFailedException(e.getMessage(), e);            } finally { // NOPMD                try {                    unsubscribe();                } catch (Throwable e) {                    RxJavaHooks.onError(e);                    throw new UnsubscribeFailedException(e.getMessage(), e);                }            }        }    }    /**    @Override    public void onError(Throwable e) {        Exceptions.throwIfFatal(e);        if (!done) {            done = true; //这里可以看出，当该方法调用之后，done设置成了 true;            _onError(e);        }    }    @Override    public void onNext(T t) {        try {            if (!done) {//当done=true时，跳出该方法                actual.onNext(t);            }        } catch (Throwable e) {            Exceptions.throwOrReport(e, this);        }    }    @SuppressWarnings("deprecation")    protected void _onError(Throwable e) { // NOPMD        RxJavaPlugins.getInstance().getErrorHandler().handleError(e);        try {            actual.onError(e);        } catch (OnErrorNotImplementedException e2) { // NOPMD            try {                unsubscribe();            } catch (Throwable unsubscribeException) {                RxJavaHooks.onError(unsubscribeException);                throw new OnErrorNotImplementedException("Observer.onError not implemented and error while unsubscribing.", new CompositeException(Arrays.asList(e, unsubscribeException))); // NOPMD            }            throw e2;        } catch (Throwable e2) {            RxJavaHooks.onError(e2);            try {                unsubscribe();            } catch (Throwable unsubscribeException) {                RxJavaHooks.onError(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 (Throwable unsubscribeException) {            RxJavaHooks.onError(unsubscribeException);            throw new OnErrorFailedException(unsubscribeException);        }    }    public Subscriber<? super T> getActual() {        return actual;    }}

以上代码，可以看出当调用了onError（），onCompleted（）方法时，done=true之后，onNext()方法则不在执行，另外就是onError（），onCompleted（）两方法是互斥的，一方法调用之后，则另一方法不在执行。

1. from()的使用方法我们可以看代码：

//from方法传参，只支持数组与集合类型的参数。具体看源码ArrayList<Integer> list = new ArrayList<>();        list.add(100);        list.add(200);        list.add(300);        list.add(400);String[] strings = new String[]{"1","2","3","4"};        Observable.from(strings)                .map(Integer::parseInt)//通过map将类型转成整型                .subscribe(new Subscriber<Integer>() {                    @Override                    public void onCompleted() {                        System.out.println("from.onCompleted");                    }                    @Override                    public void onError(Throwable e) {                        System.out.println("e = " + e.getMessage().toString());                    }                    @Override                    public void onNext(Integer integer) {                        System.out.println("integer = " + integer);                    }                });Log日志：06-28 09:57:59.165 27726-27726/test.demo I/System.out: integer = 106-28 09:57:59.690 27726-27726/test.demo I/System.out: integer = 206-28 09:58:00.058 27726-27726/test.demo I/System.out: integer = 306-28 09:58:00.619 27726-27726/test.demo I/System.out: integer = 406-28 09:58:01.572 27726-27726/test.demo I/System.out: from.onCompleted

1. just()方法使用，代码：

//just()支持多种类型的传参，而且可以传多个参数。    ArrayList<Integer> list = new ArrayList<>();        list.add(100);        list.add(200);        list.add(300);        list.add(400);        //just它只能发射整个列表，不会迭代发射整个列表的每个值        Observable.just(list)                .subscribe(new Subscriber<ArrayList<Integer>>() {                    @Override                    public void onCompleted() {                        System.out.println("just.onCompleted");                    }                    @Override                    public void onError(Throwable e) {                        System.out.println("e = " + e.getMessage().toString());                    }                    @Override                    public void onNext(ArrayList<Integer> integers) {                        for (int i = 0; i < integers.size(); i++) {                            System.out.println(integers.get(i));                        }                    }                });

1. Observable.never()方法，看源码：

public static <T> Observable<T> never() {        return NeverObservableHolder.instance();//返回一个单列    }//再看NeverObservableHolder.class源码：public enum NeverObservableHolder implements OnSubscribe<Object> {    INSTANCE    ;    /** The singleton instance. */    static final Observable<Object> NEVER = Observable.unsafeCreate(INSTANCE);    /**     * Returns a type-corrected singleton instance of the never Observable.     * @param <T> the value type     * @return a type-corrected singleton instance of the never Observable.     */    @SuppressWarnings("unchecked")    public static <T> Observable<T> instance() {        return (Observable<T>)NEVER;    }//因为是实现了OnSubscribe接口，则会生成call方法，可以看到方法内什么都没做，所以调用该方法直接结束了观察者的执行。    @Override    public void call(Subscriber<? super Object> child) {        // deliberately no op    }}

1. Observable.empty()方法，看源码：

    public static <T> Observable<T> empty() {        return EmptyObservableHolder.instance();//返回一个单列    }    //再看EmptyObservableHolder.class类    public enum EmptyObservableHolder implements OnSubscribe<Object> {    INSTANCE    ;    /** The singleton instance. */     static final Observable<Object> EMPTY = Observable.unsafeCreate(INSTANCE);    /**     * Returns a type-corrected singleton instance of the empty Observable.     * @param <T> the value type     * @return a type-corrected singleton instance of the empty Observable.     */    @SuppressWarnings("unchecked")    public static <T> Observable<T> instance() {        return (Observable<T>)EMPTY;    }    @Override    public void call(Subscriber<? super Object> child) {        child.onCompleted();//直接走了已完成的方法，结束其它方法的执行。    }}

1. Observable.error()方法，看源码：

  public static <T> Observable<T> error(Throwable exception) {        return unsafeCreate(new OnSubscribeThrow<T>(exception));//直接创建一个异常的OnSubscribe    }  //再看OnSubscribeThrow.class类public final class OnSubscribeThrow<T> implements OnSubscribe<T> {    private final Throwable exception;    public OnSubscribeThrow(Throwable exception) {        this.exception = exception;    }    /**     * Accepts an {@link Observer} and calls its {@link Observer#onError onError} method.     *     * @param observer     *            an {@link Observer} of this Observable     */    @Override    public void call(Subscriber<? super T> observer) {        observer.onError(exception); //直接执行异常的方法，其它方法则结束执行    }}