RxJava—Observable

RxJava—Observable创建

RxJava是现在很流行的一个响应式编程框架，基于的是观察者模式（框架内部还用到了代理模式、迭代器模式等设计模式），响应式编程最初诞生于.net，后来IOS和安卓都纷纷效仿，当然在安卓开发中，还需要结合RxAndroid，那么为什么RxJava会这么火，它又是用来干嘛的，接下来我会一一阐述。

响应式编程是基于异步流的编程模式，异步处理的数据流可以理解为河流，而响应式编程提供了方便河流观测、过滤、操作的方法。

RxJava最大的优势在于它的简洁性，特别是在做异步处理这块，它的优势将体现的淋漓尽致，而且它的优势并不会因为逻辑的复杂度而受影响，比起常用的AsyncTask和Handle有它明显的优势。而且使用RxJava在大部分时候我们都不需要去考虑并发处理、线程安全问题，因为框架内部就帮你省去了这些麻烦。

观察者模式：举个例子，我们熟知的点击事件监听，View相当于被观察者，OnClickListner相当于观察者，通过setOnClickListner完成订阅关系，观察者订阅后，一旦用户点击按钮，FrameWork层接收到屏驱的点击消息，立马会将消息发送给观察者OnClickListner，比起常规的开个线程轮循监听不管是实施性还是实用性都要优化很多。我们的RxJava中的被观察者就是ObServable和Subject（前者子类），观察者是Subscriber（后者实现类）和ObServer，通过subscibe完成订阅关系。为了方便理解，我特意在网上找了两张图，你们自己细细体会：

OnClickListener观察者模式图：

Observer观察者模式图：

---

先上demo的效果图Demo下载：

理论讲完了，我们正式开始RxJava的学习，因为内容比较多，我会分几个章节来讲，一步步吸收和消化，这一章我们要讲的就是被观察者的几种创建方式以及使用：

一、create

Observable observableInteger;//创建Observable对象
//配置回调接口，OnSubscribe继承自Action1
// 监听观察者订阅，从源码中可以看出，一旦调用了subscribe方法， 即会回调call()方法，其中的observer即订阅传进去观察者new Observer<Integer>()
observabelInteger = Observable.  
                        create(new OnSubscribe<Integer>() {
                    //call -> 回调方法
                    @Override//这里面observer就是订阅传进来的观察者
                    public void call(Subscriber<? super Integer> observer) {
                        for (int i = 1; i < 5; i++) {
                            //观察者发送数据
                            observer.onNext(i);
                        }
                        observer.onCompleted();
                    }
                });

创建Observable（被观察者）之后，我们的观察者实现订阅（注册）即可接收被观察者传过来的数据：

//观察者/订阅者注册（Subscriber是Observer和Subscription实现抽象类）
        Subscription subscription = observabelInteger.subscribe(new Observer<Integer>() {
            @Override
            public void onCompleted() {
                adapter.add("Observable completed");
            }
            @Override
            public void onError(Throwable e) {
                adapter.add("Oh,no! Something wrong happened！");
            }
            //观察者接收数据
            @Override
            public void onNext(Integer item) {
                info = observableName + "send Item is " + item;
                if (adapter != null) {
                    adapter.add(info);
                }
            }
        });
        //解除订阅关系
        subscription.unsubscribe();

创建Observable的方式很多，订阅方式都是一样的，接下来为了不重复，订阅代码我不会再贴。
为了方便理解，这一次我带大家来分析下源码的实现机制，后面大同小异就不讲了：
1.源码中的被观察者的create方法实现：

public static <T> Observable<T> create(OnSubscribe<T> f) {
        return new Observable<T>(RxJavaHooks.onCreate(f));
    }

2.通过RxJavaHooks.onCreate(f)方法创建onSubscribe（监听器）：

public static <T> Observable.OnSubscribe<T> onCreate(Observable.OnSubscribe<T> onSubscribe) {
        Func1<OnSubscribe, OnSubscribe> f = onObservableCreate;
        if (f != null) {
            return f.call(onSubscribe);
        }
        return onSubscribe;
    }

3.将onSubscribe传给Observable的成员变量onSubscribe：

protected Observable(OnSubscribe<T> f) {
        //这里的onSubscribe（监听器）有final修饰
        this.onSubscribe = f;
    }

4.注册观察者监听：

    observabelInteger.subscribe(new Observer<Integer>();
    //下面是Observable类注册观察者的源码
    public final Subscription subscribe(final Observer<? super T> observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber<? super T>)observer);
        }
        if (observer == null) {
            throw new NullPointerException("observer is null");
        }
        return subscribe(new ObserverSubscriber<T>(observer));
    }

5.subscribe(new ObserverSubscriber(observer))源码：

 public final Subscription subscribe(Subscriber<? super T> subscriber) {
        return Observable.subscribe(subscriber, this);
    }

6.Observable.subscribe(subscriber, this)源码关键代码：

//这里的onSubscribe即是第三步传给Observable的成员变量onSubscribe（监听器）
RxJavaHooks.onObservableStart(observable,observable.onSubscribe)
//subscriber即是第四步传进来的observer观察者，subscriber是observer的实现类。
.call(subscriber);

通过源码我们发现，观察者一旦订阅即会回调监听器call方法。

二、from

from创建有很多重载方法，这里只讲常用的一种，其他可自己查阅源码
List<Integer> array = new ArrayList<>();
        array.add(1);
        array.add(2);
        array.add(3);
        array.add(4);
        //框架内部调用create方法，一旦观察者注册，立即自动遍历array列表，发送消息序列
        observabelInteger = Observable.from(array);

三、just

        //这个方法看源码，实际将just的参数转成了数组，最多十个
        /** public static <T> Observable<T> just(T t1, T t2, T t3, T t4, T t5, T t6) 
        { return from((T[])new Object[] { t1, t2, t3, t4, t5, t6 });}
         **/
        observabelInteger = Observable.just(1, 2, 3, 4);
        //这个方法只回调观察者的onCompleted方法
//        observabelInteger = Observable.empty();
        //不发送任何数据，且一直存在的observable，不回调观察者的方法……不知道有啥用
//        observabelInteger = Observable.never();

四、repeat

    observableInteger = Observable.just(1, 2, 3, 4).repeat(2);//消息重发

五、defer

//当观察者订阅,会立马回调Func0中的call方法，创建Observable（懒加载）
                observabelInteger = Observable.defer(new Func0<Observable<Integer>>() {
                    @Override
                    public Observable<Integer> call() {
                        //这里可以用just、from、repeat等方法
                        return Observable.just(1,2,3,4);
                    }
                });

六、range

//第一个参数是起始值，第二个是发送的个数，相当于just(1,2,3,4)
observabelInteger = Observable.range(1, 4);

七、interval

//这个方法有轮循的作用，可以做定时器用，第一个参数是延迟多长时间开始，第二个参数是轮循的间隔时间，第三个参数是时间的单位
Observable<Long> longObservable = Observable.interval(1, 2, TimeUnit.SECONDS);

讲到这里Observable的创建就讲完了，当然可能暂时也看不出Rxjava的实用性，请耐心看完下面章节，保准你会收获满满。用得越深入，你会发现它的魅力越大，最后给大家推荐网络请求的组合框架：MVP（架构）+RxJava+Retrofit+RxBinding
下面几章将讲述Observable的子类Subject、RxJava的常用操作符（过滤、合并、转换三大类）、RxJava的线程调度器。会在这个月内抽时间写出来，项目赶啊！
当然还有不能错过的demo下载：RxJava_Demo