美高梅开户送58元官网:需要传递一个 OnSubscrib

2019-09-30 15:32栏目:美高梅开户送58元官网
TAG:

使用RxJava 已经有一年多的时间,从 RxJava 1.0 +Retrofit 2.0 网络请求框架,包括常用的 RxBus,RxPermission 等,到后面的RxJava2.0+Retrofit2.0。然而始终没有认真细致的去归纳总结,基于这个缘由,本文将由浅入深,由Rx的基本用法,到RxJava和Retrofit的封装,到Rx的源码分析,做一次系统的学习。

RxJava 到底是什么

来自于:CSDN blog.csdn.net/caihongdao123/article/details/51897793

本文将分为三个方面阐述:

一个词:异步

前言:

  • RxJava 是什么
  • RxJava 基本用法
  • RxJava 的用途

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

第一次接触RxJava是在前不久,一个新Android项目的启动,在评估时选择了RxJava。RxJava是一个基于事件订阅的异步执行的一个类库。听起来有点复杂,其实是要你使用过一次,就会大概明白它是怎么回事了!为是什么一个android项目启动会联系到RxJava呢?因为在RxJava使用起来得到广泛的认可,又是基于Java语言的。自然会有善于组织和总结的开发者联想到Android!没错,RxAndroid就这样在RxJava的基础上,针对Android开发的一个库。今天我们主要是来讲解一下RxJava,在接下来的几篇博客中我会陆续带大家来认识RxAndroid,Retrofit框架的使用,这些都是目前比较火的一些技术框架!

想要用一句话总结RxJava,或许只有作者的那句话才能精准概括了:RxJava实现了jvm的响应式扩展,通过观察序列来实现异步和基于事件的库。如果要加上更细致的阐述那就是:它扩展了观察者模式,支持数据或者事件的序列,添加了一系列的操作符,允许你使用声明的方式组合序列,同时处理了线程、同步、线程安全、和并发的问题。

然而,对于初学者来说,这太难看懂了。因为它是一个『总结』,而初学者更需要一个『引言』。

这里是Github上RxJava的项目地址:https://github.com/ReactiveX/RxJava

RxJava 依赖代码

compile "io.reactivex:rxjava:1.2.3"compile "io.reactivex:rxandroid:1.2.1"

其实, RxJava 的本质可以压缩为异步这一个词。说到根上,它就是一个实现异步操作的库,而别的定语都是基于这之上的。

技术文档Api:http://reactivex.io/RxJava/javadoc/

既然是观察者模式,那么就必然有观察者和被观察者,在RxJava中,有两个类需要搞清楚

RxJava 好在哪

官方的介绍

Observable :被观察者,Observer :观察者。二者通过 subscribe() 方法来实现订阅的关系,这样一来 Observable 可以在需要的时候发送事件通知 Observer。

换句话说,『同样是做异步,为什么人们用它,而不用现成的 AsyncTask / Handler / XXX / ... ?』

1.支持Java6+

 //创建一个 Observable  Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { subscriber.onNext; subscriber.onCompleted;

一个词:简洁

2.android 2.3+

创建 Observable 的时候,需要传递一个 OnSubscribe 对象 ,这个对象的指定了一个回调,当订阅事件发生的时候,call 方法里面的内容就会被调用。在回调的方法中 可以看到 Subscriber 对象,这个对象实现了 Observer 和 Subscription 接口,事实上,它是 Observer 的升级版。

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

3.异步的

而 Observable 创建的时候做了什么呢?

假设有这样一个需求:界面上有一个自定义的视图 imageCollectorView ,它的作用是显示多张图片,并能使用 addImage(Bitmap) 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组 File[] folders 中每个目录下的 png 图片都加载出来并显示在 imageCollectorView 中。需要注意的是,由于读取图片的这一过程较为耗时,需要放在后台执行,而图片的显示则必须在 UI 线程执行。常用的实现方式有多种,我这里贴出其中一种:

