原文地址：https://github.com/ReactiveX/RxJava/wiki/How-To-Use-RxJava
项目中用到的代码地址：http://git.oschina.net/brendanv/learnrxjava

先来个Hello World

为什么第一行代码都喜欢用Hello World？因为这个表示你的程序有了生命。

maven配置

        <dependency>
            <groupId>io.reactivex.rxjava2</groupId>
            <artifactId>rxjava</artifactId>
            <version>2.1.1</version>
        </dependency>

Hello World

代码在first module的first包。

public class HelloWorld {
    public static void hello(String... names) {
        /**
         * Flowable是2.x版本新增的
         */
        Flowable.fromArray(names).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println(s);
            }
        });
        /**
         * Observable是旧版本的
         */
        Observable.fromArray(names).blockingSubscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println(s);
            }
        });
    }

    public static void main(String[] args) {
        hello("Hello World!");
    }
}

官方文档里面使用的是RxJava1，所以有区别。所以rxjava1可以使用

如何使用RxJava

使用RxJava需要创建一些Observable（用来发射数据），以各种方式转换这些Observable获取需要的数据项，再订阅这些数据项。

创建Observable

要创建一个Observable，您可以通过将一个函数传递给具有Observable行为的create（）来手动实现Observable的行为，也可以通过使用为此目的设计的一些Observable操作符将现有数据结构转换为Observable 。

使用现有的数据创建Observable

我们的hello world程序就是使用已有的数据来创建Observable的。所以可以使用fromArray()(* 1.x版本为from*)或者just()方法类转换对象，列表，数组为发射这些对象的Observable对象：

Observable<String> stringObservable = Observable.fromArray("a", "b", "c");
Observable<String> oneJust = Observable.just("one Object");
Observable<String> twoJust = Observable.just("one Object", "two Object");

这些转换后的Observable会同步调用任何订阅者的onNext()方法，然后发送这些Observable的每个数据，最后调用订阅者的onCompleted()方法。

使用create()方法创建Observable

你可以使用create创建自定义的Observable来实现异步I/O，计算操作甚至无限的数据流。

同步的Observable示例

public class SyncObservable {
    public static Observable customObservableBlocking() {
        return Observable.create(aSubcriber -> {
            for (int i = 0; i < 50; i++) {
                if (!aSubcriber.isDisposed()) {
                    aSubcriber.onNext("value:" + i);
                }
            }
            if (!aSubcriber.isDisposed()) {
                aSubcriber.onComplete();
            }
        });
    }

    public static void main(String[] args) {
        customObservableBlocking().subscribe(System.out::println);
    }
}

异步的Observable示例

package second;


import io.reactivex.Observable;
import io.reactivex.schedulers.Schedulers;

/**
 * @author
 * @since 2017/7/6 下午8:03
 * Purpose
 */
public class AsyncObservable {

    public static Observable asyncObservable() {
        return Observable.create(aSubscriber->{
            new Runnable(){

                @Override
                public void run() {
                    for(int i=0;i<5;i++) {
                        aSubscriber.onNext("value:"+i);
                    }
                    System.out.println("runnable"+Thread.currentThread());
                }
            }.run();
            System.out.println("observable:"+Thread.currentThread());
            aSubscriber.onComplete();
        });
    }

    public static Observable asyncNonblockingObservabel() {
        return Observable.create(aSubscribe -> {
            for(int i=0;i<5;i++) {
                aSubscribe.onNext("NonBlockingValue:" + i);
            }
        });
    }
    public static void main(String[] args) {
        asyncObservable().subscribeOn(Schedulers.io()).subscribe(System.out::println);
        asyncNonblockingObservabel().subscribeOn(Schedulers.io()).subscribe(System.out::println);
        //main方法容易在线程还没有切换的时候结束，然后就看不到结果了。这个地方卡了我好久啊
        try {
            Thread.sleep(1000*2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

会发现输出的结果是异步的：

NonBlockingValue:0
NonBlockingValue:1
value:0
value:1
value:2
value:3
value:4
NonBlockingValue:2
runnableThread[RxCachedThreadScheduler-1,5,main]
NonBlockingValue:3
NonBlockingValue:4
observable:Thread[RxCachedThreadScheduler-1,5,main]
Process finished with exit code 0

上面介绍的例子为了简介都没有做错误处理，后面的例子会有错误处理。更多信息可以看Obserbable 和创建Observable页面。

使用操作符转换Observable

RxJava允许链式聚合操作转换和组合Observable。
下面的代码表示忽略前两个，从剩余的里面取两个：

public static void simpleComposition() {
        asyncNonblockingObservabel().skip(2).take(2)
                .map(stringValue -> {
                    return stringValue + "_xform";
                })
                .subscribe(it -> {
                    System.out.println("onNext=>" + it);
                });
    }

下面的交互图是官网的，他发射的是17个值，我懒得画图直接复制了。原理一样。

image.png