美文网首页
RxJava(新手推荐一)

RxJava(新手推荐一)

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

    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。

    参考文档:

    RxJava入门

    相关文章

      网友评论

          本文标题:RxJava(新手推荐一)

          本文链接:https://www.haomeiwen.com/subject/qyjnpttx.html