rxjava1.x学习

1、介绍

a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在Java VM上使用可观测的序列来组成异步的、基于事件的程序的库），说白了就是异步。

2、基本概念

Observable：被观察者

Observer：观察者

Subscribe:订阅（动词）

Observer和Obserable通过sunscribe()实现订阅关系，而和普通的观察者模式不一样的是：Rxjava除了普通的事件onNext()方法之外，还定义了新的事件方法Oncomplete()以及OnError().

Oncomplete()：事件队列完结，Rxjava不仅每个事件单独处理，还把他们当作队列，当不会有新的OnNext()发生的时候，就会触发Oncompleted()方法。就是队列完成的时候会有消息通知出来。

OnError()：事件队列异常，Rxjava在处理事件队列异常的时候会触发OnError()方法，同时队列自动终止，不会发出任何通知，所以OnCompleted()和OnError()方法是对立的，不会同时触发出来 。

rxjava流程图：

3、

先明确一个东西，有的文章定义如下：

RxJava最核心的两个东西是Observables（被观察者，事件源）和Subscribers（观察者）。Observables发出一系列事件，Subscribers处理这些事件。这里的事件可以是任何你感兴趣的东西 （触摸事件，web接口调用返回的数据......）

在第二节中说到Rxjava中三个概念：观察者，被观察者，订阅。但上面只提供了两个概念。是因为Subscribers是一个抽象类，实现了观察者接口，所以看到这个也不必认为是写错了。其使用方式基本是一样的，不同点：

onStart()：方法是Subscribers新添加的，也就是说在事件触发前做的准备工作放在这里做。 例如数据的清零或重置。但是如果准备工作是对线程有要求，则这个也无法满足，onStart()和后面的触发方法在一个线程中。如果一定要在线程中做准备工作，可以使用onDoSubscrible()方法，后面会有。

unsubscribe(): 是Subscribers实现另一个接口是实现的方法，用于取消订阅，调用之后，Subscribers将不会在接受事件响应。类似于广播注册，以及取消注册，一定要成对出现，可能会内存泄漏。

4、

（1）

分三步：

1）定义一个被观察者Observable

2）定义一个观察者Subscriber

3）建立订阅关系myObservable.subscribe(mySubscriber)；

   private void observable01() {
        //先定义一个被观察者(事件源)，当被订阅的时候发出字符串
        Observable<String> myObservable = Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello World!");
                subscriber.onCompleted();
            }
        });
        //接下来定义一个观察者，观察者接受一个字符串并打印
        Subscriber<String> mySubscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }
            
            @Override
            public void onNext(String s) {
                Log.d(TAG, "s====>" + s);
            }
        };

        subscription = myObservable.subscribe(mySubscriber);

    }

结果：

07-04 14:38:24.472 29664-29664/com.example.rxjavahellodemo D/MainActivity: s====>Hello World!

（2）

这段代码肯定是很复杂的，并且仅仅是为了展示字符串，接下来，看看rxjava提供的方便调用的API：

Observable.just就是用来创建只发出一个事件就结束的Observable对象。

所以定义一个观察者，可以写成：Observable<String> myObservable = Observable.just("hello 2017");

观察者的简化：对于Subscribler，我们并不关心onComplete,以及onError，所以也提供了响应的实现类。

    private void observable02() {
        Observable<String> myObservable = Observable.just("hello 2017");

        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, "s====>" + s);
            }
        };

        subscription = myObservable.subscribe(onNextAction);
    }

或者可以直接简写为：

  Observable.just("hello 2017").subscribe(new Action1<String>() {

            @Override
            public void call(String s) {
                Log.d(TAG, "s====>" + s);
            }
        });

打印结果：

07-04 14:47:55.290 8477-8477/com.example.rxjavahellodemo D/MainActivity: s====>hello 2017

（3）map

 private void observableMap() {
        Observable<String> myObservable = Observable.just("hello");

        Func1<String, String> func1 = new Func1<String, String>() {

            @Override
            public String call(String s) {
                return s + " 2017";
            }
        };

        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, "s====>" + s);
            }
        };

        subscription = myObservable.map(func1).subscribe(onNextAction);
    }

或者可写为：

Observable.just("hello").map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                return s + " 2017";
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, "s====>" + s);
            }
        });

打印结果：

07-04 15:12:41.796 20538-20538/com.example.rxjavahellodemo D/MainActivity: s====>hello 2017

总结：

Observable和Subscriber可以做任何事情，

1）Observable可以是查询一个数据库，Subscribler用来显示结果；

2）Observable可以是点击事件，Subscribler用来响应点击事件；

3）Observable也可以是网络请求，Subscribler用来显示请求结果。

但是注意的是，线程的问题，后面会详细讲解。

先看Map:把一个事件转化为另外一个事件，Map操作符就是用来转化Observable对象的，Map返回一个Observable对象，这样就可以实现链式调用。也可以对一个Observable对象多次进行Map从而得到Subscrible最终需要的数据用于显示。比如前面的例子。

再来一个例子，将String字符转为Integer

   //这里就是把字符串转化为基本类型输出的
    private void mapStr2Int() {
        Observable.just("b").map(new Func1<String, Integer>() {
            @Override
            public Integer call(String s) {
                return s.hashCode();
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG, "integer===>" + integer);
            }
        });
    }

打印结果：

07-04 15:29:36.845 7089-7089/com.example.rxjavahellodemo D/MainActivity: integer===>98

（4）from

From是从集合中获取，然后一个个输出

//From是从集合中获取，然后一个个输出
    private void observableFrom() {
        List<String> list = Arrays.asList("java", "android", "swift", "ios");
        Observable<String> strObservable = Observable.from(list);
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, "s----->" + s);
            }
        };

        subscription = strObservable.subscribe(onNextAction);
    }

打印结果：

07-04 15:19:01.557 27394-27394/com.example.rxjavahellodemo D/MainActivity: s----->java
07-04 15:19:01.557 27394-27394/com.example.rxjavahellodemo D/MainActivity: s----->android
07-04 15:19:01.557 27394-27394/com.example.rxjavahellodemo D/MainActivity: s----->swift
07-04 15:19:01.557 27394-27394/com.example.rxjavahellodemo D/MainActivity: s----->ios

源码下载：http://download.csdn.net/detail/yihuangol/9888983