目录

1．计算一段时间内的平均值

2．优化搜索联想功能

3．优化多次重复点击

4．RxJava + Retrofit + OkHttp

5．页面轮询请求

6．接口重新请求（retry）

7．本地验证输入有效性

8．优先加载本地缓存，再读取网络数据

方案一：concat

方案二：concatEager

方案三：merge

方案四：publish + merge

9．网络请求中发现token过期后刷新token并重新发起请求

1．Token缓存（SharedPreferences）

2．判断是否失效

3．Observable

4．retryWhen

5．map

6．TokenLoader

7．场景模拟

10．屏幕旋转导致Activity重建时恢复任务

1．Android屏幕旋转处理方式

（1）禁止旋转

（2）旋转后恢复现场（官方推荐）

（3）手工处理旋转（官方不推荐）

2．RxJava实现Activity重建时恢复任务

（1）定义一套Fragment与Activity通讯的接口

（2）定义任务Fragment：WorkerFragment

（3）模拟一个旋转屏幕需要销毁重建的Activity（实现Iholder接口）

11．网络重连自动请求

1．定位模块

2．网络状态模块

3．整合上述两个触发条件，并实现网络请求逻辑

12．模拟60秒发送验证码

1．计算一段时间内的平均值

应用场景：不定期产生一些数值，需要计算固定一段时间内的平均值

（1）Observable 模拟了按随机时间发送数据值的场景。

（2）buffer(200,TimeUnit.MILLISECONDS) 把一段时间（200s）发送的数据值收集起来，生成一个List发送给Consumer，Consumer收到后计算出平均值。

Observable.create(new ObservableOnSubscribe<Integer>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<Integer> e) throws Throwable {e.onNext(1);Thread.sleep(50);e.onNext(2);Thread.sleep(90);e.onNext(3);Thread.sleep(60);e.onNext(4);Thread.sleep(70);}
}).buffer(200,TimeUnit.MILLISECONDS).subscribe(new Consumer<List<Integer>>() {@Overridepublic void accept(List<Integer> integers) throws Throwable {if(integers.size() <= 0) {return;}int result = 0;for(Integer i : integers) {result += i;}Log.i("avg","avg = " + result / integers.size());}
});

2．优化搜索联想功能

搜索联想：每当搜索框中输入的key发生变化，随即返回相应的搜索结果并展示。

优化项：

（1）连续输入引发的不必要请求。用户输入abc，App会连续发起三次关键字搜索request：a，ab，abc

（2）连续request，返回乱序。（1）场景下无法保证response按照a，ab，abc顺序返回，导致实际搜索结果错误。

解决方案：

按照上述场景，实际需要请求的是abc，即输入的最后结果key！

（1）debounce操作符，当输入框发生变化时，不会立刻将事件发送给下游，而是等待500ms，如果在这段事件内，输入框没有发生变化，那么才发送该事件；反之，则在收到新的关键词后，继续等待500ms。

（2）filter操作符，只有关键词的长度大于0时才发送事件给Observer。

（3）switchMap操作符，即便当ab、abc都触发request，即使ab的结果返回了，也不会发送给Observer，从而避免了出现前面介绍的搜索词和联想结果不匹配的问题。

RxTextView.textChanges(editText)// 表示延时多少秒后执行，当你敲完字之后停下来的半秒就会执行下面语句.debounce(500, TimeUnit.MILLISECONDS)// 只有关键词的长度大于0时才发送事件给Observer.filter(new Predicate<CharSequence>() {@Overridepublic boolean test(CharSequence charSequence) throws Exception {return charSequence != null && charSequence.length() > 0;}})// 数据转换 flatMap: 当同时多个数据请求访问的时候，前面的网络数据会覆盖后面的网络数据// 数据转换 switchMap: 当同时多个网络请求访问的时候，会以最后一个发送请求为准，前面网络数据会被最后一个覆盖.switchMap(new Function<CharSequence, ObservableSource<List<String>>>() {@Overridepublic ObservableSource<List<String>> apply(@NonNull CharSequence charSequence) throws Exception {// 网络请求操作，获取我们需要的数据List<String> list = new ArrayList<String>();list.add("2017");list.add("2018");return Observable.just(list);}}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe();

3．优化多次重复点击

场景：用户多次点击，造成重复请求。

