Rxjava

Rxjava是一个基于观察者模式的一个响应式编程框架。

引入Rxjava2.0
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'io.reactivex.rxjava2:rxjava:2.0.1'
创建事件的发出者

Observale observale = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("Hello RxJava2.0");
                e.onComplete();
            }

        });

其中泛型<String>是指要发出消息的类型！

创建事件的接受者

Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onNext(String value) {
                Log.d("ICE","onNext:"+value);
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
                Log.d("ICE","onComplete");
            }
        }

其中泛型是指接收到的类型

把发出者与接受者绑定
observable.subscribe(observer);
只有绑定之后才会发送事件。
简洁的语法——链式操作：

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("Hello RxJava2.0");
                e.onComplete();
            }

        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("ICE","onSubscribe");
            }
            @Override
            public void onNext(String value) {
                Log.d("ICE","onNext:"+value);
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
                Log.d("ICE","onComplete");
            }
        });

我们也许不想接受onComplete()和onError()，我们只关心onNext(),那么我们可以把接受者换成：

new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println(s+"  thread:"+Thread.currentThread().getName());
                    }
                }

我们甚至觉得发送都是一件麻烦的事情，那么可以使用just()：

Observable.just(imageUrl)

那么RxJava会自动帮我们发送just里面的内容！

改变事件的线程
.subscribeOn(Schedulers.io())

这个语句可以改变传递事件的执行线程，但是这条语句只有第一次出现的时候有用，所以设置多次也只是按照第一次的线程执行。

.observeOn(AndroidSchedulers.mainThread())//可以使用多次改变的是下一个操作的线程
所以在子线程下载图片，然后在UI线程更新图片的代码为：

 Observable.just(imageUrl)
                .map(new Function<String, Bitmap>() {
                    @Override
                    public Bitmap apply(String s) throws Exception {
                        HttpURLConnection conn  = (HttpURLConnection) new URL(imageUrl).openConnection();
                        Bitmap bitmap = BitmapFactory.decodeStream(conn.getInputStream());
                        return bitmap;
                    }
                })
                .subscribeOn(Schedulers.io())//只有第一次作用
                .observeOn(AndroidSchedulers.mainThread())//可以使用多次  改变的是下一个开始的
                .subscribe(new Consumer<Bitmap>() {
                    @Override
                    public void accept(Bitmap bitmap) throws Exception {
                        Log.d(TAG, "accept: thread:"+Thread.currentThread().getName());
                        imageView.setImageBitmap(bitmap);
                    }
                });

过滤器

.filter(new Predicate<String>() {
                    @Override
                    public boolean test(String s) throws Exception {
                        return s.endsWith(".jpg");
                    }
                })

我们可以过滤事件，保留满足我们需要的即可，上面就是保留了以.jpg结尾的字符串。