4.基于观察者设计模式(Observer、Observable)不懂设计模式的可以移步到此:浅谈Java设计模式(十五)观察者模式(Observer)

 public static <T> Observable<T> create(OnSubscribe<T> f) { return new Observable<T>(RxJavaHooks.onCreate;}

new Thread() {    @Override    public void run() {        super.run();        for (File folder : folders) {            File[] files = folder.listFiles();            for (File file : files) {                if (file.getName().endsWith(".png")) {                    final Bitmap bitmap = getBitmapFromFile(file);                    getActivity().runOnUiThread(new Runnable() {                        @Override                        public void run() {                            imageCollectorView.addImage(bitmap);                        }                    });                }            }        }    }}.start();

5.Subscribe (订阅)

RxJavaHooks 的 onCreate() 返回了一个 OnSubscribe 对象,OnSubscribe 是 Action1 的子类,是一个只有一个 call() 方法的接口。RxJavaHooks 的内部,则调用了 RxJavaHooks 的一个接口 Func1 的 call()方法的回调。

而如果使用 RxJava ,实现方式是这样的:

正式使用RxJava

 //创建一个 Observer  Observer observer = new Observer() { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext { } };

Observable.from(folders)    .flatMap(new Func1>() {        @Override        public Observable call(File file) {            return Observable.from(file.listFiles());        }    })    .filter(new Func1() {        @Override        public Boolean call(File file) {            return file.getName().endsWith(".png");        }    })    .map(new Func1() {        @Override        public Bitmap call(File file) {            return getBitmapFromFile(file);        }    })    .subscribeOn(Schedulers.io())    .observeOn(AndroidSchedulers.mainThread())    .subscribe(new Action1() {        @Override        public void call(Bitmap bitmap) {            imageCollectorView.addImage(bitmap);        }    });

用框架或者库都是为了简洁、方便,RxJava也不例外它能使你的代码逻辑更加的简洁。举个例子之前我们先来引入依赖的 gradle 代码:

或者可以这样写:

那位说话了:『你这代码明明变多了啊!简洁个毛啊!』大兄弟你消消气,我说的是逻辑的简洁,不是单纯的代码量少(逻辑简洁才是提升读写代码速度的必杀技对不?)。观察一下你会发现, RxJava 的这个实现,是一条从上到下的链式调用,没有任何嵌套,这在逻辑的简洁性上是具有优势的。当需求变得复杂时,这种优势将更加明显(试想如果还要求只选取前 10 张图片,常规方式要怎么办?如果有更多这样那样的要求呢?再试想,在这一大堆需求实现完两个月之后需要改功能,当你翻回这里看到自己当初写下的那一片迷之缩进,你能保证自己将迅速看懂,而不是对着代码重新捋一遍思路?)。

[java]view plaincopy

 Subscriber subscriber = new Subscriber() { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext { } };

另外,如果你的 IDE 是 Android Studio ,其实每次打开某个 Java 文件的时候,你会看到被自动 Lambda 化的预览,这将让你更加清晰地看到程序逻辑:

compile'io.reactivex:rxjava:1.0.14'

Observer只是一个接口,他们的作用是一样的,区别在于 Subscriber 比 Observer 多了两个方法 onStart() 和 unsubscribe(), 前者是在事件还没有发送之前调用的,可以进行一些准备的动作,后者则是用于取消订阅,在发生订阅行为的时候,被观察者会持有观察者的引用,如果在页面销毁或者view销毁或者其他情况下没有进行解绑,则会发生内存泄漏。

Observable.from(folders)    .flatMap((Func1) (folder) -> { Observable.from(file.listFiles()) })    .filter((Func1) (file) -> { file.getName().endsWith(".png") })    .map((Func1) (file) -> { getBitmapFromFile(file) })    .subscribeOn(Schedulers.io())    .observeOn(AndroidSchedulers.mainThread())    .subscribe((Action1) (bitmap) -> { imageCollectorView.addImage(bitmap) });

compile'io.reactivex:rxandroid:1.0.1'

 //订阅 observable.subscribe;

在Flipboard 的 Android 代码中,有一段逻辑非常复杂,包含了多次内存操作、本地文件操作和网络操作,对象分分合合,线程间相互配合相互等待,一会儿排成人字,一会儿排成一字。如果使用常规的方法来实现,肯定是要写得欲仙欲死,然而在使用 RxJava 的情况下,依然只是一条链式调用就完成了。它很长,但很清晰。

既然是基于异步,当然要在处理比较耗时的操作上才能彰显它的优势!现在我们假设有这样一个需求:

这里有个奇怪的现象,你会发现是被观察者订阅了观察者。之所以这样实现,是为了更好的设计。而订阅行为到底干了什么,为什么要传递进去一个接口呢?看下源码

所以, RxJava 好在哪?就好在简洁,好在那把什么复杂逻辑都能穿成一条线的简洁。

需要实现一个多个下载的图片并且显示的功能,它的作用可以添加多个下载操作,由于下载这一过程较为耗时,需要放在后台执行,而图片的显示则必须在 UI 线程执行。常用的实现方式有多种,我这里贴出其中一种:

public final Subscription subscribe(final Observer<? super T> observer) { if (observer instanceof Subscriber) { return subscribe((Subscriber<? super T>)observer); } if (observer == null) { throw new NullPointerException("observer is null"); } return subscribe(new ObserverSubscriber<T>);}

API 介绍和原理简析

[java]view plaincopy

重点看下 observable 的 subscribe 方法,他需要传递一个 ObserverSubscriber的对象 ,它Subscriber 的子类,而且提供了一个构造函数来传递 observer。在真正的 subscribe 方法中,我们可以看到这么一句话:

这个我就做不到一个词说明了……因为这一节的主要内容就是一步步地说明 RxJava 到底怎样做到了异步,怎样做到了简洁。

newThread() {

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) { // validate and proceed if (subscriber == null) { throw new IllegalArgumentException("subscriber can not be null"); } if (observable.onSubscribe == null) { throw new IllegalStateException("onSubscribe function can not be null."); /* * the subscribe function can also be overridden but generally that's not the appropriate approach * so I won't mention that in the exception */ } // new Subscriber so onStart it subscriber.onStart(); /* * See https://github.com/ReactiveX/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls * to user code from within an Observer" */ // if not already wrapped if (!(subscriber instanceof SafeSubscriber)) { // assign to `observer` so we return the protected version subscriber = new SafeSubscriber<T>(subscriber); } // The code below is exactly the same an unsafeSubscribe but not used because it would // add a significant depth to already huge call stacks. try { // allow the hook to intercept and/or decorate RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber); return RxJavaHooks.onObservableReturn(subscriber); } catch (Throwable e) { // special handling for certain Throwable/Error/Exception types Exceptions.throwIfFatal; // in case the subscriber can't listen to exceptions anymore if (subscriber.isUnsubscribed { RxJavaHooks.onError(RxJavaHooks.onObservableError; } else { // if an unhandled error occurs executing the onSubscribe we will propagate it try { subscriber.onError(RxJavaHooks.onObservableError; } catch (Throwable e2) { Exceptions.throwIfFatal; // if this happens it means the onError itself failed (perhaps an invalid function implementation) // so we are unable to propagate the error correctly and will just throw RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2); // TODO could the hook be the cause of the error in the on error handling. RxJavaHooks.onObservableError; // TODO why aren't we throwing the hook's return value. throw r; // NOPMD } } return Subscriptions.unsubscribed(); }}
  1. 概念:扩展的观察者模式

@Override

subscriber.onStart(); 在 observable 中 调用了 subscriber 的 onStart()方法,RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber); 这个方法,其实就是OnSubscribe对call 方法的调用。

RxJava 的异步实现,是通过一种扩展的观察者模式来实现的。

publicvoidrun() {

经过上面的三个步骤,就完成了一次RxJava的基本使用。然而事实上,不管是 observable 的创建或者是 observer 或者 Subscriber ,再或者绑定的使用,都有很多种方法可以选择,事实上,要根据业务逻辑或者不同的场景来选择使用。比如:

观察者模式

super.run();

 Observable<String> just = Observable.just( "are", "u", "ok"); just.subscribe(new Subscriber<String>() { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext { Log.i; } });

先简述一下观察者模式,已经熟悉的可以跳过这一段。

for(File folder : folders) {

通过just 将传入的参数依次的发送出来,这样,在 Subscriber 的回调中,就可以依次的打印出那几个字符串。假定有一个数据源,我需要依次发送数据源里面的数据,from方法则会很恰当,就像这样:

观察者模式面向的需求是:A 对象(观察者)对 B 对象(被观察者)的某种变化高度敏感,需要在 B 变化的一瞬间做出反应。举个例子,新闻里喜闻乐见的警察抓小偷,警察需要在小偷伸手作案的时候实施抓捕。在这个例子里,警察是观察者,小偷是被观察者,警察需要时刻盯着小偷的一举一动,才能保证不会漏过任何瞬间。程序的观察者模式和这种真正的『观察』略有不同,观察者不需要时刻盯着被观察者(例如 A 不需要每过 2ms 就检查一次 B 的状态),而是采用注册(Register)或者称为订阅(Subscribe)的方式,告诉被观察者:我需要你的某某状态,你要在它变化的时候通知我。 Android 开发中一个比较典型的例子是点击监听器 OnClickListener 。对设置 OnClickListener 来说, View 是被观察者, OnClickListener 是观察者,二者通过 setOnClickListener() 方法达成订阅关系。订阅之后用户点击按钮的瞬间,Android Framework 就会将点击事件发送给已经注册的 OnClickListener 。采取这样被动的观察方式,既省去了反复检索状态的资源消耗,也能够得到最高的反馈速度。当然,这也得益于我们可以随意定制自己程序中的观察者和被观察者,而警察叔叔明显无法要求小偷『你在作案的时候务必通知我』。

File[] files = folder.listFiles();

 String[] array = new String[]{"are","u","ok"}; Observable<String> observableStr = Observable.from; observableStr.subscribe(new Subscriber<String>() { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext { } });

OnClickListener 的模式大致如下图:

for(File file : files) {

同样的,Subscribe() 方法也可以通过Action来实现某些不完全的定义,比如这样:

美高梅开户送58元官网 1

if(file.getName().endsWith(".png")) {

 Action1<String> action1 = new Action1<String>() { @Override public void call { Log.i; } }; observableStr.subscribe;

如图所示,通过 setOnClickListener() 方法,Button 持有 OnClickListener 的引用(这一过程没有在图上画出);当用户点击时,Button 自动调用 OnClickListener 的 onClick() 方法。另外,如果把这张图中的概念抽象出来(Button -> 被观察者、OnClickListener -> 观察者、setOnClickListener() -> 订阅,onClick() -> 事件),就由专用的观察者模式(例如只用于监听控件点击)转变成了通用的观察者模式。如下图:

finalBitmap bitmap = getBitmapFromFile(file);

通过 Schduler 调度器来指定某段代码运行在哪个线程之中,因为在日常开发中,我们总是会将耗时的请求放在后台,通过回调在前台更新ui,基于这些重要的线程控制,Scheduler 提供了一系列的方法来进行线程切换。诸如:

美高梅开户送58元官网 2

getActivity().runOnUiThread(newRunnable() {

 //直接运行,即在当前的线程运行 Schedulers.immediate(); //计算的线程,主要用于事件轮询,回调的处理等。不能进行耗时的操作。 Schedulers.computation(); //开启一个新的线程,并且运行在新线程 Schedulers.newThread(); // 读写、网络、等耗时操作 Schedulers.io(); //Android 主线程 AndroidSchedulers.mainThread();

而 RxJava 作为一个工具库,使用的就是通用形式的观察者模式。

@Override

Observable 提供了一些方法来指定我们需要的线程:

RxJava 的观察者模式

publicvoidrun() {

observableStr.subscribeOn(Schedulers.io .observeOn(AndroidSchedulers.mainThread;

RxJava 有四个基本概念:Observable (可观察者,即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系,从而 Observable 可以在需要的时候发出事件来通知 Observer。

imageCollectorView.addImage(bitmap);

subscribeOn() 方法指定了subscribe() 发生在IO线程,observeOn() 则指定了其回调发生在主线程。准确的说前者是指定事件产生的线程,后者是指定事件消费的线程。

与传统观察者模式不同, RxJava 的事件回调方法除了普通事件 onNext() (相当于 onClick() / onEvent())之外,还定义了两个特殊的事件:onCompleted() 和 onError()。

}

所谓变换,即把事件序列 中的对象或者整个序列进行变换,得到我想要的事件或者序列。通过一个简单的例子就可以看出来转换的强大之处了。比如说我想加载指定路径下的ImageView

onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理,还会把它们看做一个队列。RxJava 规定,当不会再有新的 onNext() 发出时,需要触发 onCompleted() 方法作为标志。

});

 String mImgPath = "..."; Observable.just .map(new Func1<String, Bitmap>() { @Override public Bitmap call { Bitmap bitmap = BitmapFactory.decodeFile; return bitmap; } }) .subscribe(new Action1<Bitmap>() { @Override public void call(Bitmap bitmap) { imageView.setImageBitmap; } });

onError(): 事件队列异常。在事件处理过程中出异常时,onError() 会被触发,同时队列自动终止,不允许再有事件发出。

}

map()方法需要一个 Func1 的回调 ,Func1是一个简单的接口,和 Action 不同的地方在于,它是有返回值的。这就达到了转换的目的。我们看到,我们发送事件的只是一个字符串,通过转换,在我们需要Bitmap的时候,在map() 中把字符串做了转换。

在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个,并且是事件序列中的最后一个。需要注意的是,onCompleted() 和 onError() 二者也是互斥的,即在队列中调用了其中一个,就不应该再调用另一个。

}

除此之外,还有一个转换的方法 flatMap方法不同的地方在于,flatMap中返回的是一个 Observable 对象。通过 flatMap 将事件进行了拆分,可以进行更加细致和精准的处理:假如有这个一个类,在发起事件的时候传递整个类的对象,最后我想要的是String content,这种情况使用flatMap 就更加方便了。

RxJava 的观察者模式大致如下图:

}

public class DataBean implements Serializable {public Data data;public String message;public int code;class Data { public String title; public Content content;}class Content { public String content;}
  1. 基本实现

}

}

基于以上的概念, RxJava 的基本实现主要有三点:

}.start();

final List<DataBean> beanList = new ArrayList<>(); Subscriber<String> subscriber1 = new Subscriber<String>() { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext { } }; Observable.from .flatMap(new Func1<DataBean, Observable<DataBean.Content>>() { @Override public Observable<DataBean.Content> call(DataBean bean) { return Observable.just(bean.data.content); } }) .flatMap(new Func1<DataBean.Content, Observable<String>>() { @Override public Observable<String> call(DataBean.Content content) { return Observable.just(content.content); } }) .subscribe(subscriber1);

1) 创建 Observer

里面的判断是不是看起来有点晕晕,当然这是我自己写的,我一眼就能看清楚里面的逻辑,但是如果换做是别人来阅读你的代码,这就比较的尴尬了!

我们会发现 map 是一对一的关系,而 flatMap 是一对多的关系,通过 flatmap 可以实现很强大的功能。

Observer 即观察者,它决定事件触发的时候将有怎样的行为。 RxJava 中的 Observer 接口的实现方式:

我们来看看使用RxJava的代码:

假如我们需要把一个Bitmap格式的图片保存为png或者jpg文件 ,假如使用RxJava,结合上面的线程调度器,我们该怎么写呢?直接上代码吧。

Observer observer = new Observer() {    @Override    public void onNext(String s) {        Log.d(tag, "Item: " + s);    }    @Override    public void onCompleted() {        Log.d(tag, "Completed!");    }    @Override    public void onError(Throwable e) {        Log.d(tag, "Error!");    }};

[java]view plaincopy

 Observable.create(new SaveObservable .subscribeOn(Schedulers.io .observeOn(AndroidSchedulers.mainThread .subscribe(new SaveSubscriber; //Observable private class SaveObservable implements Observable.OnSubscribe<String> { private Bitmap drawingCache = null; public SaveObservable(Bitmap drawingCache) { this.drawingCache = drawingCache; } @Override public void call(Subscriber<? super String> subscriber) { if (drawingCache == null) { subscriber.onError(new NullPointerException); } else { try { File imageFile = new File(imagePath,imageName); FileOutputStream outStream = new FileOutputStream(imageFile); drawingCache.compress(Bitmap.CompressFormat.JPEG, 100, outStream); subscriber.onNext(Environment.getExternalStorageDirectory() + "/store"); subscriber.onCompleted(); outStream.flush(); outStream.close(); } catch (IOException e) { subscriber.onError; } } }}//Subscriberprivate class SaveSubscriber extends Subscriber<String> { @Override public void onCompleted() { // Toast.makeText(context, "保存成功", Toast.LENGTH_SHORT).show(); } @Override public void onError(Throwable e) { Log.i(getClass().getSimpleName(), e.toString; Toast.makeText(context, "保存失败:" + e.toString(), Toast.LENGTH_SHORT).show(); } @Override public void onNext { Toast.makeText(context, "保存至" + s, Toast.LENGTH_SHORT).show(); }}

除了 Observer 接口之外,RxJava 还内置了一个实现了 Observer 的抽象类:Subscriber。 Subscriber 对 Observer 接口进行了一些扩展,但他们的基本使用方式是完全一样的:

Observable.from(folders)

这样以来,我们的代码看起来非常的清爽,而且逻辑清晰。

Subscriber subscriber = new Subscriber() {    @Override    public void onNext(String s) {        Log.d(tag, "Item: " + s);    }    @Override    public void onCompleted() {        Log.d(tag, "Completed!");    }    @Override    public void onError(Throwable e) {        Log.d(tag, "Error!");    }};

.flatMap(newFunc1>() {

不仅基本使用方式一样,实质上,在 RxJava 的 subscribe 过程中,Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能,选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点:

@Override

onStart(): 这是 Subscriber 增加的方法。它会在 subscribe 刚开始,而事件还未发送之前被调用,可以用于做一些准备工作,例如数据的清零或重置。这是一个可选方法,默认情况下它的实现为空。需要注意的是,如果对准备工作的线程有要求(例如弹出一个显示进度的对话框,这必须在主线程执行), onStart() 就不适用了,因为它总是在 subscribe 所发生的线程被调用,而不能指定线程。要在指定的线程来做准备工作,可以使用 doOnSubscribe() 方法,具体可以在后面的文中看到。

publicObservable call(File file) {

unsubscribe(): 这是 Subscriber 所实现的另一个接口 Subscription 的方法,用于取消订阅。在这个方法被调用后,Subscriber 将不再接收事件。一般在这个方法调用前,可以使用 isUnsubscribed() 先判断一下状态。 unsubscribe() 这个方法很重要,因为在 subscribe() 之后, Observable 会持有 Subscriber 的引用,这个引用如果不能及时被释放,将有内存泄露的风险。所以最好保持一个原则:要在不再使用的时候尽快在合适的地方(例如 onPause() onStop() 等方法中)调用 unsubscribe() 来解除引用关系,以避免内存泄露的发生。

returnObservable.from(file.listFiles());

2) 创建 Observable

}

Observable 即被观察者,它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create() 方法来创建一个 Observable ,并为它定义事件触发规则:

})

Observable observable = Observable.create(new Observable.OnSubscribe() {    @Override    public void call(Subscriber subscriber) {        subscriber.onNext("Hello");        subscriber.onNext("Hi");        subscriber.onNext("Aloha");        subscriber.onCompleted();    }});

.filter(newFunc1() {

可以看到,这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中,它的作用相当于一个计划表,当 Observable 被订阅的时候,OnSubscribe 的 call() 方法会自动被调用,事件序列就会依照设定依次触发(对于上面的代码,就是观察者Subscriber 将会被调用三次 onNext() 和一次 onCompleted())。这样,由被观察者调用了观察者的回调方法,就实现了由被观察者向观察者的事件传递,即观察者模式。

@Override

create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法, RxJava 还提供了一些方法用来快捷创建事件队列,例如:

publicBoolean call(File file) {

just(T...): 将传入的参数依次发送出来。

returnfile.getName().endsWith(".png");

Observable observable = Observable.just("Hello", "Hi", "Aloha");// 将会依次调用:// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();

}

from(T[]) / from(Iterable) : 将传入的数组或 Iterable 拆分成具体对象后,依次发送出来。

})

String[] words = {"Hello", "Hi", "Aloha"};Observable observable = Observable.from(words);// 将会依次调用:// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();

.map(newFunc1() {

上面 just(T...) 的例子和 from(T[]) 的例子,都和之前的 create(OnSubscribe) 的例子是等价的。

@Override

3) Subscribe (订阅)

publicBitmap call(File file) {

创建了 Observable 和 Observer 之后,再用 subscribe() 方法将它们联结起来,整条链子就可以工作了。代码形式很简单:

returngetBitmapFromFile(file);

observable.subscribe(observer);// 或者:observable.subscribe(subscriber);

}

有人可能会注意到, subscribe() 这个方法有点怪:它看起来是『observalbe 订阅了 observer / subscriber』而不是『observer / subscriber 订阅了 observalbe』,这看起来就像『杂志订阅了读者』一样颠倒了对象关系。这让人读起来有点别扭,不过如果把 API 设计成 observer.subscribe(observable) / subscriber.subscribe(observable) ,虽然更加符合思维逻辑,但对流式 API 的设计就造成影响了,比较起来明显是得不偿失的。

})

Observable.subscribe(Subscriber) 的内部实现是这样的(仅核心代码):

.subscribeOn(Schedulers.io())

// 注意:这不是 subscribe() 的源码,而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。// 如果需要看源码,可以去 RxJava 的 GitHub 仓库下载。public Subscription subscribe(Subscriber subscriber) {    subscriber.onStart();    onSubscribe.call(subscriber);    return subscriber;}

.observeOn(AndroidSchedulers.mainThread())

可以看到,subscriber() 做了3件事:

.subscribe(newAction1() {

调用 Subscriber.onStart() 。这个方法在前面已经介绍过,是一个可选的准备方法。

@Override

调用 Observable 中的 OnSubscribe.call(Subscriber) 。在这里,事件发送的逻辑开始运行。从这也可以看出,在 RxJava 中, Observable 并不是在创建的时候就立即开始发送事件,而是在它被订阅的时候,即当 subscribe() 方法执行的时候。

publicvoidcall(Bitmap bitmap) {

将传入的 Subscriber 作为 Subscription 返回。这是为了方便 unsubscribe().

imageCollectorView.addImage(bitmap);

整个过程中对象间的关系如下图:

}

美高梅开户送58元官网 3

});

除了 subscribe(Observer) 和 subscribe(Subscriber) ,subscribe() 还支持不完整定义的回调,RxJava 会自动根据定义创建出 Subscriber 。形式如下:

是不是明了,虽然说算不上简单,但是习惯了就一如既往了!

Action1 onNextAction = new Action1() {    // onNext()    @Override    public void call(String s) {        Log.d(tag, s);    }};Action1 onErrorAction = new Action1() {    // onError()    @Override    public void call(Throwable throwable) {        // Error handling    }};Action0 onCompletedAction = new Action0() {    // onCompleted()    @Override    public void call() {        Log.d(tag, "completed");    }};// 自动创建 Subscriber ,并使用 onNextAction 来定义 onNext()observable.subscribe(onNextAction);// 自动创建 Subscriber ,并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()observable.subscribe(onNextAction, onErrorAction);// 自动创建 Subscriber ,并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

如果你使用的AndroidStudio的话,你打开Java文件的时候,你会看到被自动 Lambda 化的预览,这将让你更加清晰地看到程序逻辑:

简单解释一下这段代码中出现的 Action1 和 Action0。 Action0 是 RxJava 的一个接口,它只有一个方法 call(),这个方法是无参无返回值的;由于 onCompleted() 方法也是无参无返回值的,因此 Action0 可以被当成一个包装对象,将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe() 以实现不完整定义的回调。这样其实也可以看做将 onCompleted() 方法作为参数传进了 subscribe(),相当于其他某些语言中的『闭包』。 Action1 也是一个接口,它同样只有一个方法 call(T param),这个方法也无返回值,但有一个参数;与 Action0 同理,由于 onNext(T obj) 和 onError(Throwable error) 也是单参数无返回值的,因此 Action1可以将 onNext(obj) 和 onError(error) 打包起来传入 subscribe() 以实现不完整定义的回调。事实上,虽然 Action0 和 Action1在 API 中使用最广泛,但 RxJava 是提供了多个 ActionX 形式的接口 (例如 Action2, Action3) 的,它们可以被用以包装不同的无返回值的方法。

[java]view plaincopy

4) 场景示例

Observable.from(folders)

下面举两个例子:

.flatMap((Func1) (folder) -> { Observable.from(file.listFiles()) })

为了把原理用更清晰的方式表述出来,本文中挑选的都是功能尽可能简单的例子,以至于有些示例代码看起来会有『画蛇添足』『明明不用 RxJava 可以更简便地解决问题』的感觉。当你看到这种情况,不要觉得是因为 RxJava 太啰嗦,而是因为在过早的时候举出真实场景的例子并不利于原理的解析,因此我刻意挑选了简单的情景。

.filter((Func1) (file) -> { file.getName().endsWith(".png") })

a. 打印字符串数组

.map((Func1) (file) -> { getBitmapFromFile(file) })

将字符串数组 names 中的所有字符串依次打印出来:

.subscribeOn(Schedulers.io())

String[] names = ...;Observable.from(names)    .subscribe(new Action1() {        @Override        public void call(String name) {            Log.d(tag, name);        }    });

.observeOn(AndroidSchedulers.mainThread())

b. 由 id 取得图片并显示

.subscribe((Action1) (bitmap) -> { imageCollectorView.addImage(bitmap) });

由指定的一个 drawable 文件 id drawableRes 取得图片,并显示在 ImageView 中,并在出现异常的时候打印 Toast 报错:

不过如果你对Java8还不是很了解的话呢这一段可以暂时忽略,但是你可以移步到这里了解一下Java8:Java8部分新特性介绍

int drawableRes = ...;ImageView imageView = ...;Observable.create(new OnSubscribe() {    @Override    public void call(Subscriber subscriber) {        Drawable drawable = getTheme().getDrawable(drawableRes));        subscriber.onNext(drawable);        subscriber.onCompleted();    }}).subscribe(new Observer() {    @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();    }});

看完代码,是不是有种相见恨晚的冲动?别急,我们来慢慢了解RxJava!

正如上面两个例子这样,创建出 Observable 和 Subscriber ,再用 subscribe() 将它们串起来,一次 RxJava 的基本使用就完成了。非常简单。

前面已经提到他是基于Java观察者设计模式的,这个模式上面有给大家链接,可以去看看,这里不不坐过多的介绍,我们来介绍一下RxJava中的观察者模式:

然而,在 RxJava 的默认规则中,事件的发出和消费都是在同一个线程的。也就是说,如果只用上面的方法,实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是『后台处理,前台回调』的异步机制,因此异步对于 RxJava 是至关重要的。而要实现异步,则需要用到 RxJava 的另一个概念: Scheduler 。

RxJava 的观察者模式

  1. 线程控制 —— Scheduler (一)

一、说明

在不指定线程的情况下, RxJava 遵循的是线程不变的原则,即:在哪个线程调用 subscribe(),就在哪个线程生产事件;在哪个线程生产事件,就在哪个线程消费事件。如果需要切换线程,就需要用到 Scheduler (调度器)。

1)RxJava 有四个基本概念:Observable (可观察者,即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系,从而 Observable 可以在需要的时候发出事件来通知 Observer。

1) Scheduler 的 API (一)

2)与传统观察者模式不同, RxJava 的事件回调方法除了普通事件 onNext() (相当于 onClick() / onEvent())之外,还定义了两个特殊的事件:onCompleted() 和 onError()。