RxView.clicks(button).throttleFirst(1, TimeUnit.SECONDS).subscribe(new Observer<Object>() {@Overridepublic void onSubscribe(Disposable d) {}@Overridepublic void onNext(Object o) {Log.i("JAVA", "onClick");}@Overridepublic void onError(Throwable e) {}@Overridepublic void onComplete() {}});

4．RxJava + Retrofit + OkHttp

参见Retrofit相关资料

5．页面轮询请求

interval操作符：固定延时请求，每隔n秒请求一次。

Observable// 每间隔10s轮询一次.interval(10, TimeUnit.SECONDS)// 防止由于Activity已经销毁，但Observable依然在发送数据导致的内存泄漏.takeWhile(new Predicate<Long>() {@Overridepublic boolean test(Long aLong) throws Exception {// 用于中断interval的发送，当Activity在 onDestory / onPause等方法 设置 needRefresh 为 false时，Observable将停止发送数据return needReFresh;}}).subscribeOn(Schedulers.computation()).observeOn(Schedulers.io()).map(new Function<Long, String>() {@Overridepublic String apply(Long aLong) throws Exception {// 发送网络请求，获取结果return null;}}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<String>() {@Overridepublic void onSubscribe(Disposable d) {}@Overridepublic void onNext(String string) {// update UI}@Overridepublic void onError(Throwable e) {}@Overridepublic void onComplete() {}});

扩展：也可以用repeat，repeatWhen实现。

6．接口重新请求（retry）

应用场景：

1．规定重试次数

2．规定重试条件，什么条件下需要重试，什么条件下不需要重试，重试的时间、方式等

解决方案：

retryWhen + flatMap

