RxJava整理

RxJava整理

将RxJava理解为观察者模式，则RxJava中的角色与观察者模式的联系有：

• 观察者 Observer
• 被观察对象 Observable
• 订阅(注册) subscribe

观察者通过订阅被观察对象，接收被观察对象的变化情况，并在观察者的onNext、onComplete、onError方法反应观察结果。

被观察者可以通过crate()、just(T…)、from(T[]) 或者from(Iterable)来创建，然后使用subscribe()方法将其与观察者连接起来。

Observer observer = new Observer() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(Object o) {

    }
};

Observable.just("Hello RxJava").subscribe(observer);

有时并不需要Observer中所有的方法，可以采用Action来替代。
Action分为两类

• Action1 含有参数的call方法 call(T param)，能够模拟Observer的onNext和onError方法
• Action0 无参数的call方法 call()， 能够模拟Observer的onComplete方法

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

    }
};

Action1<Throwable> onError = new Action1<Throwable>() {
    @Override
    public void call(Throwable throwable) {

    }
};

Action0 onComplete = new Action0() {
    @Override
    public void call() {

    }
};

List<String> lst = new ArrayList<>();
lst.add("Hello");
lst.add("RxJava");
Observable.from(lst).subscribe(onNext, onError, onComplete);

与Action类似的有Func1,与Action 不同的是 Func1指定返回值类型。

Func1<String, Integer> func1 = new Func1<String, Integer>() {
    @Override
    public Integer call(String s) {
        return null;
    }
};

当需要使用RxJava中的转换方法map的时候，就需要Func1来辅助，并且map可以级联使用。

List<String> lst = new ArrayList<>();
lst.add("1");
lst.add("2");
Observable.from(lst)
    .map(new Func1<String, Integer>() {
        @Override
        public Integer call(String s) {
            return Integer.valueOf(s);
        }
    })
    .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            System.out.println(integer);
        }
    });

与map相似的有floatMap，借助网上的栗子有如下代码：

List<Student> students = new ArrayList<Student>();
students.add...
...

Action1<List<Course>> action1 = new Action1<List<Course>>() {
    @Override
    public void call(List<Course> courses) {
        //遍历courses，输出cuouses的name
         for (int i = 0; i < courses.size(); i++){
            Log.i(TAG, courses.get(i).getName());
        }
    }
};
Observable.from(students)
        .map(new Func1<Student, List<Course>>() {
            @Override
            public List<Course> call(Student student) {
                //返回coursesList
                return student.getCoursesList();
            }
        })
        .subscribe(action1);

此代码是采用map的方式循环打印每个Student的Course信息。为了使代码更易于阅读可以采用floatMap实现有：

List<Student> students = new ArrayList<Student>();
students.add...
...

Observable.from(students)
        .flatMap(new Func1<Student, Observable<Course>>() {
            @Override
            public Observable<Course> call(Student student) {
                return Observable.from(student.getCoursesList());
            }
        })
        .subscribe(new Action1<Course>() {
            @Override
            public void call(Course course) {
                Log.i(TAG, course.getName());
            }
        });

在不指定线程的情况下，RxJava发起和消费是在同一个线程中。可以通过Schedule来指定代码块运行的线程。

List<String> nameList = new ArrayList<>();
nameList.add("Teemo");
nameList.add("SinPingWu");
Observable.from(nameList)
    .subscribeOn(Schedulers.newThread())
    .map(new Func1<String, String>() {
        @Override
        public String call(String s) {
            return s;
        }
    })
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            System.out.println(s);
            toastResult(s);
        }
    });

Schedulers有如下几类

• Schedulers.immediate()：直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。
• Schedulers.newThread()：总是启用新线程，并在新线程执行操作。
• Schedulers.io()： I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
• Schedulers.computation()：计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
• AndroidSchedulers.mainThread()：它指定的操作将在 Android 主线程运行。

RxJava支持线程之间的多次切换