在RxJava 中,Scheduler ——调度器,相当于线程控制器,RxJava 通过它来指定每一段代码应该运行在什么样的线程。RxJava 已经内置了几个 Scheduler ,它们已经适合大多数的使用场景:

3)onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理,还会把它们看做一个队列。RxJava 规定,当不会再有新的 onNext() 发出时,需要触发 onCompleted() 方法作为标志。

Schedulers.immediate(): 直接在当前线程运行,相当于不指定线程。这是默认的 Scheduler。

4)onError(): 事件队列异常。在事件处理过程中出异常时,onError() 会被触发,同时队列自动终止,不允许再有事件发出。

Schedulers.newThread(): 总是启用新线程,并在新线程执行操作。

5)在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个,并且是事件序列中的最后一个。需要注意的是,onCompleted() 和 onError() 二者也是互斥的,即在队列中调用了其中一个,就不应该再调用另一个。

Schedulers.io(): I/O 操作(读写文件、读写数据库、网络信息交互等)所使用的 Scheduler。行为模式和 newThread() 差不多,区别在于 io() 的内部实现是是用一个无数量上限的线程池,可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中,可以避免创建不必要的线程。

二、实现

Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算,即不会被 I/O 等操作限制性能的操作,例如图形的计算。这个 Scheduler 使用的固定的线程池,大小为 CPU 核数。不要把 I/O 操作放在 computation() 中,否则 I/O 操作的等待时间会浪费 CPU。

