安卓中Rxjava

最新推荐文章于 2024-03-21 13:44:49 发布

昌啊！

最新推荐文章于 2024-03-21 13:44:49 发布

阅读量287

点赞数 1

分类专栏：原创

本文链接：https://blog.csdn.net/DC1031/article/details/96502427

版权

原创专栏收录该内容

22 篇文章 0 订阅

订阅专栏

RxJava异步

*RxJava 在 GitHub 主页上的自我介绍是 “a library for composing asynchronous and event-based programs using observable sequences for the Java VM”（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就是 RxJava ，概括得非常精准。
*

RxJava好处

简洁异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。 Android 创造的 AsyncTask 和Handler ，其实都是为了让异步代码更加简洁。RxJava 的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。

概念：扩展的观察者模式
RxJava 的异步实现，是通过一种扩展的观察者模式来实现的。
RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。
onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。
onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。
在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted() 和 onError() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。
创建 Observable

Observable 即被观察者，它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create() 方法来创建一个 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();
    }
});

线程控制 —— Scheduler (一)
在不指定线程的情况下， RxJava 遵循的是线程不变的原则，即：在哪个线程调用 subscribe()，就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。如果需要切换线程，就需要用到 Scheduler （调度器）。

3) Subscribe (订阅)
创建了 Observable 和 Observer 之后，再用 subscribe() 方法将它们联结起来，整条链子就可以工作了。
1.调用 Subscriber.onStart() 。这个方法在前面已经介绍过，是一个可选的准备方法。
2.调用 Observable 中的 OnSubscribe.call(Subscriber) 。在这里，事件发送的逻辑开始运行。从这也可以看出，在 RxJava 中， Observable 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当 subscribe() 方法执行的时候。
3.将传入的 Subscriber 作为 Subscription 返回。这是为了方便 unsubscribe().

1. 与 Retrofit 的结合

Retrofit 是 Square 的一个著名的网络请求库。没有用过 Retrofit 的可以选择跳过这一小节也没关系，我举的每种场景都只是个例子，而且例子之间并无前后关联，只是个抛砖引玉的作用，所以你跳过这里看别的场景也可以的。

Retrofit 除了提供了传统的 Callback 形式的 API，还有 RxJava 版本的 Observable 形式 API。下面我用对比的方式来介绍 Retrofit 的 RxJava 版 API 和传统版本的区别。

2. RxBinding

RxBinding 是 Jake Wharton 的一个开源库，它提供了一套在 Android 平台上的基于 RxJava 的 Binding API。所谓 Binding，就是类似设置 OnClickListener 、设置 TextWatcher 这样的注册绑定对象的 API。

3. 各种异步操作

前面举的 Retrofit 和 RxBinding 的例子，是两个可以提供现成的 Observable 的库。而如果你有某些异步操作无法用这些库来自动生成 Observable，也完全可以自己写。例如数据库的读写、大图片的载入、文件压缩/解压等各种需要放在后台工作的耗时操作，都可以用 RxJava 来实现，有了之前几章的例子，这里应该不用再举例了。

4. RxBus

RxBus 名字看起来像一个库，但它并不是一个库，而是一种模式，它的思想是使用 RxJava 来实现了 EventBus ，而让你不再需要使用 Otto 或者 GreenRobot 的 EventBus。

public class Rxjava {
    public static void main(String[] args) {
       /* new Observable<String>(){

            @Override
            protected void subscribeActual(Observer<? super String> observer) {


                observer.onNext("玻璃瓶");
                observer.onNext("啤酒瓶");
                observer.onComplete();
            }
        }.subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {


            }

            @Override
            public void onNext(String s) {

                System.out.println("接收到了：" + s);

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                System.out.println("接收数据完毕");

            }
        });*/

//        mapOpretor();
//        flatMapOpretor();
//        groupByOperator();
//        filterOperator();
//        distinctOperator();
//        ignoreElements();
//        elementAtOperator();
        windowOperator();
    }

