Android工程师学RxJava（一）:入门

RxJava是我在半年前研究MVP架构的时候看到的，当时不以为然，没有细看，后来在网上到处都能看到这个R君，我才发现原来它这么流行。既然和R君这么有缘，那我们就深入了解吧。

认识RxJava

之前使用过EventBus或者Otto的小伙伴可能应该能对RxJava的理解快一些，因为很类似，编程模式都属于观察者模式。当然也少不了观察者（Subscriber）和订阅者（Observable），而RxJava最好用的地方之一就是链式编码，把观察者和订阅之通过订阅事件，串在一起，让编码的人感觉很”爽”！就像这样下面的代码，是打印出”robot”。

        final String name = "robot";
        Observable.just(name).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.i("rxjava", s);
            }
        });

当然，还没开始学RxJava，并不容易看懂，现在就是见个面，看见对方长得如此漂亮，自然想深入了解啊！

简单用法

依赖引入，目前的最新版本：

 compile 'io.reactivex:rxjava:1.1.1'
 compile 'io.reactivex:rxandroid:1.1.0'

然后我们分步骤，先能上手，可以简单使用RxJava。前文说过，我们需要观察者，订阅者，然后通过一个订阅方法，把两者连起来，就是Rxjava最基本的使用。所有就按照这个步骤：

1、创建观察者（Subscriber）：

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i("rxjava", "completed");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("rxjava", "error");
            }

            @Override
            public void onNext(String s) {
                Log.i("rxjava", s);
            }
        };

看上面的代码，要求复写三个方法，其中”onNext”方法就是观察者要执行的事件，类似OnClickListener里面的OnClick方法。”onError”为事件队列异常执行的方法，”onCompleted”为事件队列完成实行的方法。

2、创建订阅者（Observable）：

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("robot");
                subscriber.onNext("rose");
                subscriber.onCompleted();
            }
        });

上面的代码意思是会调用观察者subscriber的onNext方法两次，和onCompleted方法。

3、执行订阅：

observable.subscribe(subscriber);

通过subscribe()方法把观察者和订阅者链接，那么上述的事件就会执行了。

链式调用

那么把上面的代码写在一起，就是我开头举得例子了，就是链式调用。

Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("robot");
                subscriber.onNext("rose");
                subscriber.onCompleted();
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i("rxjava", "completed");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("rxjava", "error");
            }

            @Override
            public void onNext(String s) {
                Log.i("rxjava", s);
            }
        });

简单的写法

上面的订阅者（Observable）在创建过程中使用了create()方法，当然这是最基本的创建方法，不过还有更简单的办法来完成Observable对象的创建：

 Observable observable = Observable.just("robot","rose");

使用just()方法和上面能达到一样的效果，它将传入的参数依次发送出去。还可以这么写：

String[] names = {"robot", "rose"};
Observable observable = Observable.from(names);

使用from()方法将传入的数组或 Iterable 拆分成具体对象后，依次发送出去。
完整代码：
just

Observable.just("robot","rose").subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i("rxjava", "completed");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("rxjava", "error");
            }

            @Override
            public void onNext(String s) {
                Log.i("rxjava", s);
            }
        });

from

String[] names = {"robot", "rose"};
Observable.from(names).subscribe(new Subscriber<String>() {
   @Override
   public void onCompleted() {
       Log.i("rxjava", "completed");
   }

   @Override
   public void onError(Throwable e) {
       Log.e("rxjava", "error");
   }

   @Override
   public void onNext(String s) {
       Log.i("rxjava", s);
   }
});

写到这里，我们看到这个RxJava很简单嘛，嘿嘿，其实难的还在后面呢，RxJava的真正用处在于异步操作的方便，所以后续我会继续写RxJava的异步操作，以及更强大的变换功能。