1) 创建 Observer

另外, Android 还有一个专用的 AndroidSchedulers.mainThread(),它指定的操作将在 Android 主线程运行。

Observer 即观察者,它决定事件触发的时候将有怎样的行为。 RxJava 中的 Observer 接口的实现方式:

有了这几个 Scheduler ,就可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。 * subscribeOn(): 指定 subscribe() 所发生的线程,即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。 * observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。

[java]view plaincopy

文字叙述总归难理解,上代码:

Observer observer =newObserver() {

Observable.just(1, 2, 3, 4)    .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程    .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程    .subscribe(new Action1() {        @Override        public void call(Integer number) {            Log.d(tag, "number:" + number);        }    });

@Override

上面这段代码中,由于 subscribeOn(Schedulers.io()) 的指定,被创建的事件的内容 1、2、3、4 将会在 IO 线程发出;而由于 observeOn(AndroidScheculers.mainThread()) 的指定,因此 subscriber 数字的打印将发生在主线程 。事实上,这种在 subscribe() 之前写上两句 subscribeOn(Scheduler.io()) 和 observeOn(AndroidSchedulers.mainThread()) 的使用方式非常常见,它适用于多数的 『后台线程取数据,主线程显示』的程序策略。

publicvoidonNext(String s) {

而前面提到的由图片 id 取得图片并显示的例子,如果也加上这两句:

Log.d(tag,"Item: "+ s);

int drawableRes = ...;ImageView imageView = ...;Observable.create(new OnSubscribe() {    @Override    public void call(Subscriber subscriber) {        Drawable drawable = getTheme().getDrawable(drawableRes));        subscriber.onNext(drawable);        subscriber.onCompleted();    }}).subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程.observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程.subscribe(new Observer() {    @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();    }});

}

