RxJava基本使用

Observable被观察者

Observable.OnSubscribe –>call()

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {

       @Override
        public void call(Subscriber<? super String> subscriber) {

            subscriber.onNext("Hi，Weavey！");  //发送数据"Hi，Weavey！"
        }
    });

ObServer观察者

Subscriber –> onNext(),onError(),onCompleted()

Observer<String> observer = new Observer<String>() {

        @Override
        public void onCompleted() {

            //数据接收完成时调用
        }

        @Override
        public void onError(Throwable e) {

            //发生错误调用
        }

        @Override
        public void onNext(String s) {

           //正常接收数据调用
            System.out.print(s);  //将接收到来自sender的问候"Hi，Weavey！"
        }
    };

subscribe订阅

observable.subscribe(observer);

基本概念

Observable：发射源，英文释义“可观察的”，在观察者模式中称为“被观察者”或“可观察对象”；

Observer：接收源，英文释义“观察者”，没错！就是观察者模式中的“观察者”，可接收Observable、Subject发射的数据；

Subject：Subject是一个比较特殊的对象，既可充当发射源，也可充当接收源，为避免初学者被混淆，本章将不对Subject做过多的解释和使用，重点放在Observable和Observer上，先把最基本方法的使用学会，后面再学其他的都不是什么问题；

Subscriber：“订阅者”，也是接收源，那它跟Observer有什么区别呢？Subscriber实现了Observer接口，比Observer多了一个最重要的方法unsubscribe( )，用来取消订阅，当你不再想接收数据了，可以调用unsubscribe( )方法停止接收，Observer 在 subscribe() 过程中,最终也会被转换成 Subscriber 对象，一般情况下，建议使用Subscriber作为接收源；

Subscription ：Observable调用subscribe( )方法返回的对象，同样有unsubscribe( )方法，可以用来取消订阅事件；

Action0：RxJava中的一个接口，它只有一个无参call（）方法，且无返回值，同样还有Action1，Action2…Action9等，Action1封装了含有 1 个参的call（）方法，即call（T t），Action2封装了含有 2 个参数的call方法，即call（T1 t1，T2 t2），以此类推；

Func0：与Action0非常相似，也有call（）方法，但是它是有返回值的，同样也有Func0、Func1…Func9;

示例

1. 从数据库的用户表查找出所有用户数据

    Observable.create(new Observable.OnSubscribe<List<User>>() {
         @Override
         public void call(Subscriber<? super List<User>> subscriber) {
             List<User> userList = null;
             ···
             //从数据库获取用户表数据并赋给userList
             ···
             subscriber.onNext(userList);
         }
     }).subscribe(new Action1<List<User>>() {
         @Override
         public void call(List<User> users) {
   
             //获取到用户信息列表
         }
     });
   

2. 领导突然又不想要所有用户了，只要名字叫“小明”的用户

   Observable.create(new Observable.OnSubscribe<List<User>>() {
         @Override
         public void call(Subscriber<? super List<User>> subscriber) {
             List<User> userList = null;
             ···
             //从数据库获取用户表数据并赋给userList
             ···
             subscriber.onNext(userList);
         }
     }).flatMap(new Func1<List<User>, Observable<User>>() {
         @Override
         public Observable<User> call(List<User> users) {
             return Observable.from(users);
         }
     }).filter(new Func1<User, Boolean>() {
         @Override
         public Boolean call(User user) {
             return user.getName().equals("小明");
         }
     }).subscribe(new Action1<User>() {
         @Override
         public void call(User user) {
             //拿到谜之小明的数据
         }
     });
   

3. 领导又说，我不要小明了，我要小明的爸爸的数据

   Observable.create(new Observable.OnSubscribe<List<User>>() {
     @Override
     public void call(Subscriber<? super List<User>> subscriber) {
         List<User> userList = null;
         ···
         //从数据库获取用户表数据并赋给userList
         ···
         subscriber.onNext(userList);
         } 
    }).flatMap(new Func1<List<User>, Observable<User>>() {
         @Override
         public Observable<User> call(List<User> users) {
             return Observable.from(users);
         }
     }).filter(new Func1<User, Boolean>() {
         @Override
         public Boolean call(User user) {
             return user.getName().equals("小明");
         }
     }).map(new Func1<User, User>() {
         @Override
         public User call(User user) { 
             //根据小明的数据user从数据库查找出小明的父亲user2
             return user2;
         }
     }).subscribe(new Action1<User>() {
         @Override
         public void call(User user2) {
           //拿到谜之小明的爸爸的数据
         }
     });
   

结论： RxJava在需求不断变更、逻辑愈加复杂的情况下，依旧可以保持代码简洁、可阅读性强