RxJava的简单使用

RxJava的观察者模式：

Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)

Rxjava的回调方法：

onNext() :(相当于onClick()/onEvent())
onCompleted(): 事件队列完结时调用，RxJava官方规定，当不会再有onNext()方法被调用时，需要触发此方法作为完成标志。
onError():事件队列异常。在事件处理过程中出现异常的时候，onError() 就会被触发，同时自动终止队列，不允许再执行任务。

简单使用示例：

    private void case01() {
        // 遍历数据组中的元素；取出以a开头的元素，并在末尾加上后缀'xx'
        // 打印元素；

        // 1. 传统方式实现
        for (int i = 0; i < arr.length; i++) {
            String temp = arr[i];
            if (temp.startsWith("a")) {
                temp += " xx";
                System.out.println("traditional:" + temp.length());
            }
        }

        // 2. RxJava实现
        Observable
                .from(arr)  // from： 用来接收数组或集合数据，如果单个对象则用just
                .filter(new Func1<String, Boolean>() {  // 对数据进行过滤
                    @Override
                    public Boolean call(String s) { // 把以'a'开头的数组中的元素过滤出来
                        return s.startsWith("a");
                    }
                })
                .subscribe(new Action1<String>() {  // 订阅，处理数据

                    @Override
                    public void call(String s) {
                        String temp = s + " xx";
                        System.out.println("Rxjava:" + temp.length());
                    }
                });
    }


    private void case02() {
        Course yuwen = new Course("语文", 1);
        Course shuxue = new Course("数学", 2);
        Course yingyu = new Course("英文", 3);
        Course lishi = new Course("计算机", 4);

        ArrayList<Course> course1 = new ArrayList<>();
        course1.add(yuwen);
        course1.add(shuxue);
        course1.add(yingyu);
        course1.add(lishi);

        Student zhangsan = new Student("zhangsan", course1);

        Observable
                .just(zhangsan) // 接收一个数据（对象）

                // 一对多数据转换： Student对象 --> List<Course>
                .flatMap(new Func1<Student, Observable<Course>>() {
                    @Override
                    public Observable<Course> call(Student student) {
                        return Observable.from(student.getCourses());
                    }
                })

                .subscribe(new Action1<Course>() {  // List<Course>
                    @Override
                    public void call(Course course) {   // 打印每一个元素
                        System.out.println(course.getName());
                    }
                });
    }


    private void case03() {
        Observable
                // just：用来接收单个数据（一个对象）
                // from: 用来接收多个数据（数组或集合）
                .just(imageId)
                .subscribeOn(Schedulers.io())           // 后续操作在子线程中执行
                .map(new Func1<Integer, Drawable>() {   // 一对一数据转换：把Integer类的数据转成Drawable类型

                    @Override
                    public Drawable call(Integer integer) {
                        return getResources().getDrawable(integer);
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())  // 指定 Subscriber 的回调发生在主线程
                .subscribe(new Observer<Drawable>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        Toast.makeText(MainActivity.this, "Error", Toast.LENGTH_SHORT).show();
                    }

                    @Override
                    public void onNext(Drawable drawable) {
                        imageView.setImageDrawable(drawable);
                    }
                });
    }

更多详细信息可参考

猜你喜欢