初探RxJava2Android

源码

RxJava: https://github.com/ReactiveX/RxJava

RxAndroid: https://github.com/ReactiveX/RxAndroid

配置

    compile 'io.reactivex.rxjava2:rxjava:2.1.12'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.2'

基本用法

向数据库插入一个用户数据

Observable.create(new ObservableOnSubscribe() {//被观察者
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {
        Log.i("room---", "被观察者存入数据 threadId=" + Thread.currentThread().getId());
        User user = getUser();
        UserDatabase.getInstance(RoomActivity.this).getUserDao().insert(user);//插入数据
        emitter.onNext(user);//通知观察者已经插入数据
        emitter.onComplete();//执行观察者的onComplete方法
    }
}).doOnSubscribe(new Consumer() {
    @Override
    public void accept(Disposable disposable) throws Exception {
        //被观察者开启插入前的回调
        Log.i("room---", "被观察者插入数据前回调----threadId=" + Thread.currentThread().getId());
    }
})
.subscribeOn(Schedulers.io())//被观察者执行在io线程
.observeOn(AndroidSchedulers.mainThread())//观察者执行在android的UI线程
.subscribe(new Consumer() {
    @Override
    public void accept(User user) throws Exception {
        //接收到被观察者的通知,和onComplete执行在同一个线程
        Log.i("room---", "存入数据库的数据是：" + user.toString() + " threadId=" + Thread.currentThread().getId());
    }
}, new Consumer() {
    @Override
    public void accept(Throwable throwable) throws Exception {
        //发生错误的时候，观察者的此方法会被执行
    }
}, new Action() {
    @Override
    public void run() throws Exception {
        //观察者的onComplete对象，由被观察者执行（需要被观察者主动调用），和观察者回调执行在统一线程
        Log.i("room---", "插入数据执行完毕 threadId=" + Thread.currentThread().getId());
    }
});

输出

被观察者插入数据前回调----threadId=3564
被观察者存入数据 threadId=3564
存入数据库的数据是：id=0 name=user3 age=13 threadId=1
插入数据执行完毕 threadId=1

fromArray/fromIterable/just 用法

数据插入一组成功后，通知观察者：fromArray、fromIterable或者just,这几种方法都能自动调用onComplete

• 将数据元素逐个通知给观察者

        User[] users = new User[]{new User("userA", 12), new User("userB", 32)};
        //插入users...
        //...
        //插入完毕后通知监听
        Observable.fromArray(users)
        .observeOn(AndroidSchedulers.mainThread())//观察者执行在android的UI线程
        .subscribe(new Consumer() {
            @Override
            public void accept(User user) throws Exception {
                //接收到被观察者的通知，注意，此处是逐个通知
                Log.i("room---", "存入数据库的数据是：" + user.toString() + " threadId=" + Thread.currentThread().getId());
            }
        }, new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                //发生错误的时候，观察者的此方法会被执行
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //观察者的onComplete对象，能自动被调用
                Log.i("room---", "插入数据执行完毕 threadId=" + Thread.currentThread().getId());
            }
        });

或者：

        List userList = new ArrayList<>();
        userList.add(new User("userA", 23));
        userList.add(new User("userB", 24));
        //插入users...
        //...
        //插入完毕后通知监听
        Observable.fromIterable(userList)
        .observeOn(AndroidSchedulers.mainThread())//观察者执行在android的UI线程
        .subscribe(new Consumer() {
            @Override
            public void accept(User users) throws Exception {
                //接收到被观察者的通知
                Log.i("room---", "存入数据库的数据是：" + users.toString() + " threadId=" + Thread.currentThread().getId());
            }
        }, new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                //发生错误的时候，观察者的此方法会被执行
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //观察者的onComplete对象，能自动被调用
                Log.i("room---", "插入数据执行完毕 threadId=" + Thread.currentThread().getId());
            }
        });

数据插入成功后，通知观察者,将数组元素全部一次性通知给观察者

        User[] users = new User[]{new User("userA", 12), new User("userB", 32)};
        //插入users...
        //...
        //插入完毕后通知监听
        Observable.just(users)
        .observeOn(AndroidSchedulers.mainThread())//观察者执行在android的UI线程
        .subscribe(new Consumer() {
            @Override
            public void accept(User[] user) throws Exception {
                //接收到被观察者的通知
                for(int i = 0; i < user.length; i++) {
                    Log.i("room---", "存入数据库的数据是：" + user[i].toString() + " threadId=" + Thread.currentThread().getId());
                }
            }
        }, new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                //发生错误的时候，观察者的此方法会被执行
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //观察者的onComplete对象，由被观察者执行,能自动被调用
                Log.i("room---", "插入数据执行完毕 threadId=" + Thread.currentThread().getId());
            }
        });

或者

        List userList = new ArrayList<>();
        userList.add(new User("userA", 23));
        userList.add(new User("userB", 24));
        //插入users...
        //...
        //插入完毕后通知监听
        Observable.just(userList)
        .observeOn(AndroidSchedulers.mainThread())//观察者执行在android的UI线程
        .subscribe(new Consumer>() {
            @Override
            public void accept(List users) throws Exception {
                //接收到被观察者的通知
                for(User user : users) {
                    Log.i("room---", "存入数据库的数据是：" + user.toString() + " threadId=" + Thread.currentThread().getId());
                }
            }
        }, new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                //发生错误的时候，观察者的此方法会被执行
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //观察者的onComplete对象，由被观察者执行,能自动被调用
                Log.i("room---", "插入数据执行完毕 threadId=" + Thread.currentThread().getId());
            }
        });

输出结果一样

 存入数据库的数据是：id=0 name=userA age=12 threadId=1
 存入数据库的数据是：id=0 name=userB age=32 threadId=1
 插入数据执行完毕 threadId=1

map用法

将User转换为String回调给观察者

        Observable.fromIterable(userList)
        .map(new Function() {
            @Override
            public String apply(User user) throws Exception {
                return "mapUserString=" + user.toString();//将user转乘string给观察者
            }
        })
        .subscribe(new Consumer() {
            @Override
            public void accept(String userStr) throws Exception {
                //接收到被观察者的通知
                    Log.i("room---", "存入数据库的数据是：" + userStr);
            }
        }, new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                //发生错误的时候，观察者的此方法会被执行
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //观察者的onComplete对象
                Log.i("room---", "插入数据执行完毕");
            }
        });

输出

 存入数据库的数据是：mapUserString=id=0 name=userA age=23
 存入数据库的数据是：mapUserString=id=0 name=userB age=24
 插入数据执行完毕

flatMap 直接转换Observale对象

        Observable.create(new ObservableOnSubscribe>() {
            @Override
            public void subscribe(ObservableEmitter> emitter) throws Exception {
                List users = UserDatabase.getInstance(RoomActivity.this).getUserDao().queryAll();
                emitter.onNext(users);
            }
        })
        .subscribeOn(Schedulers.io())
        .flatMap(new Function, ObservableSource>() {
            @Override
            public ObservableSource apply(List userList) throws Exception {
                return Observable.fromIterable(userList);//转乘obserable对象
            }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Consumer