RXJava

对于大多数初学者来说，看到RxJava的代码是懵逼的，我也一样，特别是链式的代码，一看就懵逼，最近，稍微搞清楚了一点，以此小记一番：

首先，我们来看常规的代码

//创建一个Observable<可观察的对象>：
public static Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("hello");
        emitter.onComplete();
    }
});
//创建一个Observer<观察者>
public static Observer observer = new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
        System.out.println("observer-->onSubscribe");
    }

    @Override
    public void onNext(String value) {
        System.out.println("observer-onNext->"+value);
    }
    @Override
    public void onError(Throwable e) {
        System.out.println("observer-->onError");
    }
    @Override
    public void onComplete() {
        System.out.println("observer-->onComplete");
    }
};
//可观察者和观察者之间建立联系
observable.subscribe(observer);

　　看到这里，大多数同学还是可以看明白的，因为这是很常规的代码，两个对象而已，没了

　　这段代码的输出的结果是：

observer-->onSubscribe
observer-onNext->hello
observer-->onComplete

　　然后变一个样式，链式的时候是这样的

Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("2");
        emitter.onComplete();
    }
}).subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
        System.out.println("observer-->onSubscribe");
    }

    @Override
    public void onNext(String value) {
        System.out.println("observer-onNext->" + value);
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("observer-->onError");
    }

    @Override
    public void onComplete() {
        System.out.println("observer-->onComplete");
    }
});

　　上面两段代码的效果是完全一模一样的啊。只是写法简洁了很多，但是对于初学者来说看起来就比较困难了　

 

　　下面来看看just

Observable.just("hello").subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
        System.out.println("observer-->onSubscribe");
    }

    @Override
    public void onNext(String value) {
        System.out.println("observer-onNext->" + value);
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("observer-->onError");
    }

    @Override
    public void onComplete() {
        System.out.println("observer-->onComplete");
    }
});

　　这段代码，看起来是不是似曾相识的感觉，Observable 的 create 方法返回的是一个 Onservable对象， 同样的，just 方法也是返回的也是一个 Observable、

　　这就很明白了，而两者的区别就是：Just是现有的数据，不用做处理，用 create 的方法，可以在 subscribe 里面做一些操作，包括对数据的处理等，最后调用 onNext 的时候把相应的数据发送出去

　　

　　下面来看看 map 操作

　　

Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("2");
        emitter.onComplete();
    }
}).map(new Function<String, Integer>() {
    //map基本作用就是将一个Observable通过某种函数关系，转换为另一种Observable，
    //这个例子中就是把我们的String数据变成了Integer类型
    @Override
    public Integer apply(String s) throws Exception {
        return Integer.parseInt(s);
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
        System.out.println("observer-->onSubscribe");
    }

    @Override
    public void onNext(Integer value) {
        System.out.println("observer-onNext->" + value);
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("observer-->onError");
    }

    @Override
    public void onComplete() {
        System.out.println("observer-->onComplete");
    }
});

　　这个和第二段代码的区别是，里面多了一个map的操作，你点击 map 进去你就会发现， map 也是返回的是一个 Observable 对象

　　这个例子中，看最后的 subscribe 的时候 Observer 的类型也相应的变化了，由原来的 String  类型变成了 Integer 类型

　　没错，这就是map的操作，map的作用就是使 Obasevable 的类型发生变化

　　这里要注意的是 Function 的第一个参数是原来Observable的对象的类型，而第二个参数是经过转换后的Observable的类型，可以粗略的理解成方法入参和返回值吧

 

 

 

暂且记叙到这里：2017-11-15 22：50 广州