那么,加载图片将会发生在 IO 线程,而设置图片则被设定在了主线程。这就意味着,即使加载图片耗费了几十甚至几百毫秒的时间,也不会造成丝毫界面的卡顿。

@Override

2) Scheduler 的原理 (一)

publicvoidonCompleted() {

RxJava 的 Scheduler API 很方便,也很神奇(加了一句话就把线程切换了,怎么做到的?而且 subscribe() 不是最外层直接调用的方法吗,它竟然也能被指定线程?)。然而 Scheduler 的原理需要放在后面讲,因为它的原理是以下一节《变换》的原理作为基础的。

Log.d(tag,"Completed!");

好吧这一节其实我屁也没说,只是为了让你安心,让你知道我不是忘了讲原理,而是把它放在了更合适的地方。

}

  1. 变换

@Override

终于要到牛逼的地方了,不管你激动不激动,反正我是激动了。

publicvoidonError(Throwable e) {

RxJava 提供了对事件序列进行变换的支持,这是它的核心功能之一,也是大多数人说『RxJava 真是太好用了』的最大原因。所谓变换,就是将事件序列中的对象或整个序列进行加工处理,转换成不同的事件或事件序列。概念说着总是模糊难懂的,来看 API。

Log.d(tag,"Error!");

1) API

}

