Rxjava 学习 一 基本的操作符

内容来源

1.创建 Observer (观察者)

Observer<String> observer = new Observer<String>() {
    @Override
    public void onNext(String s) {
        Log.d(tag, "Item: " + s);
    }

    @Override
    public void onCompleted() {
        Log.d(tag, "Completed!");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(tag, "Error!");
    }
};

Subscriber 实现了 Observer 的抽象类，对 Observer 实现了一些扩展

Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onNext(String s) {
        Log.d(tag, "Item: " + s);
    }

    @Override
    public void onCompleted() {
        Log.d(tag, "Completed!");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(tag, "Error!");
    }
};

2.创建 Observable

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("Hello");
        subscriber.onNext("Hi");
        subscriber.onNext("Aloha");
        subscriber.onCompleted();
    }
});

3.产生订阅关系

observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);

4.常见的操作符

• ** just(T...): 将传入的参数依次发送出来。**

Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

• ** from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。**

String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

• ** 变换 **
  概念解释：

所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成 不同的事件或事件序列。
换一句话说就是：将一种事件变化为另一种事件

• 1. map() 一对一的转化
     栗子：

Observable.just("images/logo.png") // 输入类型 String
     .map(new Func1<String, Bitmap>() {
        @Override
        public Bitmap call(String filePath) { // 参数类型 String
            return getBitmapFromPath(filePath); // 返回类型 Bitmap
        }
    }) .subscribe(new Action1<Bitmap>() {
        @Override
        public void call(Bitmap bitmap) { // 参数类型 Bitmap
            showBitmap(bitmap);
        }
    });

被观察者传入的参数类型为 String ，即事件的起点操作的数据类型为 String 字符串类型，通过 map() 函数的变换map(new Func1<String, Bitmap>(){ ... }，将参数中的 String 对象 转换成 Bitmap 对象后返回，即观察者即消费事件的操作数据类型为 Bitmap 的数据类型 subscribe(new Action1<Bitmap>() { ... }

• 2. flapMap() 一对多的转化
     栗子：

Student[] students = ...;
Subscriber<Course> subscriber = new Subscriber<Course>() {
    @Override
    public void onNext(Course course) {
        Log.d(tag, course.getName());
    }
    ...
};
Observable.from(students)
    .flatMap(new Func1<Student, Observable<Course>>() {
        @Override
        public Observable<Course> call(Student student) {
            return Observable.from(student.getCourses());
        }
    })
    .subscribe(subscriber);

flatMap() 的原理是这样的：

1. 使用传入的事件对象创建一个 Observable 对象；
2. 并不发送这个 Observable, 而是将它激活，于是它开始发送事件；
3. 每一个创建出来的 Observable 发送的事件，都被汇入同一个 Observable ，而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。

这三个步骤，把事件拆成了两级，通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径分发了下去。而这个『铺平』就是 flatMap() 所谓的 flat。

• map() flatMap() 异同点

  同：两者都是把传入的参数转化之后返回另一个对象
 异：flatMap() 中返回的是个 ` Observable 对象 `，并且这个 Observable 对象并不是被直接发送到了 Subscriber 的回调方法中，
       而 map() 仅仅是将`参数的数据类型`做了相关的变换。