RxJava（新手推荐一）

作者: 伞U | 来源:发表于2016-11-27 17:52 被阅读53次

RxJava（新手推荐一）
RxJava（新手推荐二）
RxJava 系列（一）RxJava 1.0 简介
RxJava Tips
RxJava系列推荐
RxJava2使用
Android Rxjava ：最简单&全面背压讲解 (
RxJava2学习笔记
RxJava 初探
带实际例子的Android架构MVP简述「Kotlin，MVP，

title: RxJava（新手推荐一）

date: 2016-11-27 13:03:46

tags:

好久没更新了，这段时间一直在翻译一篇google官方关于Bitmap的文档，浪费了点时间。所以今天周末来公司给大家更新一篇关于RxJava的文章，希望对刚刚开始了解这块的朋友有点帮助。
关于RxJava的文章太多了，刚开始看的时候真的是各种不理解，这到底有啥用啊。RxJava？函数响应式编程？各种疑问？别急，让我以一个小弱鸡的视角给你讲解。
首先说到RxJava，就不得不说一种设计模式，观察者模式。关于观察者模式，如果你还不是很懂，那么我的这篇文章你说不定会喜欢-->观察者模式。

好了，现在假设你懂了。

RxJava中主要包含两部分（Observer和Observable）。

Observer：观察者，通常我们使用比较多的是（Subscribe，可以看成就是Observer）。
Observable：被观察者（也可以看做Subject）。
记得当时就因为employer（雇主），employee（职工）纠结了好久。不要在意这个，不要让一个本来很简单的问题被英文绕的晦涩难懂。

当Observable（Subject）的内容发生变化时，通知Observer执行相应的动作。

原理很简单，我们先来看看怎么用吧。

一.如何引入RxJava

RxJava

Gradle引入方式如下（x,y,z为相应的版本）:

compile 'io.reactivex:rxjava:x.y.z'

Maven引入:

<dependency>
    <groupId>io.reactivex</groupId>
    <artifactId>rxjava</artifactId>
    <version>x.y.z</version>
</dependency>

在例子中，我用的开发环境是Android Studio，所以我选择第一种方式，我引入的是（io.reactivex:rxjava:1.0.14）。

二.基本使用

1.创建Observable（被观察者）

 Observable<String> observable = Observable.create(
new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {

            subscriber.onNext("Hello world");
        }
    });

2.创建Subscribe（观察者）

Subscriber<String> subscriber = new Subscriber<String>() {
        @Override
        public void onCompleted() {
         
        }

        @Override
        public void onError(Throwable e) {

        }

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

3.完成订阅动作

 observable.subscribe(subscriber);（不要纠结为什么是observable订阅subscriber，按字面意思应该是subscriber订阅observable才对）。

好了，一个最基本的RxJava的使用过程写完了。

让我们看看运行结果：

结果

仔细看上面的代码，我们的目的是在被观察者中传出一个字符串，然后在订阅者subscriber中将该字符串打印出来。

那我们的代码有没有什么问题？

我们的需求是在订阅者中打印出该字符串而已，也就是我们只需要响应onNext就可以，但是按照现在这种写法，我们需要重写onNext，onCompleted以及onError，有点麻烦。可不可以只需要写一个方法？

当然可以。于是就有了下面这种写法。

 Action1<String> onNextAction = new Action1<String>() {
        @Override
        public void call(String s) {

            System.out.println(s);
        }
    };

随后，实现订阅动作。

 observable.subscribe(onNextAction);

有疑问吗？

这个Action1又是什么鬼？和Subscriber又是什么关系？别急，待我慢慢道来。看图。

Action1

由图可以看出，Subscriber中的每一步可以分别对应一个Action1。我们只需要实现我们想要的动作，然后订阅就可以。

如果我们想实现onNext，onError以及onCompleted。我们可以创建三个Action1对象，然后在完成订阅动作即可。

observable.subscribe(onNextAction,onErrAction,onCompleteAction)。

订阅者是简化了，但是我们的被观察者Observable有没有简单的写法呢？

当然有，我们可以雨露均沾的。

Observable<String> observable = Observable.just("Hello world");
Action1<String> onNextAction = new Action1<String>() {
        @Override
        public void call(String s) {

            System.out.println(s);
        }
    };
observable.subscribe(onNextAction);

那么，两种创建Observable的方式有什么区别吗？（先知道我们被观察者Obervable已知的有两种创建方式，区别我会在以后的文章中写。一篇写的话太长了，RxJava分为3，4部分写完）。

现在与以前相比，写法上简单太多，那么有没有更简单的写法呢？

Observable.just("Hello world").subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            System.out.println(s);
        }
    });

这一步与以上相比，省去了好多临时变量的创建，比如observable，显得结构更为简洁。那么有没有更为简单的写法呢？毕竟知足很难。是时候Lambda表达式登场了，如果你还不会这个表达式的写法，那么完全可以跳过。这部分只是为了表现出函数响应式编程的魅力。

  Observable.just("Hello world").subscribe(
           s -> System.out.println(s));

如果需求要变，我们在Subscriber中要对传出的数据进行更改，那么怎么做呢？

你可能会说，这还不简单。我眯着眼睛一看就知道有两种。

（1）

Observable.just("Hello world str").subscribe(
           s -> System.out.println(s));

（2）

Observable.just("Hello world").subscribe(
           s -> System.out.println(s + "str"));

观察实现（1）与实现（2）。

我们Observable将数据传出时并不知道要做什么自定义的东西，所以方案（1）并不好。那么方式（2）呢？
我们在订阅者（Subscriber）中对实现进行了更改，这是不合理的，因为Subscriber是被动响应的，为了结构上的简单，我们并不希望在订阅者（Subscriber）中做太多东西。要是能在Observable和Subscriber中间做一些处理就好了。可以吗？来看下RxJava中的Operators。

Operators使用

 Observable.just("Hello world").map(new Func1<String, Object>() {
        @Override
        public Object call(String s) {
            return s+"str";
        }
    }).subscribe(s -> System.out.println(s));

对Func1使用Lambda的写法如下：

Observable.just("Hello world")
            .map(s -> s+"str")
                .subscribe(s -> System.out.println(s));

可以看出我们在将事件传出（just）与订阅（subscribe）中间进行了一些处理。

哎呦

处理又能怎么样？与之前的两种方式也没啥区别啊。这么想就是你的不对了，如果我们在中间的处理过程很多，类似于中间商层层剥皮呢？按照以前的写法是不是就比较混乱，在一个里面处理了太多事情。现在RxJava有了Operators，我们就可以这么干。

    Observable.just("Hello world")
                .map(s -> s+"str")
                .map(s -> s + "i")
                .map(s -> s + "love")
                .map(s -> s + "you")
                .subscribe(s -> System.out.println(s));

心动吗？当我看到还可以这么用的时候，就差起立了。真幸福。我在中间想处理多少步就处理多少步。

RxJava的入门基本上完了，那么学这些到底有什么用？来开始画饼。

到底我们实际项目中，或者具体Android开发情境中到底该怎么用？
Observable与Subscriber的使用可以让好多情况下的条理变得更加清晰直观，比如Observable获取网络数据，在Subscriber中我们可以将数据显示在UI上。原先我们用Thread+handler所做的一切，现在都可以用RxJava结合其他一些开源组件，比如retrofit。