首先看一个 map() 的例子:

};

Observable.just("images/logo.png") // 输入类型 String    .map(new Func1() {        @Override        public Bitmap call(String filePath) { // 参数类型 String            return getBitmapFromPath(filePath); // 返回类型 Bitmap        }    })    .subscribe(new Action1() {        @Override        public void call(Bitmap bitmap) { // 参数类型 Bitmap            showBitmap(bitmap);        }    });

除了 Observer 接口之外,RxJava 还内置了一个实现了 Observer 的抽象类:Subscriber。 Subscriber 对 Observer 接口进行了一些扩展,但他们的基本使用方式是完全一样的:

这里出现了一个叫做 Func1 的类。它和 Action1 非常相似,也是 RxJava 的一个接口,用于包装含有一个参数的方法。 Func1 和 Action 的区别在于, Func1 包装的是有返回值的方法。另外,和 ActionX 一样, FuncX 也有多个,用于不同参数个数的方法。FuncX和 ActionX 的区别在 FuncX 包装的是有返回值的方法。

[java]view plaincopy

可以看到,map() 方法将参数中的 String 对象转换成一个 Bitmap 对象后返回,而在经过 map() 方法后,事件的参数类型也由 String转为了 Bitmap。这种直接变换对象并返回的,是最常见的也最容易理解的变换。不过 RxJava 的变换远不止这样,它不仅可以针对事件对象,还可以针对整个事件队列,这使得 RxJava 变得非常灵活。我列举几个常用的变换:

Subscriber subscriber =newSubscriber() {

map(): 事件对象的直接变换,具体功能上面已经介绍过。它是 RxJava 最常用的变换。 map() 的示意图:

@Override

美高梅开户送58元官网 4

publicvoidonNext(String s) {

flatMap(): 这是一个很有用但非常难理解的变换,因此我决定花多些篇幅来介绍它。 首先假设这么一种需求:假设有一个数据结构『学生』,现在需要打印出一组学生的名字。实现方式很简单:

Log.d(tag,"Item: "+ s);

Student[] students = ...;Subscriber subscriber = new Subscriber() {    @Override    public void onNext(String name) {        Log.d(tag, name);    }    ...};Observable.from(students)    .map(new Func1() {        @Override        public String call(Student student) {            return student.getName();        }    })    .subscribe(subscriber);

}

很简单。那么再假设:如果要打印出每个学生所需要修的所有课程的名称呢?(需求的区别在于,每个学生只有一个名字,但却有多个课程。)首先可以这样实现:

@Override

Student[] students = ...;Subscriber subscriber = new Subscriber() {    @Override    public void onNext(Student student) {        List courses = student.getCourses();        for (int i = 0; i < courses.size(); i++) {            Course course = courses.get(i);            Log.d(tag, course.getName());        }    }    ...};Observable.from(students)    .subscribe(subscriber);

publicvoidonCompleted() {

依然很简单。那么如果我不想在 Subscriber 中使用 for 循环,而是希望 Subscriber 中直接传入单个的 Course 对象呢(这对于代码复用很重要)?用 map() 显然是不行的,因为 map() 是一对一的转化,而我现在的要求是一对多的转化。那怎么才能把一个 Student 转化成多个 Course 呢?

Log.d(tag,"Completed!");

这个时候,就需要用 flatMap() 了:

}

Student[] students = ...;Subscriber subscriber = new Subscriber() {    @Override    public void onNext(Course course) {        Log.d(tag, course.getName());    }    ...};Observable.from(students)    .flatMap(new Func1>() {        @Override        public Observable call(Student student) {            return Observable.from(student.getCourses());        }    })    .subscribe(subscriber);

@Override

从上面的代码可以看出, flatMap() 和 map() 有一个相同点:它也是把传入的参数转化之后返回另一个对象。但需要注意,和 map()不同的是, flatMap() 中返回的是个 Observable 对象,并且这个 Observable 对象并不是被直接发送到了 Subscriber 的回调方法中。 flatMap() 的原理是这样的:1. 使用传入的事件对象创建一个 Observable 对象;2. 并不发送这个 Observable, 而是将它激活,于是它开始发送事件;3. 每一个创建出来的 Observable 发送的事件,都被汇入同一个 Observable ,而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。这三个步骤,把事件拆成了两级,通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径分发了下去。而这个『铺平』就是 flatMap() 所谓的 flat。

publicvoidonError(Throwable e) {

flatMap() 示意图:

Log.d(tag,"Error!");

美高梅开户送58元官网 5

}

扩展:由于可以在嵌套的 Observable 中添加异步代码, flatMap() 也常用于嵌套的异步操作,例如嵌套的网络请求。示例代码(Retrofit

};

  • RxJava):

不仅基本使用方式一样,实质上,在 RxJava 的 subscribe 过程中,Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能,选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点:

networkClient.token() // 返回 Observable,在订阅时请求 token,并在响应后发送 token    .flatMap(new Func1>() {        @Override        public Observable call(String token) {            // 返回 Observable,在订阅时请求消息列表,并在响应后发送请求到的消息列表            return networkClient.messages();        }    })    .subscribe(new Action1() {        @Override        public void call(Messages messages) {            // 处理显示消息列表            showMessages(messages);        }    });

