RxJava第一篇，RxJava入门

RxJava：

• 是一个异步数据处理

• 扩展的观察者模式

• 轻量级框架 <1M jar

• 支持java 8 lambda

• 支持java 6 和 Android 2.3+

• 支持异步和同步

RxJava响应式编程

• 面向对象编程：
  第一步：构建一个冰箱，具有开门，关门的方法
  第二步：构建一个大象，具有走进冰箱的方法
  第三步：实例化一个冰箱对象，实例化一个大象对象，冰箱对象调用开门方法，大象对象调用走进冰箱方法，冰箱对象调用关门方法，大象被成功装入冰箱。

• 响应式编程：
  第一步：构建一个发射源，发送大象
  第二步：构建一个响应器，接受到大象后关进冰箱。
  第三步：用这个响应器监听发射源。

• 函数式编程：
  第一步：构建一个函数，接收大象和冰箱两个参数
  第二步：在此函数内部做实现，返回冰箱已经装入大象
  第三步：调用此函数，将大象和冰箱作为参数传入

Schedulers(调度器)

• 解决Android主线程问题

• 解决多线程线程问题

RxJava与观察者模式

• 观察者模式四大要素：
  Observable 被观察者
  Observer   观察者
  subscribe  订阅
  event      事件

• 扩展的观察者模式：
  onCompleted()回调
  onError()回调
  组合而不是嵌套，避免陷入回调地狱
  被观察者（observable）-onNext()-onCompleted()-onError()->观察者（Observer）
  比传统观察者模式多了onCompleted()和onError()回调

栗子

 //第一步 创建被观察者
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {            @Override public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("Hello RxJava");
                e.onComplete();
            }
        });        //创建观察者
        Observer<String> observer = new Observer<String>() {            @Override public void onSubscribe(Disposable d) {

            }            @Override public void onNext(String s) {
                System.out.println(s);
            }            @Override public void onError(Throwable e) {

            }            @Override public void onComplete() {
                System.out.println("接收完成");
            }
        };        //订阅事件
        observable.subscribe(observer);

一旦Observer与Observable建立了订阅关系，Observer与Observable便成为了一个整体，Observer便可对Observable中的行为作出响应。

Emitter/Observer

通过Observable.create创建可观察对象时，我们可以发现具体执行发射动作的是接口ObservableEmitter的实例化对象，而ObservableEmitter<T> 继承自 接口Emitter<T>，查看源码接口Emitter的具体代码如下：

public interface Emitter<T> {        //用来发送数据，可多次调用，每调用一次发送一条数据
     void onNext(@NonNull T value);        //用来发送异常通知，只发送一次，若多次调用只发送第一条
        void onError(@NonNull Throwable error);        //用来发送完成通知，只发送一次，若多次调用只发送第一条
        void onComplete();
}

onNext：用来发送数据，可多次调用，每调用一次发送一条数据
onError：用来发送异常通知，只发送一次，若多次调用只发送第一条
onComplete：用来发送完成通知，只发送一次，若多次调用只发送第一条

步骤简化

 //步骤简化
        Observable.create(new ObservableOnSubscribe<String>() {            @Override public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("Hello Rxjava");
                e.onComplete();
            }
        }).subscribe(new Observer<String>() {            @Override public void onSubscribe(Disposable d) {
                
            }            @Override public void onNext(String s) {
                System.out.println(s);
            }            @Override public void onError(Throwable e) {

            }            @Override public void onComplete() {
                System.out.println("接收完成");
            }
        });

在响应式编程的基础上，加上函数式编程，真正的函数响应式编程可以将代码简化成以下形式：

//函数响应式编程Observable.just("Hello Rxjava")
                .subscribe(new Consumer<String>() {                    @Override public void accept(String s) throws Exception {
                        System.out.println(s);
                    }
                });

其中，just操作符是经过封装后，专门用来发射单条数据的，可以是一个数据，一条字符，一个对象，一整个数组，一整个集合。
Consumer可以看做是对观察者Observer功能单一化之后的产物——消费者，上例中的Consumer通过其函数accept只接收可观察对象发射的数据，不接收异常信息或完成信息。

发送序列化数据

    private static void rx5(final ArrayList<String> list) {
        Observable.create(new ObservableOnSubscribe<String>() {            @Override public void subscribe(ObservableEmitter<String> e) throws Exception {                try {                    for (String str:list){
                        e.onNext(str);
                    }
                } catch (Exception e1) {
                    e.onError(e1);
                }
                e.onComplete();

            }
        }).subscribe(new Observer<String>() {            @Override public void onSubscribe(Disposable d) {

            }            @Override public void onNext(String s) {
                System.out.println(s);
            }            @Override public void onComplete() {
                System.out.println("接收完成");
            }            @Override public void onError(Throwable e) {
                e.printStackTrace();
            }
        });

    }

通过fromIterable操作符对其进行简化

private static void rx6(ArrayList<String> list) {
        Observable.fromIterable(list)
                .subscribe(new Consumer<String>() {                    @Override public void accept(String s) throws Exception {
                        System.out.println(s);
                    }
                });
    }

Disposable

这个方法中有个Disposable类型的参数，
onSubscribe表示在订阅时，当观察者Observer订阅可观察对象Observable，建立订阅关系后，会触发这个方法，并且会生成一个Disposable对象，其实无论观察者Observer以何种方式订阅可观察对象Observable，都会生成一个Disposable，不管有没有onSubscribe(Disposable d)方法，如下：

    private static void rx7(ArrayList<String> list) {
        Disposable disposable1 = Observable.just("Hello World")
                .subscribe(new Consumer<String>() {                    @Override public void accept(String s) throws Exception {
                        System.out.println(s);
                    }
                });
        Disposable disposable2 = Observable.fromIterable(list)
                .subscribe(new Consumer<String>() {                    @Override public void accept(String s) throws Exception {
                        System.out.println(s);
                    }
                });
    }

Disposable是观察者Observer与可观察对象Observable建立订阅关系后生成的用来取消订阅关系和判断订阅关系是否存在的一个接口。
只有当观察者Observer与可观察对象Observable之间存在订阅关系时，Observer才能接收Observable发送的数据或信息。如果Observer在接收Observable的信息的过程中，取消了订阅关系，则Observer只能接收订阅关系取消之前Observable发送的数据，对于订阅关系取消之后Observable发送的数据，Observer将不会再接收。
运行下面的代码，当Observable接收到第5条数据时，取消订阅关系。

    private static void rx8() {
        Observable.create(new ObservableOnSubscribe<Integer>() {            @Override public void subscribe(ObservableEmitter<Integer> e) throws Exception {                for (int i = 0; i < 10; i++) {
                    System.out.println("发送"+i);
                    e.onNext(i);
                }
                e.onComplete();
            }
        }).subscribe(new Observer<Integer>() {            private Disposable disposable;            @Override public void onSubscribe(Disposable d) {
                disposable = d;
            }            @Override public void onNext(Integer integer) {
                System.out.println("接收"+integer);                if (integer>4) {disposable.dispose();}
            }            @Override public void onError(Throwable e) {
                e.printStackTrace();
            }            @Override public void onComplete() {
                System.out.println("数据接收完成");
            }
        });
    }

可以发现取消订阅关系之前，Observable发送一条数据，Observe接收一条，取消订阅关系之后，Observe将不再接收Observable发送的数据。

作者：Man不经心
链接：https://www.jianshu.com/p/74d76911a2ae