RxJava简单示例

RxJava - JVM响应式扩展Reactive Extensions 用于使用Java VM的可观察序列编写异步和基于事件的程序的库。

Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点。

简单示例：

首先创建一个被观察者Observable，之后创建一个观察者（订阅者），接着建立订阅关系。

   public static void main(String[] args) {
        Observable ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                System.out.println("我已经执行完毕了，可以通知订阅者了");
                subscriber.onNext("hello RxJava");
            }
        });

        Observer<String> observer = new Observer<String>() {
            public void onCompleted() {
                System.out.println("观察结束");
            }

            public void onError(Throwable e) {
            }

            public void onNext(String str) {
                System.out.println("被观察对象发来的信息"+str);
            }
        };

        ob.subscribe(observer);
    }

看一下执行结果。

这个是最简单的例子。同时RxJava也支持创建很多事件Action，从Action0-9。比如我们这个例子创建一个Action0。完成代码如下：

Observable.doOnSubscribe方法

    public static void main(String[] args) {
        Action0 action0 = new Action0() {
            public void call() {
                System.out.println("action0 事件是最开始执行的，在所有执行之前");
            }
        };

        Observable ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                System.out.println("我已经执行完毕了，可以通知订阅者了");
                subscriber.onNext("hello RxJava");
            }
        });

        Observer<String> observer = new Observer<String>() {
            public void onCompleted() {
                System.out.println("观察结束");
            }

            public void onError(Throwable e) {
            }

            public void onNext(String str) {
                System.out.println("被观察对象发来的信息"+str);
            }
        };

        ob = ob.doOnSubscribe(action0);
        ob.subscribe(observer);
    }

结果：

我们看一下ob.doOnSubscribe(action0)源码：

    public final Observable<T> doOnSubscribe(final Action0 subscribe) {
        return lift(new OperatorDoOnSubscribe<T>(subscribe));
    }

    public OperatorDoOnSubscribe(Action0 subscribe) {
        this.subscribe = subscribe;
    }

    @Override
    public Subscriber<? super T> call(final Subscriber<? super T> child) {
        subscribe.call();
        // Pass through since this operator is for notification only, there is
        // no change to the stream whatsoever.
        return Subscribers.wrap(child);
    }

    Subscribers类中
    public static <T> Subscriber<T> wrap(final Subscriber<? super T> subscriber) {
        return new Subscriber<T>(subscriber) {

            @Override
            public void onCompleted() {
                subscriber.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                subscriber.onError(e);
            }

            @Override
            public void onNext(T t) {
                subscriber.onNext(t);
            }

        };
    }

可以看到先会执行action.call方法。

Observable.doOnNext方法：

doOnNext方法需要Action1，我们创建一个Action1。

    public static void main(String[] args) {
        Action0 action0 = new Action0() {
            public void call() {
                System.out.println("action0 事件是最开始执行的，在所有执行之前");
            }
        };

        Action1 action1 = new Action1() {
            public void call(Object o) {
                System.out.println("action1 事件是被观察者已经执行完毕，调用订阅者OnNext方法之前");
            }
        };

        Observable ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                System.out.println("我已经执行完毕了，可以通知订阅者了");
                subscriber.onNext("hello RxJava");
            }
        });

        Observer<String> observer = new Observer<String>() {
            public void onCompleted() {
                System.out.println("观察结束");
            }

            public void onError(Throwable e) {
            }

            public void onNext(String str) {
                System.out.println("被观察对象发来的信息"+str);
            }
        };

        ob = ob.doOnSubscribe(action0);
        ob = ob.doOnNext(action1);
        ob.subscribe(observer);
    }

同时添加ob = ob.doOnNext(action1)。看下执行结果。

doOnNext 源码解析：

    public final Observable<T> doOnNext(final Action1<? super T> onNext) {
        Action1<Throwable> onError = Actions.empty();
        Action0 onCompleted = Actions.empty();
        Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);

        return create(new OnSubscribeDoOnEach<T>(this, observer));
    }

    OnSubscribeDoOnEach类中
   public OnSubscribeDoOnEach(Observable<T> source, Observer<? super T> doOnEachObserver) {
        this.source = source;
        this.doOnEachObserver = doOnEachObserver;
    }

    @Override
    public void call(final Subscriber<? super T> subscriber) {
        source.unsafeSubscribe(new DoOnEachSubscriber<T>(subscriber, doOnEachObserver));
    }

    private static final class DoOnEachSubscriber<T> extends Subscriber<T> {

        private final Subscriber<? super T> subscriber;
        private final Observer<? super T> doOnEachObserver;

        private boolean done;

        DoOnEachSubscriber(Subscriber<? super T> subscriber, Observer<? super T> doOnEachObserver) {
            super(subscriber);
            this.subscriber = subscriber;
            this.doOnEachObserver = doOnEachObserver;
        }

        .......................
        public void onNext(T value) {
            if (done) {
                return;
            }
            try {
                doOnEachObserver.onNext(value);
            } catch (Throwable e) {
                Exceptions.throwOrReport(e, this, value);
                return;
            }
            subscriber.onNext(value);
        }
    }