onStart():这是 Subscriber 增加的方法。它会在 subscribe 刚开始,而事件还未发送之前被调用,可以用于做一些准备工作,例如数据的清零或重置。这是一个可选方法,默认情况下它的实现为空。需要注意的是,如果对准备工作的线程有要求(例如弹出一个显示进度的对话框,这必须在主线程执行), onStart() 就不适用了,因为它总是在 subscribe 所发生的线程被调用,而不能指定线程。要在指定的线程来做准备工作,可以使用 doOnSubscribe() 方法,具体可以在后面的文中看到。

传统的嵌套请求需要使用嵌套的 Callback 来实现。而通过 flatMap() ,可以把嵌套的请求写在一条链中,从而保持程序逻辑的清晰。

unsubscribe():这是 Subscriber 所实现的另一个接口 Subscription 的方法,用于取消订阅。在这个方法被调用后,Subscriber 将不再接收事件。一般在这个方法调用前,可以使用 isUnsubscribed() 先判断一下状态。 unsubscribe() 这个方法很重要,因为在 subscribe() 之后, Observable 会持有 Subscriber 的引用,这个引用如果不能及时被释放,将有内存泄露的风险。所以最好保持一个原则:要在不再使用的时候尽快在合适的地方(例如 onPause() onStop() 等方法中)调用 unsubscribe() 来解除引用关系,以避免内存泄露的发生。

throttleFirst(): 在每次事件触发后的一定时间间隔内丢弃新的事件。常用作去抖动过滤,例如按钮的点击监听器:RxView.clickEvents(button) // RxBinding 代码,后面的文章有解释 .throttleFirst(500, TimeUnit.MILLISECONDS) // 设置防抖间隔为 500ms .subscribe(subscriber);妈妈再也不怕我的用户手抖点开两个重复的界面啦。

2) 创建 Observable

此外, RxJava 还提供很多便捷的方法来实现事件序列的变换,这里就不一一举例了。

Observable 即被观察者,它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create() 方法来创建一个 Observable ,并为它定义事件触发规则:

2) 变换的原理:lift()

[java]view plaincopy

这些变换虽然功能各有不同,但实质上都是针对事件序列的处理和再发送。而在 RxJava 的内部,它们是基于同一个基础的变换方法: lift(Operator)。首先看一下 lift() 的内部实现(仅核心代码):

Observable observable = Observable.create(newObservable.OnSubscribe() {

// 注意:这不是 lift() 的源码,而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。// 如果需要看源码,可以去 RxJava 的 GitHub 仓库下载。public Observable lift(Operator operator) {    return Observable.create(new OnSubscribe() {        @Override        public void call(Subscriber subscriber) {            Subscriber newSubscriber = operator.call(subscriber);            newSubscriber.onStart();            onSubscribe.call(newSubscriber);        }    });}

@Override

这段代码很有意思:它生成了一个新的 Observable 并返回,而且创建新 Observable 所用的参数 OnSubscribe 的回调方法 call() 中的实现竟然看起来和前面讲过的 Observable.subscribe() 一样!然而它们并不一样哟~不一样的地方关键就在于第二行 onSubscribe.call(subscriber) 中的 onSubscribe 所指代的对象不同(高能预警:接下来的几句话可能会导致身体的严重不适)——

publicvoidcall(Subscriber subscriber) {

subscribe() 中这句话的 onSubscribe 指的是 Observable 中的 onSubscribe 对象,这个没有问题,但是 lift() 之后的情况就复杂了点。

subscriber.onNext("Hello");

当含有 lift() 时: 

subscriber.onNext("Hi");

1.lift() 创建了一个 Observable 后,加上之前的原始 Observable,已经有两个 Observable 了; 

subscriber.onNext("Aloha");

2.而同样地,新 Observable 里的新 OnSubscribe 加上之前的原始 Observable 中的原始 OnSubscribe,也就有了两个 OnSubscribe; 

subscriber.onCompleted();

3.当用户调用经过 lift() 后的 Observable 的 subscribe() 的时候,使用的是 lift() 所返回的新的 Observable ,于是它所触发的 onSubscribe.call(subscriber),也是用的新 Observable 中的新 OnSubscribe,即在 lift() 中生成的那个 OnSubscribe; 

}

4.而这个新 OnSubscribe 的 call() 方法中的 onSubscribe ,就是指的原始 Observable 中的原始 OnSubscribe ,在这个 call()方法里,新 OnSubscribe 利用 operator.call(subscriber) 生成了一个新的 Subscriber(Operator 就是在这里,通过自己的 call() 方法将新 Subscriber 和原始 Subscriber 进行关联,并插入自己的『变换』代码以实现变换),然后利用这个新 Subscriber 向原始 Observable 进行订阅。 

});

这样就实现了 lift() 过程,有点像一种代理机制,通过事件拦截和处理实现事件序列的变换。

可以看到,这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中,它的作用相当于一个计划表,当 Observable 被订阅的时候,OnSubscribe 的 call() 方法会自动被调用,事件序列就会依照设定依次触发(对于上面的代码,就是观察者Subscriber 将会被调用三次 onNext() 和一次 onCompleted())。这样,由被观察者调用了观察者的回调方法,就实现了由被观察者向观察者的事件传递,即观察者模式

精简掉细节的话,也可以这么说:在 Observable 执行了 lift(Operator) 方法之后,会返回一个新的 Observable,这个新的 Observable 会像一个代理一样,负责接收原始的 Observable 发出的事件,并在处理后发送给 Subscriber。

create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法, RxJava 还提供了一些方法用来快捷创建事件队列,例如:

如果你更喜欢具象思维,可以看图:

just(T...): 将传入的参数依次发送出来。

美高梅开户送58元官网 6

[java]view plaincopy

两次和多次的 lift() 同理,如下图:

Observable observable = Observable.just("Hello","Hi","Aloha");

美高梅开户送58元官网 7

// 将会依次调用:

举一个具体的 Operator 的实现。下面这是一个将事件中的 Integer 对象转换成 String 的例子,仅供参考:

// onNext("Hello");

