欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Rxjava学习笔记-01

程序员文章站 2024-02-28 21:49:04
...

Rxjava学习笔记-01

这篇文章主要用于学习交流Rxjava1

目录

AGENDA

  • What is RxJava
  • Dependencies RxJava
  • How Rxjava works
  • What Rxjava can do
  • A simple test

What is RxJava

-A library for composing asynchronous and event-based programs using observable sequences for the Java VM.
一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。‘异步’是这个库的最大特点。
推荐:
给 Android 开发者的 RxJava 详解

Dependencies RxJava

若使用Android studio
在app的build.gradle中dependencies代码块里添加依赖

  compile 'io.reactivex:rxjava:1.2.4'
  compile 'io.reactivex:rxandroid:1.2.1' //  

How Rxjava works

1.基础知识:观察者模式
观察者模式主要关注的点是,观察者十分在意被观察者的动作 ,当被观察者触发动作时,观察者会第一时间收到信息。
举个栗子
Rxjava学习笔记-01
我去群光广场负2层美食广场吃饭,在哪里点餐都会给我一个电子提醒器,点好餐我就可以不用管了,当店家做好了饭,就会呼叫我的电子提醒器,我就可以去取餐了。这个栗子里,我想当于观察者,商家相当于被观察者,而点餐相当于订阅
我(观察者)向店家(被观察者)订餐(订阅),当店家(被观察者)做出动作(做好饭),我(观察者)就会收到消息,就可以取餐了。但在RxJava中,实际没有取餐这一步。

   Observable.just("饭").subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                // do some action that going error
            }

            @Override
            public void onNext(String fan) {
                // do next action
                // 拿到 fan 了
            }
        });

现在说说RxJava的四个基本概念:
Observable (可观察者,即被观察者)、 Observer (观察者)、subscribe (订阅)、事件。Observer 通过 subscribe() 方法实现订阅Observable , Observable 就可以在需要的时候发出事件来通知 Observer。
2.实现方法
创建被观察者(Observable):

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("第一条数据");
                subscriber.onNext("第一条数据");
                subscriber.onCompleted();
            }
        });

这里创建了一个Observable.OnSubscribe对象,当observable被订阅时,就会调用Observable.OnSubscribe对象中的call方法,call用于发射原始数据,在这个栗子中,call执行了两次onNext(),一次onCompleted()
创建观察者(Observer):

Observer observer = new Observer<String>() {
            /**
             * Notifies the Observer that the {@link Observable} has finished sending push-based notifications.
             * <p>
             * The {@link Observable} will not call this method if it calls {@link #onError}.
             */
            @Override
            public void onCompleted() {

            }

            /**
             * Notifies the Observer that the {@link Observable} has experienced an error condition.
             * <p>
             * If the {@link Observable} calls this method, it will not thereafter call {@link #onNext} or
             * {@link #onCompleted}.
             *
             * @param e the exception encountered by the Observable
             */
            @Override
            public void onError(Throwable e) {

            }

            /**
             * Provides the Observer with a new item to observe.
             * <p>
             * The {@link Observable} may call this method 0 or more times.
             * <p>
             * The {@code Observable} will not call this method again after it calls either {@link #onCompleted} or
             * {@link #onError}.
             *
             * @param s the item emitted by the Observable
             */
            @Override
            public void onNext(String s) {

            }
        };

在这里,被观察者call方法中执行一次onNext() 对应的观察者就会执行一次onNext()onCompleted()onError() 也是如此,但请注意onCompleted() 的注释:
The {@link Observable} will not call this method if it calls {@link #onError}.
意思很明显,就是当调用了onError() 后调用onCompleted()

What Rxjava can do

1.方便、简洁地创建异步代码,举例:

     Observable.just(1).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                // do some action that going error
            }

            @Override
            public void onNext(Integer integer) {
                // do next action
            }
        });

2.方便地切换代码运行的线程

  Observable.just(1)
  .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe();

subscribeOn(xxx) 指定事件发生在哪个线程
observeOn(xxx) 指定Subscriber 的线程,即用户操作线程
注:subscribeOn(xxx) 无论调用多少次,只生效最后一次,即事件发生只能同时在一个线程。observeOn(xxx) 可以调用多次,每次调用指定下面的操作将要在哪个线程中进行。

Schedulers :调度器,用于指定代码运行的线程。RxJava提供的调度器有一下几种:
Schedulers.immediate(): 当前线程,即不指定具体线程,如果不指定其他线程,RxJava默认为immediate()
Schedulers.newThread():新启动一个线程,在新启动的线程中做操作。
Schedulers.io():i/o流线程,一般的网络请求、文件读写、数据库操作都可以在这个线程中进行。
Schedulers.computation():计算线程,主要用于大数据处理、图形计算。
AndroidSchedulers.mainThread():Android专用的线程,即UI操作线程。注:需要引入RxAndroid。

3.灵活地处理数据-操作符
这里先说两个基本操作符:mapflatmap
map:对发送的原始数据进行变换,返回的是变换后的数据
栗子:

Observable.just(R.string.a)
                .map(new Func1<Integer, String>() {
                    @Override
                    public String call(Integer integer) {
                        return getResources().getString(integer);
                    }
                }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                mTextView.setText(s);
            }
        });

当然,这没什么卵用…甚至比下面的还复杂

mTextView.setText(getResource().getString(R.string.a));

Rxjava学习笔记-01

先别急,在看看这个:

 Observable.just(R.string.a)
                .map(new Func1<Integer, String>() {
                    @Override
                    public String call(Integer integer) {
                        return getResources().getString(integer);
                    }
                }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                mTextView.setText(s);
            }
        });

加上了线程指定,在IO线程获取资源id(这里可以替换为网络获取图片地址),在主进程加载文字(这里可以替换为将获取的图片显示到ImageView)。一个基本的后台访问网络,UI刷新界面的异步代码就这样完成了。

flatmap :相对于map 它只是将发射的数据转换为了另一个Observable 对象,然后**这个Observable,转换出来的每一个Observable 发射出的事件最终被汇总到原始Observable中进行发送。

A simple test

coming soon;