初识RxJava(入门篇)

本文只是一些学习笔记，若有和某些大神的雷同，可能学习大神的文章了，
第一次听说RXJava是在一次和耀哥（组长）和明哥（大神）吃饭的时候，那时候还没有很多概念。跟大

神交流是一件痛苦与快乐的过程，痛苦是他们说的很多高级技术自己望尘莫及，搭不上话，只能老是当

听众；但同时是学习的过程，不过要记得一下关键词，然后自己回去多多的去了解，这样才会慢慢的进

步。
网上很多人对RX的使用褒贬不一，有人说：RxJava 真是太好用了，有人说：RxJava 真是太难

用了。其实每种技术乃至一些google出来的都是这样，说好用的只是说自己理解了，习惯了，说不好用

的也不是说自己技术不行，只是自己有自己的一套理解，然后觉得不适合自己，所以没有继续往深的地

方去！上面一些只是自己的感言，言归正传：
Rxjava在github的地址：
https://github.com/ReactiveX/RxJava
https://github.com/ReactiveX/RxAndroid
如果你使用studio的话，直接在gradle引入依赖

compile 'io.reactivex:rxandroid:1.1.0'

另有java版

compile 'io.reactivex:rxjava:1.0.14' 

**

一、RxJava是什么？

**
“a library for composing asynchronous and event-based programs using observable

sequences for the Java VM”这个是在github主页上的一句话，（一个在 Java VM 上使用可观测的序列

来组成异步的、基于事件的程序的库）。其实归根结底，就是一个词，异步。
异步？那有什么用，现在android有Handler和AsyncTask，还有很多的第三方库的异步包，那

Rxjava好在哪里？下面举一个访问服务器，服务器返回图片url在主ui显示的例子：
普通的Thread+Handler

TestModel result;
Bitmap bitmap ;
 new Thread(new Runnable() {
            @Override
            public void run() {
                //访问网络
                //得到数据，listResult 赋值
                result= getResultFromNet();
                //下载图片
                bitmap = getBitmapForUrl(result.getUrl);
                //发送到主UI更新ui消息
                handler.sendEmptyMessage(0);
            }
        }).start();
    Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            //显示数据
                imageView.setImageBitmap(bitmap);
            }
            super.handleMessage(msg);
        }
    };

AsyncTask其实就是上面代码的封装，这里不是重点，所以就不写了，在来看一下Rxjava是怎么写的

Observable.create(new Observable.OnSubscribe<TestModel>() {
            @Override
            public void call(Subscriber<? super TestModel> subscriber) {
                result= getResultFromNet();
                //下载图片
//
            }
        }).map(new Func1<TestModel, Bitmap>() {
            @Override
            public Bitmap call(TestModel testModel) {
                Bitmap bitmap = getBitmapForUrl(result.getUrl);
                return bitmap;
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Action1<Bitmap>() {
            @Override
            public void call(Bitmap bitmap) {
                imageView.setImageBitmap(bitmap);
            }
        });

噢，myGod,怎么会那么复杂，那我干嘛用它呢？那RxJava到底好在哪里？大家其实也别惊讶，

RxJava好处是逻辑的简洁，而不是说代码量少。你认真看一下，RxJava的显示，是一个从上到下的链式

调用，阅读起来非常的nice。就算你过了几个月回来再看这些代码，也是瞬间条理就清晰，而不用自己

在去捋一遍。 下面我给大家介绍一下和RxJava的原理。

二、RxJava 的观察者模式

**1、概念**
扩展的观察者模式，RxJava的异步实现，是通过一种扩展的观察者模式来实现的，观察者模式

我就不多说了，有兴趣的朋友可以去关注鸿洋大神的文章
Java设计模式
RxJava 有四个基本概念：
Observable(被观察者)、observer(观察者)、subscribe(订阅)、事件。Observable和observer

通过subcribe()方法实现订阅关系，从而Observable可以在异步任务完成之后发出事件来用纸Observer

。
RxJava的时间回调方法默认有三个，
onNext()：处理事件触发
onCompleted(): 事件队列的完结触发
onError(): 事件队列异常时触发
下面我下大家展示RxJava的基本实现
1）创建Observer或者Subscriber，Subscriber是实现Observer的抽象类，同时对Observer接口

做了一下扩展，但是它们的基本使用方式是一样的。实质上，在RxJava的subscribe的过程中，

Observerble也是会转换成一个Subscriber在使用。Subscriber主要是扩展了两个方法onStart()、

unSubscribe();因为不常用所以这里不做解释，大家可以尝试一下打印log，清楚一下流程。

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(Tag,"onCompleted");
            }

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

            @Override
            public void onNext(String s) {
                Log.i(Tag,"item");
            }
        };

2）创建Observable（被观察者）

 Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hahha1");
                subscriber.onNext("hahha2");
                subscriber.onNext("hahha3");
                subscriber.onCompleted();
            }

        });

3）订阅

observable.subscribe(subscriber);

以上就是一次完成的RxJava的基本实现，RxJava其实还支持不完整定义的回调，不用一定是Subscriber

，RxJava会自动根据定义创建出Subscriber 。如：

//有返回值,单个多个action
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(Tag,"item");
            }
        };
        //有返回值Action1，多个action
        Action1<Throwable> onErrorAction = new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.i(Tag,"onError");
            }
        };
        //无返回值Action0，多个action
        Action0 onCompletedAction = new Action0() {
            @Override
            public void call() {
                Log.i(Tag,"onCompleted");
            }
        };
        //请忽略顺序和名字，我只是跟着系统的，你可以自己起名字和返回值···
        observable.subscribe(onNextAction);
        observable.subscribe(onNextAction,onErrorAction);
        observable.subscribe(onNextAction,onErrorAction,onCompletedAction);

在来一个串起来的

 Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hahha1");
                subscriber.onNext("hahha2");
                subscriber.onNext("hahha3");
                subscriber.onCompleted();
            }

        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(Tag,"onCompleted");
            }

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

            @Override
            public void onNext(String s) {
                Log.i(Tag,"item");
            }
        });

上面的两个例子，其实都算是一次完整的RxJava的基本实现，但是上面出现的subscribeOn、

observeOn、map、Func1、这些api是什么呢？大家可以先去了解一下，因为以下的才是RxJava的重点，

Scheduler 和转换，既然是入门篇，篇幅就稍微少点啦，今天写了很久了，明天再继续。有什么不懂的

，欢迎留言！
再次重申，这只是学习笔记，可能是我看过很多大神博客然后有自己的理解。