// 用于在UI线程结束前，清空订阅对象，防止内存溢出final CompositeDisposable mCompositeDisposable = new CompositeDisposable();
final String ERROR_CODE1 = "error_code1";
final String ERROR_CODE2 = "error_code2";
final int apiMaxRetryCount = 4;
Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<String> e) throws Throwable {// doNetWorkString result = doNetWork();// 模拟失败if (null == result) {e.onError(new Throwable(ERROR_CODE1));} else {// 模拟成功e.onNext(result);e.onComplete();}}
}).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {private int retryCount = -1;private long retryWaitingTime = 0;@Overridepublic ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Throwable {// 根据Throwable类型，实现不同的重试策略（是否重试，重试延时，重试次数）return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(Throwable throwable) throws Throwable {// throwable为空属于异常情况，不做重试，直接结束if (null == throwable) {return Observable.error((throwable));}switch (throwable.getMessage()) {case ERROR_CODE1:// ERROR_CODE1，延时1000s后重试retryWaitingTime = 1000;break;case ERROR_CODE2:// ERROR_CODE2，延时2000s后重试retryWaitingTime = 2000;break;default:break;}retryCount++;// 控制重试次数小于允许的最大重试次数；否则返回error，调用Observer的onError，结束本次请求return retryWaitingTime > -1 && retryCount < apiMaxRetryCount ?Observable.timer(retryWaitingTime, TimeUnit.SECONDS): Observable.error(throwable);}});}
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<String>() {@Overridepublic void onSubscribe(@NonNull Disposable d) {mCompositeDisposable.add(d);}@Overridepublic void onNext(@NonNull String s) {// 接收正常请求结果，更新UI}@Overridepublic void onError(@NonNull Throwable e) {// 处理异常情况}@Overridepublic void onComplete() {}});

7．本地验证输入有效性

模拟场景：用户名、密码登录。长度要求分别为 2-8 和 4-16。如果两者都正确，“登录”恢复可点击，否则置灰不可点击

final CompositeDisposable compositeDisposable = new CompositeDisposable();PublishSubject<String> userNamePublisher = PublishSubject.create();
PublishSubject<String> userPasswordPublisher = PublishSubject.create();
userNameEdit.addTextChangedListener(new EditTextMonitor(userNamePublisher));
passwordEdit.addTextChangedListener(new EditTextMonitor(userPasswordPublisher));
Observable.combineLatest(userNamePublisher, userPasswordPublisher, new BiFunction<String, String, Boolean>() {@Overridepublic Boolean apply(String name, String password) {if (null == name || null == password) {return false;}return name.length() >= 2 && name.length() <= 8 && password.length() >= 4 && password.length() <= 16;}
}).subscribe(new Observer<Boolean>() {@Overridepublic void onSubscribe(@NonNull Disposable d) {compositeDisposable.add(d);}@Overridepublic void onNext(@NonNull Boolean aBoolean) {// update UI}@Overridepublic void onError(@NonNull Throwable e) { }@Overridepublic void onComplete() { }
});

首先创建两个PublishSubject，用于对用户名、密码输入框的订阅，通过重写TextWatcher，实现在afterTextChanged(Editable editable) 触发时，使用PublishSubject把输入框结果值发送出去publishSubject.onNext(editable.toString().trim());

然后通过combineLatest操作符对两个PublishSubject进行组合，当任何一个PublishSubject发送数据时，都会回调代码中的apply方法，对两个PublishSubject最后一次发送的数据进行校验。

8．优先加载本地缓存，再读取网络数据

实现逻辑：同时发起读取缓存、访问网络的请求，如果缓存的数据先回来，那么就先展示缓存的数据，而如果网络的数据先回来，那么就不再展示缓存的数据。

定义读取缓存并发送结果的Observable：

private Observable<List<String>> getFromCache(final long needTime) {return Observable.create(new ObservableOnSubscribe<List<String>>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<List<String>> emitter) {try {// get data from cacheLog.d("TAG", "开始加载本地缓存");// 模拟读取缓存时长Thread.sleep(needTime);List<String> cacheData = new ArrayList<>();emitter.onNext(cacheData);emitter.onComplete();Log.d("TAG", "结束加载本地缓存");} catch (Exception e) {emitter.onError(e);}}});
}

定义读取网络数据并发送结果的Observable

private Observable<List<String>> getFromNetwork(final long needTime) {return Observable.create(new ObservableOnSubscribe<List<String>>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<List<String>> emitter) {try {// get data from networkLog.d("TAG", "开始请求网络数据");// 模拟网络请求时长Thread.sleep(needTime);List<String> networkData = new ArrayList<>();emitter.onNext(networkData);emitter.onComplete();Log.d("TAG", "结束请求网络数据");} catch (Exception e) {emitter.onError(e);}}});
}

定义获取最新数据并更新UI adapter的Observer

private List<String> data = new ArrayList<>();private DisposableObserver<List<String>> getArticleObserver() {return new DisposableObserver<List<String>>() {@Overridepublic void onNext(List<String> newsResultEntities) {Log.d("TAG", "展示数据");data.clear();data.addAll(newsResultEntities);mNewsAdapter.notifyDataSetChanged();}@Overridepublic void onError(Throwable throwable) {Log.d("TAG", "加载错误, e=" + throwable);}@Overridepublic void onComplete() {Log.d("TAG", "加载完成");}};
}

方案一：concat

Observable.concat (getFromCache(500).subscribeOn(Schedulers.io()),getFromNetwork(2000).subscribeOn(Schedulers.io())).observeOn(AndroidSchedulers.mainThread()).subscribe(getArticleObserver());

假设读取缓存需要500ms，获取网路数据需要2000ms，concat操作符标准地按序先获取缓存，再读取网络数据，总共耗时2500ms。执行逻辑清晰，但两种操作无法同时发起。

Log：

开始加载本地缓存

展示数据 – cache

结束加载本地缓存

开始请求网路数据

展示数据 – network

结束请求网络数据

加载完成

方案二：concatEager

List<Observable<List<String>>> observables = new ArrayList<>();observables.add(getFromCache(500).subscribeOn(Schedulers.io()));
observables.add(getFromNetwork(2000).subscribeOn(Schedulers.io()));
Observable.concatEager(observables).observeOn(AndroidSchedulers.mainThread()).subscribe(getArticleObserver());

与concat最大的不同就是多个Observable可以同时开始发送数据，如果后一个Observable发送完成后，前一个Observable还有发送完数据，那么它会将后一个Observable的数据先缓存起来，等到前一个Observable发送完毕后，才将缓存的数据发送出去。

Log：

开始加载本地缓存

开始请求网路数据

结束加载本地缓存

展示数据 – cache

结束请求网络数据

展示数据 – network

加载完成

如果把两个时间对调一下：读取缓存时间2000ms，网络请求时间500ms，会出现“network data”等待“cache data”完成展示后才能发送给Observer，因为最终会以网络数据为准，所以中间浪费了1500ms

Log：

开始加载本地缓存

开始请求网路数据

结束请求网络数据

结束加载本地缓存

展示数据 – cache

展示数据 – network

加载完成

方案三：merge

Observable.merge (getFromCache(500).subscribeOn(Schedulers.io()),getFromNetwork(2000).subscribeOn(Schedulers.io())).observeOn(AndroidSchedulers.mainThread()).subscribe(getArticleObserver());

merge操作符合并Observable集合后会产生乱序，当 读取缓存时间 > 网络请求时间，merge符合要求；但当 读取缓存时间 ＜ 网络请求时间，界面会先展示网络数据，之后又被缓存数据刷了一遍。

方案四：publish + merge

getFromNetwork(2000).subscribeOn(Schedulers.io()).publish(new Function<Observable<List<String>>, ObservableSource<List<String>>>() {@Overridepublic ObservableSource<List<String>> apply(Observable<List<String>> network) {return Observable.merge(network, getFromCache(500).subscribeOn(Schedulers.io()).takeUntil(network));}}).observeOn(AndroidSchedulers.mainThread()).subscribe(getArticleObserver());

Log：网络请求时间（2000ms） > 读取缓存时间（500ms）

开始加载本地缓存

开始请求网路数据

展示数据 – cache

结束加载本地缓存

结束请求网络数据

展示数据 – network

加载完成

Log：网络请求时间（500ms） ＜ 读取缓存时间（2000ms）

开始加载本地缓存

开始请求网路数据

展示数据 – network

结束请求网络数据

加载完成

扩展问题：

如果网络请求失败，返回error，将导致后面的缓存数据也无法加载的问题，针对这个问题，把获取网络数据的Observable做一下加工，让它主动屏蔽掉network所造成的error，或者把error进行业务逻辑转换，再通过onNext传递给Observer让页面展示提示语。

上述问题通过 onErrorResumeNext实现：

return Observable.create(new ObservableOnSubscribe<List<String>>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<List<String>> emitter) {try {// get data from networkLog.d("TAG", "开始请求网络数据");// 模拟网络请求时长Thread.sleep(needTime);List<String> networkData = new ArrayList<>();networkData.add("network");emitter.onNext(networkData);emitter.onComplete();Log.d("TAG", "结束请求网络数据");// 异常情况emitter.onError(new Throwable("network error"));} catch (Exception e) {emitter.onError(e);}}
}).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends List<String>>>() {@Overridepublic ObservableSource<? extends List<String>> apply(Throwable throwable) throws Exception {// 返回一个永远不发送事件的Observable；从而阻止network error传递给UI Observerreturn Observable.never();}
});

原理解析：

1．takeUntil解决了只要网络源数据开始发送，缓存就不再发送数据 的需求，针对concatEager在获取网络时间 ＜ 读取缓存时间时，网络数据要等待缓存数据加载并显示完之后才能显示的问题。

2．merge的作用满足了两个操作同时进行的需求。

3．publish

上面代码中merge和takeUntil结合使用会发生两次订阅。

publish操作符完美解决了这个问题，它接收一个Function函数，该函数返回一个Observable，该Observable是对原Observable，即获取网络数据的Observable转换之后的结果，该Observable可以被takeUntil和merge操作符所共享，从而实现只订阅一次的效果。

9．网络请求中发现token过期后刷新token并重新发起请求

应用场景：

网络请求中，发现token失效，需要刷新token并重新请求接口。

特殊考虑：

同时有多个Request因Token失效而重复触发刷新Token的情况。如果当前有Request正在刷新Token，则其他Request只需等待Token刷新请求返回后，直接重新发起请求即可。

Token相关处理流程：

1．Token缓存（SharedPreferences）

// 缓存SharedManager.getInstance().setValue(SharedManager.KEY_TOKEN_VALUE, token);// 读取SharedManager.getInstance().getValue(SharedManager.KEY_TOKEN_VALUE, "0");

2．判断是否失效

Demo中token缓存的获取token的时间戳，默认值为0；Demo中token在获取2s后被判定失效。

private boolean isExpires() {String token = getTokenCached();return System.currentTimeMillis() > Long.parseLong(token) + 2000;
}

3．Observable

判定token是否有效，无效刷新token，有效正常执行请求，index模拟request id。

private void startRequest(final int index) {Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<String> emitter) {if (isExpires()) {// 无效：发送Throwable给retryWhen刷新tokenemitter.onError(new Throwable("Token is invalid"));} else {// 有效：发送token给map，正常执行请求emitter.onNext(index + ":" + getTokenCached() + "的用户信息");emitter.onComplete();}}})}

4．retryWhen

接收"Token is invalid"类型的Throwable，刷新token，并触发重订阅，使用最新Token重新执行请求。

Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<String> emitter) {// …..}
}).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(Observable<Throwable> throwableObservable) {return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(Throwable throwable) {if ("Token is invalid".equals(throwable.getMessage())) {Log.d("TAG", index + ":" + "接收Throwable：" + throwable.getMessage() + " 刷新Token");return TokenLoader.getInstance().getNetTokenLocked();} else {// 过滤其他类型的error给下游return Observable.error(throwable);}}});}
})

5．map

模拟正常执行API Request，获取结果后刷新UI

private void startRequest(final int index) {Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<String> emitter) {// …..}}).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(Observable<Throwable> throwableObservable) {return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(Throwable throwable) {// …..}});}}).subscribeOn(Schedulers.io()).observeOn(Schedulers.io()).map(new Function<String, Object>() {@Overridepublic Object apply(String s) {// 模拟执行 API Request，获取Response解析后返回return "Response Data";}}).observeOn(AndroidSchedulers.mainThread()).subscribe(new DisposableObserver<Object>() {@Overridepublic void onNext(@NonNull Object value) {Log.d("TAG", index + ":" + "收到信息=" + value);}@Overridepublic void onError(@NonNull Throwable e) {Log.d("TAG", index + ":" + "onError=" + e);}@Overridepublic void onComplete() {Log.d("TAG", index + ":" + "onComplete");}});
}

6．TokenLoader

TokenLoader采用AtomicBoolean来标记是否有刷新Token的请求正在执行，如果有，那么直接返回一个PublishSubject，否则就先发起一次刷新token的请求，并将PublishSubject作为该请求的订阅者。

AtomicBoolean保证当同时有多个Request因Token失效，只触发一次刷新Token，其他Request直接返回PublishSubject触发重订阅，但此时第一个请求正在刷新Token（进行中），所以后面所有的Request只能等待，等待第一个Request刷新Token完成后返回，一起触发重订阅。在doOnNext/doOnError中，我们将AtomicBoolean恢复标志位，同时缓存最新的token。

PublishSubject既作为刷新Token Observable的订阅者，同时又用于触发retryWhen的重订阅。

（1）Token刷新成功，发送onNext事件，触发重订阅

（2）Token刷新失败，发送onError事件，结束整个调用链

public static class TokenLoader {// 定义刷新Token的Observableprivate Observable<String> mTokenObservable;// getNetTokenLocked()最后返回一个Observable类型，用于触发retryWhen的重订阅private PublishSubject<String> mPublishSubject;// 保证当同时有多个Request因Token失效，只触发一次刷新Token操作，其他Request直接触发重订阅private AtomicBoolean mRefreshing = new AtomicBoolean(false);private TokenLoader() {mPublishSubject = PublishSubject.create();mTokenObservable = Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(ObservableEmitter<String> e) throws Exception {// 模拟刷新Token的请求操作Thread.sleep(1000);Log.d("TAG", "发送Token");// Token取当前时间，返回给下游缓存e.onNext(String.valueOf(System.currentTimeMillis()));}}).doOnNext(new Consumer<String>() {@Overridepublic void accept(String token) {// 完成Token本地缓存Log.d("TAG", "存储Token=" + token);SharedManager.getInstance().setValue(SharedManager.KEY_TOKEN_VALUE, token);// 重置标志位mRefreshing.set(false);}}).doOnError(new Consumer<Throwable>() {@Overridepublic void accept(Throwable throwable) {// 重置标志位mRefreshing.set(false);}}).subscribeOn(Schedulers.io());}public static TokenLoader getInstance() {return Holder.INSTANCE;}private static class Holder {private static final TokenLoader INSTANCE = new TokenLoader();}public Observable<String> getNetTokenLocked() {// 第一次把AtomicBoolean标记为true，表示当前有token正在请求if (mRefreshing.compareAndSet(false, true)) {Log.d("TAG", "没有请求，发起一次新的Token请求");startTokenRequest();} else {Log.d("TAG", "已经有请求，直接返回等待");}return mPublishSubject;}private void startTokenRequest() {mTokenObservable.subscribe(mPublishSubject);}
}

7．场景模拟

模拟多个Request同时因token失效而触发刷新token的情况，在发起一个请求500ms之后，立刻发起另一个请求，当第二个请求决定是否要重订阅时，第一个请求正在进行刷新token的操作，这时候第二个请求只是等待而已。等第一个请求返回后，两个请求一起重订阅。

startRequest(0);try {Thread.sleep(500);
} catch (InterruptedException e) {e.printStackTrace();
}
startRequest(1);

Log：

// 第一个Request 0 发现Token失效，触发刷新Token操作

0:接收Throwable：Token is invalid 刷新Token

没有请求，发起一次新的Token请求

// 刷新Token时，第二个Request 1 发起请求，同时发现Token失效，试图触发刷新Token操作，这时候判断当前已经有一个请求在刷新Token，所以返回等待

1:接收Throwable：Token is invalid 刷新Token

已经有请求，直接返回等待

// 第一个Request 0 获取Token，并完成缓存

发送Token

存储Token=1589525718464

// 第一个Request 0 刷新Token完成，返回和Request1一起触发重订阅，两个Request重新发起

1:收到信息=Response Data

1:onComplete

0:收到信息=Response Data

0:onComplete

10．屏幕旋转导致Activity重建时恢复任务

1．Android屏幕旋转处理方式

针对Android屏幕旋转导致Activity销毁重建问题，处理方式有三种：

（1）禁止旋转

<activityandroid:name=".MyActivity"android:screenOrientation="portrait"android:label="@string/app_name" />

（2）旋转后恢复现场（官方推荐）

使用持久化 / 恢复现场的逻辑解决。

在onPause()里将用户数据保存到Preference, 如果Activity重建需要耗费大量资源或需要访问网络导致时间很长，可以实现onRetainNonConfigurationInstance()方法将所需数据先保存到一个对象里。

@Override
public Object onRetainCustomNonConfigurationInstance() {final MyDataObject data = cacheMyDataObject();return data;
}

在onCreate()取回

@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.main);final MyDataObject data = (MyDataObject) getLastNonConfigurationInstance();if (data == null) {//表示不是由于Configuration改变触发的onCreate()data = loadDataFromNet();}//... 
}

（3）手工处理旋转（官方不推荐）

通过配置AndroidManifest.xml，指定Activity在屏幕旋转时不做重建。

<activityandroid:name=".MyActivity"android:configChanges="orientation|keyboardHidden"android:label="@string/app_name" />

上述设置可以让Activity在屏幕旋转时不做重建，而是触发onConfigurationChanged()方法，在这里可以获取到当前的屏幕方向以便做必要的更新。旋转后Activity当前的信息也不会丢失，任务不会被终止。

2．RxJava实现Activity重建时恢复任务

场景：

没有在AndroidManifest.xml中对android:configChanges进行特殊的声明。Activity因屏幕旋转重建时，有些和Activity生命周期没有绑定关系的任务，可以放在具有setRetainInstance属性设置的Fragment中。

Fragment. setRetainInstance方法：

Fragment设置该标志位，在上述场景下，Fragment实例会被保留，并在Activity销毁过程中，只调用Fragment的onDetach方法，而不会调用onDestroy方法；在Activity重建时，会调用Fragment的onAttach，onActivityCreated方法，而不会调用onCreate方法。

（1）定义一套Fragment与Activity通讯的接口

由Activity实现接口，Fragment持有接口句柄，用于Fragment向Activity传递一个ConnectableObservable，Fragment通过ConnectableObservable向Activity发送数据（比如任务执行进度）

public interface IHolder {void onWorkerPrepared(ConnectableObservable<String> worker);
}

（2）定义任务Fragment：WorkerFragment

定义成员变量

// 持有View的接口引用，调用接口方法把ConnectableObservable传递给View
private IHolder mHolder;
// 用于取消订阅
private Disposable mDisposable;
// 用于向Activity发送数据
private ConnectableObservable<String> mWorker;

onCreate

（1）设置标志位setRetainInstance(true);

（2）模拟一个独立（和view生命周期无关）任务，开始执行并同步执行进度给view。

// 设置标志位，当Activity重建时，本Fragment保留实例
setRetainInstance(true);
if (mWorker == null) {mWorker = Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {for (int i = 0; i < 10; i++) {String message = "任务进度=" + i * 10 + "%";try {// 模拟任务执行Thread.sleep(1000);if (observableEmitter.isDisposed()) {break;}} catch (InterruptedException error) {if (!observableEmitter.isDisposed()) {observableEmitter.onError(error);}}observableEmitter.onNext(message);}observableEmitter.onComplete();}}).subscribeOn(Schedulers.io()).publish();mDisposable = mWorker.connect();
}

onAttach

对于设置setRetainInstance(true); 的Fragment，在Activity重建时，会调用Fragment的onAttach，onActivityCreated方法，而不会调用onCreate方法。onAttach中，将Activity的上下文转换成接口（IHolder）类型。

@Override
public void onAttach(Context context) {super.onAttach(context);if (context instanceof IHolder) {mHolder = (IHolder) context;}
}

onResume

把负责执行任务的ConnectableObservable通过接口传递给Activity

@Override
public void onResume() {super.onResume();if (mHolder != null) {mHolder.onWorkerPrepared(mWorker);}
}

onDestroy

销毁订阅

@Override
public void onDestroy() {super.onDestroy();mDisposable.dispose();
}

（3）模拟一个旋转屏幕需要销毁重建的Activity（实现Iholder接口）

onCreate

调用startWorker()开始执行任务。

@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.layout);startWorker();mCompositeDisposable = new CompositeDisposable();
}

startWorker

考虑两个场景：（1）启动App，Activtiy被创建，开始执行任务；（2）屏幕旋转，Activity被销毁后重建，继续执行任务。注意（2）情况下不是重新执行任务，而是应该继续执行当前任务。

场景实现：如果存在Fragment实例（旋转屏幕，Activity重建情况下），不需要重新添加；否则创建并添加一个新的Fragment。

private void startWorker() {WorkerFragment worker = getWorkerFragment();if (worker == null) {addWorkerFragment();} else {Log.d(TAG, "WorkerFragment has attach");}
}
private void addWorkerFragment() {WorkerFragment workerFragment = new WorkerFragment();FragmentManager manager = getSupportFragmentManager();FragmentTransaction transaction = manager.beginTransaction();transaction.add(workerFragment, WorkerFragment.TAG);transaction.commit();
}

IHolder接口实现

当Activity销毁重建时，会调用已经存在的Fragment实例的onAttach方法，接着调用onResume方法，onAttach中，Fragment实例获取了重建的Activity IHolder类型的句柄，onResume方法中，Fragment实例调用了onWorkerPrepared方法，把执行任务的Observable同步给重建的Activity。

在Activity中，为ConnectableObservable订阅了观察者，用于接收进度信息并显示在页面上。

@Override
public void onWorkerPrepared(ConnectableObservable<String> worker) {worker.observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<String>() {@Overridepublic void onSubscribe(@NonNull Disposable d) {mCompositeDisposable.add(d);}@Overridepublic void onNext(@NonNull String message) {mTvResult.setText(message);}@Overridepublic void onError(@NonNull Throwable e) {onWorkerFinished();mTvResult.setText("任务错误");}@Overridepublic void onComplete() {onWorkerFinished();mTvResult.setText("任务完成");}});
}

finishWorker

任务结束，移除Fragment。

private void onWorkerFinished() {removeWorkerFragment();
}
private void removeWorkerFragment() {WorkerFragment workerFragment = getWorkerFragment();if (workerFragment != null) {FragmentManager manager = getSupportFragmentManager();FragmentTransaction transaction = manager.beginTransaction();transaction.remove(workerFragment);transaction.commit();}
}

onDestroy

记得解除订阅，防止内存泄漏。

@Override
protected void onDestroy() {super.onDestroy();mCompositeDisposable.clear();
}

11．网络重连自动请求

应用场景：模拟天气预报请求场景。

1．定位模块

起后台线程，每隔一段时间获取一次定位（城市代码）的结果，并发送结果通知。

（1）interval + takeWhile：每隔5s有条件地循环执行一次

（2）distinctUntilChanged：过滤连续的重复数据，即连续两次定位（城市代码）信息一样，则过滤掉重复信息，避免后面接口的重复请求。

（3）doOnNext：当位置（城市代码）变更，向下通知之前，先做本地缓存

// 每隔5s获取一次位置信息，直到停止天气服务（stopService = true)
return Observable.interval(5000, TimeUnit.MILLISECONDS).takeWhile(new Predicate<Long>() {@Overridepublic boolean test(Long aLong) throws Throwable {return !stopService;}}).subscribeOn(Schedulers.computation()).observeOn(Schedulers.io()).map(new Function<Long, Long>() {@Overridepublic Long apply(Long aLong) {Log.d("TAG", "重新定位");// 模拟获取位置信息过程 ...Log.d("TAG", "定位到城市信息=" + cityCode);return cityCode;}})// 过滤掉连续相同的数据，如果连续两次定位位置相同，不重复请求.distinctUntilChanged()// 发送位置信息通知之前，把位置信息缓存到本地.doOnNext(new Consumer<Long>() {@Overridepublic void accept(Long s) {saveCacheCity(s);}}).subscribeOn(Schedulers.io());

2．网络状态模块

监听网络状态变化，当断网后重连接时，发送通知给下游，以便重新请求网络数据。

（1）PublishSubject：注册网络状态监听器，当接收器接收到网络状态变更事件，由PublishSubject发送当前网路状态（是否可用）给下游。

（2）filter：PublishSubject发送数据前，对数据加过滤，只发送网络已连接事件（isConnect == true），同时只有当前已经获取到位置信息时才发送。

（3）map：将网络状态变化事件，最终转换成获取的本地缓存的城市代码，并发送给下游，请下游组织向服务器请求天气数据。

// 用于发送网络状态变更事件
private PublishSubject<Boolean> mNetStatusPublish = new PublishSubject<>();
// 网络状态Observable由网络状态变更事件触发，最后返回缓存的位置信息，下游将用位置信息重新请求天气数据
private Observable<Long> getNetStatusObservable() {return mNetStatusPublish.filter(new Predicate<Boolean>() {@Overridepublic boolean test(Boolean isConnect) {// 只发送网络已连接事件（isConnect == true），同时只有当前已经获取到位置信息时才发送return isConnect && getCacheCity() > 0;}}).map(new Function<Boolean, Long>() {@Overridepublic Long apply(Boolean aBoolean) {// 当网络重连成功后，发送缓存的位置信息给下游return getCacheCity();}).subscribeOn(Schedulers.io());
}
// 注册网络状态变更广播接收器，当发生变更时，判断是否重连成功，并把结果通知给下游
private void registerBroadcast() {BroadcastReceiver mReceiver = new BroadcastReceiver() {@Overridepublic void onReceive(Context context, Intent intent) {if (mNetStatusPublish != null) {mNetStatusPublish.onNext(isNetworkConnected(context));}}};IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);registerReceiver(mReceiver, filter);
}

3．整合上述两个触发条件，并实现网络请求逻辑

（1）定义API接口

public interface IWeatherApi {Observable<WeatherEntity> doRequestWeather(long cityId);
}

（2）网络请求

merge操作符：整合两个数据源

retryWhen操作符：出错重试

Observable.merge(getLocationObservable(), getNetStatusObservable()).flatMap(new Function<Long, ObservableSource<WeatherEntity>>() {@Overridepublic ObservableSource<WeatherEntity> apply(Long cityCode) throws Exception {Log.d("TAG", "尝试请求天气信息=" + cityCode);return doRequestWeather(cityCode).subscribeOn(Schedulers.io());}}).subscribeOn(Schedulers.io()).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Exception {return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {@Overridepublic ObservableSource<?> apply(Throwable throwable) throws Exception {Log.d("TAG", "请求天气信息过程中发生错误，进行重订阅");return Observable.just(0);}});}}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer());

12．模拟60秒发送验证码

public void onCodeClick() {Observable.intervalRange(0, 60, 0, 1, TimeUnit.SECONDS).map(new Function<Long, Long>() {@Overridepublic Long apply(@NonNull Long aLong) throws Exception {return 60 - aLong; // 设置60秒，由于是倒计时，需要将倒计时的数字反过来}}).observeOn(AndroidSchedulers.mainThread()).doOnSubscribe(new Consumer<Disposable>() {@Overridepublic void accept(@NonNull Disposable disposable) throws Exception {button.setEnabled(false);button.setTextColor(Color.GRAY);}}).subscribeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Long>() {@Overridepublic void onSubscribe(Disposable d) {}@Overridepublic void onNext(Long aLong) {button.setText(aLong + "秒后重发");}@Overridepublic void onError(Throwable e) {}@Overridepublic void onComplete() {button.setEnabled(true);button.setTextColor(Color.RED);button.setText("发送验证码");}});
}

参考链接：https://www.jianshu.com/p/c935d0860186