在创建doOnNext时，首先会将Action1转为一个观察者对象

Observer<T> observer = new ActionObserver<T>(onNext, onError, onCompleted);。接着执行

new OnSubscribeDoOnEach<T>(this, observer)，创建一个OnSubscribeDoOnEach对象。OnSubscribeDoOnEach对象的call方法会创建DoOnEachSubscriber对象，由于DoOnEachSubscriber继承Subscriber，所以把自己本身也当作了一个订阅者。最后在执行OnNext方法时，先执行Acition1，再执行真正订阅者OnNext。

Observable.subscribeOn方法：

subscribeOn是被观察者异步执行。有事我们执行完毕后不希望影响主线程，可以使用。代码如下：

   public static void main(String[] args) throws  Exception{
        Action0 action0 = new Action0() {
            public void call() {
                System.out.println("action0 事件是最开始执行的，在所有执行之前");
            }
        };

        Action1 action1 = new Action1() {
            public void call(Object o) {
                System.out.println("action1 事件是被观察者已经执行完毕，调用订阅者OnNext方法之前");
            }
        };

        Observable ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                }
                System.out.println("我已经执行完毕了，可以通知订阅者了");
                subscriber.onNext("hello RxJava");
            }
        });

        Observer<String> observer = new Observer<String>() {
            public void onCompleted() {
                System.out.println("观察结束");
            }

            public void onError(Throwable e) {
            }

            public void onNext(String str) {
                System.out.println("被观察对象发来的信息"+str);
            }
        };

        ob = ob.subscribeOn(Schedulers.newThread());
        ob = ob.doOnSubscribe(action0);
        ob = ob.doOnNext(action1);
        ob.subscribe(observer);
        System.out.println("----------main-------------");
        try {
            Thread.sleep(5000);
        } catch (Exception e) {
        }
        System.out.println("----------main-end---------");
    }

执行结果：

subscribeOn源码：

    public final Observable<T> subscribeOn(Scheduler scheduler) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
        }
        return create(new OperatorSubscribeOn<T>(this, scheduler));
    }

public final class OperatorSubscribeOn<T> implements OnSubscribe<T> {

    final Scheduler scheduler;
    final Observable<T> source;

    public OperatorSubscribeOn(Observable<T> source, Scheduler scheduler) {
        this.scheduler = scheduler;
        this.source = source;
    }

    @Override
    public void call(final Subscriber<? super T> subscriber) {
        final Worker inner = scheduler.createWorker();
        subscriber.add(inner);

        inner.schedule(new Action0() {
            @Override
            public void call() {
                final Thread t = Thread.currentThread();

                Subscriber<T> s = new Subscriber<T>(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }

                    @Override
                    public void onError(Throwable e) {
                        try {
                            subscriber.onError(e);
                        } finally {
                            inner.unsubscribe();
                        }
                    }

                    @Override
                    public void onCompleted() {
                        try {
                            subscriber.onCompleted();
                        } finally {
                            inner.unsubscribe();
                        }
                    }

                    @Override
                    public void setProducer(final Producer p) {
                        subscriber.setProducer(new Producer() {
                            @Override
                            public void request(final long n) {
                                if (t == Thread.currentThread()) {
                                    p.request(n);
                                } else {
                                    inner.schedule(new Action0() {
                                        @Override
                                        public void call() {
                                            p.request(n);
                                        }
                                    });
                                }
                            }
                        });
                    }
                };

                source.unsafeSubscribe(s);
            }
        });
    }
}

Observable.subscribeOn就是创建一个OperatorSubscribeOn对象，然后call方法中通过Scheduler异步执行。

以上就是比较简单的RxJava使用示例，当然还有很多方法没有介绍，比如map，flatmap，lift替换等。

RxJava响应式编程是一种基于异步数据流概念的编程模式。数据流就像一条河：它可以被观测，被过滤，被操作，或者为新的消费者与另外一条流合并为一条新的流。