    //map操作符
    public static  void mapOpretor(){
        Observable.just("HELLO")
         .map(new Function<String, String>() {
            @Override
            public String apply(String s) throws Exception {
                return s.toLowerCase();

            }
        })
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) throws Exception {
                        return s + ",world";
                    }
                })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println("接收到的数据是:" + s);


                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

    }

    //flatMap操作符
    public static void flatMapOpretor() {

        User user = new User();
        user.userName = "zhangsan";
        user.addresss = new ArrayList<>();
        User.Address address1 = new User.Address();
//        User.Address address1 = new User.Address();
        address1.street = "上地九街";
        address1.city = "北京";
        user.addresss.add(address1);

        User.Address address2 = new User.Address();
        address2.street = "上地十街";
        address2.city = "上海";
        user.addresss.add(address2);

        /*Observable.just(user)
                .map(new Function<User, List<User.Address>>() {
                    @Override
                    public List<User.Address> apply(User user) throws Exception {
                        return user.addresss;
                    }
                }).subscribe(new Consumer<List<User.Address>>() {
            @Override
            public void accept(List<User.Address> addresses) throws Exception {
                for (int i = 0; i < addresses.size(); i++) {
                    System.out.println("地址是：" + addresses.get(i).street);
                }
            }
        });*/

        Observable.just(user)
                .flatMap(new Function<User, ObservableSource<User.Address>>() {
                    @Override
                    public ObservableSource<User.Address> apply(User user) throws Exception {
                        return Observable.fromIterable(user.addresss);
                    }
                })

                .subscribe(new Consumer<User.Address>() {
            @Override
            public void accept(User.Address address) throws Exception {
                System.out.println("地址是：" + address.street);

            }
        });

    }

    //groupBy操作符
    public static void groupByOperator(){
        Observable
                .range(1,8)
                .groupBy(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return (integer % 2 == 0)? "偶数组":"奇数组";
                    }
                }).subscribe(new Consumer<GroupedObservable<String, Integer>>() {
            @Override
            public void accept(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) throws Exception {
                if(stringIntegerGroupedObservable.getKey().equals("奇数组")){
                    stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
                        @Override
                        public void accept(Integer integer) throws Exception {
                            System.out.println(stringIntegerGroupedObservable.getKey() + "member:"  + integer);
                        }
                    });
                }/*else if(stringIntegerGroupedObservable.getKey().equals("偶偶组")){
                    stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
                        @Override
                        public void accept(Integer integer) throws Exception {
                            System.out.println(stringIntegerGroupedObservable.getKey() + "member:"  + integer);

                        }
                    });
                }*/

                System.out.println();
            }
        });
    }

    //filter操作符
    public static void filterOperator(){

        Observable.just(1,8,20,3,50,4,6,100)
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 8;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println("next :" + integer);
            }
        });

    }

    //distinct过滤掉重复的数据项
    public static void distinctOperator() {
        Observable.just("A","A","B")
                .distinct()
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String integer) throws Exception {
                        System.out.println("next :" + integer);

                    }
                });
    }

    //ignoreElements 不发射任何数据
    public static void ignoreElements() {
        Observable.just(1,2,3,4,5)
                .ignoreElements()
                .subscribe(new Action() {
                    @Override
                    public void run() throws Exception {
                        System.out.println("完成了任务");

                    }
                });
    }


    //elementAt 只发射第n项数据
    public static void elementAtOperator() {
        Observable.just(1,2,3,4,5,6,7)
                .elementAt(2)
//                .elementAt(12,34)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println("next:" + integer);

                    }
                });
    }

    //window操作符
    public static void windowOperator() {
        Observable.range(1,10)
                .window(2)
                .subscribe(new Consumer<Observable<Integer>>() {
                    @Override
                    public void accept(Observable<Integer> integerObservable) throws Exception {
                        System.out.println("On next:" );
                        integerObservable.subscribe(new Consumer<Integer>() {
                            @Override
                            public void accept(Integer integer) throws Exception {
                                System.out.println("accept:" + integer );

                            }
                        });

                    }
                });
    }


}

字符串数组
String[] names = ...;
Observable.from(names)
    .subscribe(new Action1<String>() {
        @Override
        public void call(String name) {
            Log.d(tag, name);
        }
    });

由 id 取得图片并显示
int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new OnSubscribe<Drawable>() {
    @Override
    public void call(Subscriber<? super Drawable> subscriber) {
        Drawable drawable = getTheme().getDrawable(drawableRes));
        subscriber.onNext(drawable);
        subscriber.onCompleted();
    }
}).subscribe(new Observer<Drawable>() {
    @Override
    public void onNext(Drawable drawable) {
        imageView.setImageDrawable(drawable);
    }

    @Override
    public void onCompleted() {
    }

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

昌啊！

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
安卓中Rxjava

RxJava异步*RxJava 在 GitHub 主页上的自我介绍是 “a library for composing asynchronous and event-based programs using observable sequences for the Java VM”（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就是 RxJava ，概括得非常精...
复制链接

扫一扫