observable.lift(new Observable.Operator() {    @Override    public Subscriber call(final Subscriber subscriber) {        // 将事件序列中的 Integer 对象转换为 String 对象        return new Subscriber() {            @Override            public void onNext(Integer integer) {                subscriber.onNext("" + integer);            }            @Override            public void onCompleted() {                subscriber.onCompleted();            }            @Override            public void onError(Throwable e) {                subscriber.onError(e);            }        };    }});

// onNext("Hi");

讲述 lift() 的原理只是为了让你更好地了解 RxJava ,从而可以更好地使用它。然而不管你是否理解了 lift() 的原理,RxJava 都不建议开发者自定义 Operator 来直接使用 lift(),而是建议尽量使用已有的 lift() 包装方法(如 map() flatMap() 等)进行组合来实现需求,因为直接使用 lift() 非常容易发生一些难以发现的错误。

// onNext("Aloha");

3) compose: 对 Observable 整体的变换

// onCompleted();

除了 lift() 之外, Observable 还有一个变换方法叫做 compose(Transformer)。它和 lift() 的区别在于, lift() 是针对事件项和事件序列的,而 compose() 是针对 Observable 自身进行变换。举个例子,假设在程序中有多个 Observable ,并且他们都需要应用一组相同的 lift() 变换。你可以这么写:

from(T[]) / from(Iterable) : 将传入的数组或 Iterable 拆分成具体对象后,依次发送出来。

observable1

[java]view plaincopy

    .lift1()    .lift2()    .lift3()    .lift4()    .subscribe(subscriber1);observable2

String[] words = {"Hello","Hi","Aloha"};

    .lift1()    .lift2()    .lift3()    .lift4()    .subscribe(subscriber2);observable3

Observable observable = Observable.from(words);

    .lift1()    .lift2()    .lift3()    .lift4()    .subscribe(subscriber3);observable4

// 将会依次调用:

    .lift1()    .lift2()    .lift3()    .lift4()    .subscribe(subscriber1);

// onNext("Hello");

你觉得这样太不软件工程了,于是你改成了这样:

// onNext("Hi");

private Observable liftAll(Observable observable) {    return observable

// onNext("Aloha");

        .lift1()        .lift2()        .lift3()        .lift4();}...liftAll(observable1).subscribe(subscriber1);liftAll(observable2).subscribe(subscriber2);liftAll(observable3).subscribe(subscriber3);liftAll(observable4).subscribe(subscriber4);

// onCompleted();

可读性、可维护性都提高了。可是 Observable 被一个方法包起来,这种方式对于 Observale 的灵活性似乎还是增添了那么点限制。怎么办?这个时候,就应该用 compose() 来解决了:

上面 just(T...) 的例子和 from(T[]) 的例子,都和之前的 create(OnSubscribe) 的例子是等价的。

public class LiftAllTransformer implements Observable.Transformer {    @Override    public Observable call(Observable observable) {        return observable

3) Subscribe (订阅)

            .lift1()            .lift2()            .lift3()            .lift4();    }}...Transformer liftAll = new LiftAllTransformer();observable1.compose(liftAll).subscribe(subscriber1);observable2.compose(liftAll).subscribe(subscriber2);observable3.compose(liftAll).subscribe(subscriber3);observable4.compose(liftAll).subscribe(subscriber4);

创建了 Observable 和 Observer 之后,再用 subscribe() 方法将它们联结起来,整条链子就可以工作了。代码形式很简单:

像上面这样,使用 compose() 方法,Observable 可以利用传入的 Transformer 对象的 call 方法直接对自身进行处理,也就不必被包在方法的里面了。

[java]view plaincopy

compose() 的原理比较简单,不附图喽。

observable.subscribe(observer);

  1. 线程控制:Scheduler (二)

// 或者:

除了灵活的变换,RxJava 另一个牛逼的地方,就是线程的自由控制。

observable.subscribe(subscriber);

1) Scheduler 的 API (二)

Observable.subscribe(Subscriber) 的内部实现是这样的(仅核心代码):

前面讲到了,可以利用 subscribeOn() 结合 observeOn() 来实现线程控制,让事件的产生和消费发生在不同的线程。可是在了解了 map() flatMap() 等变换方法后,有些好事的(其实就是当初刚接触 RxJava 时的我)就问了:能不能多切换几次线程?

[java]view plaincopy

答案是:能。因为 observeOn() 指定的是 Subscriber 的线程,而这个 Subscriber 并不是(严格说应该为『不一定是』,但这里不妨理解为『不是』)subscribe() 参数中的 Subscriber ,而是 observeOn() 执行时的当前 Observable 所对应的 Subscriber ,即它的直接下级 Subscriber 。换句话说,observeOn() 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求,只要在每个想要切换线程的位置调用一次 observeOn() 即可。上代码:

// 注意:这不是 subscribe() 的源码,而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。

Observable.just(1, 2, 3, 4) // IO 线程,由 subscribeOn() 指定    .subscribeOn(Schedulers.io())    .observeOn(Schedulers.newThread())    .map(mapOperator) // 新线程,由 observeOn() 指定    .observeOn(Schedulers.io())    .map(mapOperator2) // IO 线程,由 observeOn() 指定    .observeOn(AndroidSchedulers.mainThread)

// 如果需要看源码,可以去 RxJava 的 GitHub 仓库下载。

    .subscribe(subscriber);  // Android 主线程,由 observeOn() 指定

publicSubscription subscribe(Subscriber subscriber) {

如上,通过 observeOn() 的多次调用,程序实现了线程的多次切换。

subscriber.onStart();

不过,不同于 observeOn() , subscribeOn() 的位置放在哪里都可以,但它是只能调用一次的。

onSubscribe.call(subscriber);

又有好事的(其实还是当初的我)问了:如果我非要调用多次 subscribeOn() 呢?会有什么效果?

returnsubscriber;

这个问题先放着,我们还是从 RxJava 线程控制的原理说起吧。

}

2) Scheduler 的原理(二)

可以看到,subscriber() 做了3件事:

其实, subscribeOn() 和 observeOn() 的内部实现,也是用的 lift()。具体看图(不同颜色的箭头表示不同的线程):

1.调用 Subscriber.onStart() 。这个方法在前面已经介绍过,是一个可选的准备方法。

subscribeOn() 原理图:

2.调用 Observable 中的 OnSubscribe.call(Subscriber) 。在这里,事件发送的逻辑开始运行。从这也可以看出,在 RxJava 中, Observable 并不是在创建的时候就立即开始发送事件,而是在它被订阅的时候,即当 subscribe() 方法执行的时候。

美高梅开户送58元官网 8

3.将传入的 Subscriber 作为 Subscription 返回。这是为了方便 unsubscribe().

observeOn() 原理图:

除了 subscribe(Observer) 和 subscribe(Subscriber) ,subscribe() 还支持不完整定义的回调,RxJava 会自动根据定义创建出 Subscriber 。形式如下:

美高梅开户送58元官网 9

[java]view plaincopy

从图中可以看出,subscribeOn() 和 observeOn() 都做了线程切换的工作(图中的 "schedule..." 部位)。不同的是, subscribeOn()的线程切换发生在 OnSubscribe 中,即在它通知上一级 OnSubscribe 时,这时事件还没有开始发送,因此 subscribeOn() 的线程控制可以从事件发出的开端就造成影响;而 observeOn() 的线程切换则发生在它内建的 Subscriber 中,即发生在它即将给下一级 Subscriber 发送事件时,因此 observeOn() 控制的是它后面的线程。

Action1 onNextAction =newAction1() {

最后,我用一张图来解释当多个 subscribeOn() 和 observeOn() 混合使用时,线程调度是怎么发生的(由于图中对象较多,相对于上面的图对结构做了一些简化调整):

// onNext()

版权声明:本文由美高梅开户送58元官网发布于美高梅开户送58元官网,转载请注明出处:美高梅开户送58元官网:需要传递一个 OnSubscrib