Android响应式编程框架---RxJava&RxAndroid2.0使用笔记

RxJava

官方GitHub地址：https://github.com/ReactiveX/RxJava

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.
译：RxJava是Reactive Extensions的Java VM实现：用于通过使用observable序列来组合异步和基于事件的程序的库。

与RxJava1.x对比

RxJava 2.0 已经按照Reactive-Streams specification规范完全的重写了。2.0 已经独立于RxJava 1.x而存在。
因为Reactive-Streams有一个不同的构架，它改变了一些以往RxJava的用法。这份文档尝试去总结所发生的变化，并描述如何把1.x的代码改写成符合2.x规则的代码。

RxJava2.0与RxJava1.0的区别，请看：http://blog.csdn.net/qq_35064774/article/details/53045298

RxJava的四个组成部分：

观察者（observer），被观察者（Observable），订阅（subscribe），响应事件。

RxJava的强大的核心：

1. 异步：两个比较核心的方法subscribeOn和observeOn这两个方法都传入一个Scheduler对象，subscribeOn指定发射事件的线程，observeOn指定消费事件的线程。
2. 操作符：提供了一系列的转换操作符，如map(),flatMap(),filter(),merge(),concat(),lift(),compose()等操作符可以将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。
3. 链式调用：链式调用最大的好处就是逻辑清晰，代码简洁。在应对较复杂的逻辑的时候，也能展现出清晰的思路！正如文章中戏称：迷之缩进！

添加依赖

dependencies {
    ...
    compile 'io.reactivex.rxjava2:rxjava:2.1.3'
    ...
}

Data类

下面代码中使用的Data数据类。

public class Data {
    private int id;
    private String name;

    public Data(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

1.最基本的使用

      //创建观察者或者订阅者
        Observer observer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                //Disposable是1.x的Subscription改名的，因为Reactive-Streams规范用这个名称，为了避免重复
                //这个回调方法是在2.0之后新添加的
                //可以使用d.dispose()方法来取消订阅
            }

            @Override
            public void onNext(String value) {
                Log.d("onNext", value);
            }

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

            @Override
            public void onComplete() {
                Log.d("onComplete", "complete");
            }
        };

        //创建被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext("Hello World!");
            }
        });

        observable.subscribe(observer);

由于1.x中Observable不能合理的背压，导致了无法意料的 MissingBackpressureException，所以在2.x中，添加了Flowable来支持背压，而把Observable设计成非背压的。

还有一点需要注意的就是，在上边注释中也有，onSubscribe(Disposable d)这个回调方法是在2.x中添加的，Dispose参数是由1.x中的Subscription改名的，为了避免名称冲突！

2.RxJava2.x中的基本用法

所以在2.x中，最好这么写：

 Subscriber subscriber = new Subscriber() {
            @Override
            public void onSubscribe(Subscription s) {
                Log.d(TAG, "onSubscribe: ");
                s.request(1);
            }

            @Override
            public void onNext(Data data) {
                Log.d(TAG, "onNext: first:" + data.getId() + data.getName());
            }

            @Override
            public void onError(Throwable t) {
                Log.d(TAG, "onError: " + t.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        };
       Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(FlowableEmitter e) throws Exception {
                Data data = new Data(1, "+Java");
                Data data1 = new Data(2, "+Android");
                e.onNext(data);
                e.onNext(data1);
                e.onComplete();
            }
        }, BackpressureStrategy.BUFFER).subscribe(subscriber);

3.Consumer消费者

如果我们只关注onNext()方法的内容，而忽略其他方法，可以使用Consumer代替Subscriber：

 Data data = new Data(1, "+Java");
        Data data1 = new Data(2, "+Android");
        List list = new ArrayList<>();
        list.add(data);
        list.add(data1);
        Flowable> flowable = Flowable.just(list);

        Consumer consunmer = new Consumer>() {

            @Override
            public void accept(List datas) throws Exception {
                for (Data data : datas) {
                    Log.d(TAG, "onNext: second:" + data.getId() + data.getName());
                }
            }
        };

        flowable.subscribe(consunmer);

4.更简洁的写法

用just发射指定内容，可以是字符串，数组等各种对象类型。

Flowable.just("Hello,I am China!")
    //替代1.x中的action1,接收一个参数，如果是两个参数action2使用BiCustomer，而且删除了action3-9
    //多个参数用Custom
    .subscribe(new Consumer() {
        @Override
        public void accept(String s) throws Exception {
            Log.e("consumer", s);
        }
    });

1.map：转换操作

如果我们想修改Data数据中id为2时的name，如下：

        Data data = new Data(1, "+Java");
        Data data1 = new Data(2, "+Android");
        List list = new ArrayList<>();
        list.add(data);
        list.add(data1);
        Flowable.just(list).map(new Function, List>() {
            @Override
            public List apply(List datas) throws Exception {
                for (Data data : datas) {
                    if (data.getId() == 2) {
                        data.setName(data.getName() + "---DeMon");
                    }
                }
                return datas;
            }
        }).subscribe(new Consumer>() {
            @Override
            public void accept(List datas) throws Exception {
                for (Data data : datas) {
                    Log.d(TAG, "onNext: three:" + data.getId() + data.getName());
                }
            }
        });

2.flatMap：批量转换

如果我们需要批量修改（一般来说是容器的数据）数据，需要使用fromIterable()发射数据，flatMap()进行批量修改：

        Data data = new Data(1, "+Java");
        Data data1 = new Data(2, "+Android");
        List list = new ArrayList<>();
        list.add(data);
        list.add(data1);
        Flowable.fromIterable(list).flatMap(new Function>() {
            @Override
            public Publisher apply(Data data) throws Exception {
                data.setName(data.getName() + "---DeMon");
                return Flowable.fromArray(data);
            }
        }).subscribe(new Consumer