Rxjava学习笔记-01

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.基础知识：观察者模式
观察者模式主要关注的点是，观察者十分在意被观察者的动作 ，当被观察者触发动作时，观察者会第一时间收到信息。
举个栗子

我去群光广场负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.灵活地处理数据-操作符
这里先说两个基本操作符：map和flatmap
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));

先别急，在看看这个：

 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;