当RxLifecycle遇到MVP 在P中没有Bind怎么破？
看完rxLifeCycle 你会发现 好方便啊~但是在MVP中 尤其是P中没有bindToLifeCycle啊 怎么破？
解决方案：
搞一个接口实现
public interface IParaView extends IBase {
void updateData();
&T& Observable.Transformer&T, T& bindToLifecycle();
}然后像这样调就行了
void bindDatas_rx() {
bindDataObservable.subscribeOn(Schedulers.io()).doOnSubscribe(new Action0() {
public void call() {
pDialog.show();
pDialog.setCancelable(false);
}).compose(getView().bindToLifecycle()).subscribeOn(AndroidSchedulers.mainThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Subscriber&String&() {
public void onCompleted() {
Log.i(TAG, "onCompleted: ");
getView().updateData();
pDialog.dismiss();
com.orhanobut.logger.Logger.t(TAG).d("ConfigParaList size%s", mDatas.size());
public void onError(Throwable e) {
Log.i(TAG, "onError: " + e.toString());
public void onNext(String s) {
Log.i(TAG, "onNext: state:" + s);
}我的继承关系是这样的：
public class SetupAlgorithmparameterFragment extends BaseFragment&IParaView, SetupAlgorithmparaPresenter&
implements LoadMoreAdapter.OnLoadMoreListener, IParaView {
也就是说这个bind在RxFrament中，我的Presenter访问不到，只要通过接口回调，而RxFragment实现了这个接口，自然就调用的RxFragment中的Bind方法啦！
我也测试了一下，的确如此。
本文转载自 潮男阿狸的博客 , 原文链接： , 转载请保留本声明！
每一个你不满意的现在，都有一个你没有努力的曾经。
Copyright (C) 2015&&
&&Powered by&接着上一篇文章的内容，这篇文章一边分析RxLifecycle的实现原理，一边学习RxJava操作符。
首先RxLifecycle在基础类里定义BehaviorSubject并绑定Activity或Fragment的生命周期，生命周期被调用时BehaviorSubject就发射相应周期的数据。
并且BehaviorSubject同时作为一个被观察者，随时被自定义的操作符观察着。
private final BehaviorSubject&ActivityEvent& lifecycleSubject
= BehaviorSubject.create();
@CallSuper
protected void onStart() {
super.onStart();
lifecycleSubject.onNext(ActivityEvent.START);
@CallSuper
protected void onResume() {
super.onResume();
lifecycleSubject.onNext(ActivityEvent.RESUME);
@CallSuper
protected void onPause() {
lifecycleSubject.onNext(ActivityEvent.PAUSE);
super.onPause();
@CallSuper
protected void onStop() {
lifecycleSubject.onNext(ActivityEvent.STOP);
super.onStop();
再来看看基础类里如何提供定义的变换符，RxLifecycle提供的bindActivity方法将BehaviorSubjec传入，定义的操作符根据生命周期数据进行变换。
@CheckResult
public final &T& Observable.Transformer&T, T& bindToLifecycle() {
return RxLifecycle.bindActivity(lifecycleSubject);
把核心变换操作的代码贴上，边分析思路边熟悉了解几个陌生的操作符。
这里几个关键的操作应用实现了，绑定生命周期的变化。
TakeUntil 订阅并开始反射原始Observable，它还监视你提供的第二个Observable。如果第二个Observable发射了一项数据或者发射了一个终止通知，TakeUtil返回的Observable会停止反射原始Observable并终止。源码使用这个操作判断是否执行发射原始Observable。
代码理解一下takeUntil的作用
Observable.just(1).takeUntil(Observable.create(new Observable.OnSubscribe&Object&() {
public void call(Subscriber&? super Object& subscriber) {
//subscriber.onNext(&abc&); //如果不发射&abc&，Log信息回接收到onNext=1;
})).subscribe(Utils.getSubscriber());
04-26 18:19:59.886 /qulei.rxjava.demo D/RxJava: onNext : 1
04-26 18:19:59.886 /qulei.rxjava.demo D/RxJava: onCompleted
combineLatest
当两个Observables中的任何一个发射了数据时，使用一个函数结合每个Observable发射的最近数据项，并且基于这个函数的结果发射数据。这里根据BehaviorSubject生命周期的变化作为判断是否发射数据终止原始它还监视你提供的第二个Observable。
Observable.combineLatest(
sharedLifecycle.take(1).map(correspondingEvents),sharedLifecycle.skip(1),
new Func2&R, R, Boolean&() {
public Boolean call(R bindUntilEvent, R lifecycleEvent) {
return lifecycleEvent.equals(bindUntilEvent);
如果原始Observable没有发射任何满足条件的数据，takeFist 会返回一个空的Observable（不调用 onNext() 但是会调用 onCompleted ）。如果生命周期不是绑定的周期，将继续匹配下一个周期时间，如果相同就发送空的Observable，停止原始的Observable执行发射数据。
原理分析到这里希望能够带来帮助。
阅读(...) 评论()Rxlifecycle使用详解，解决RxJava内存泄露问题 - 推酷
Rxlifecycle使用详解，解决RxJava内存泄露问题
随着Android第三库的普及，
)越来越被人熟知，简洁的语法，配合Java8 Lambda表达式，使代码的结构更加清晰，通过线程调度器更容易控制和切换线程，种种优点，使用它的人也越来越多。但是使用不好，很容易导致内存泄露。
Rxlifecycle (
)就使被用来严格控制由于发布了一个订阅后，由于没有及时取消，导致Activity/Fragment无法销毁导致的内存泄露
RxJava和RxAndroid
compile 'io.reactivex:rxandroid:1.0.1'
compile 'io.reactivex:rxjava:1.0.16'
Rxlifecycle
compile 'com.trello:rxlifecycle:0.3.0'
compile 'com.trello:rxlifecycle-components:0.3.0'
Rxlifecycle 使用
Activity/Fragment需继承RxAppCompatActivity/RxFragment，目前支持的有RxAppCompatActivity、RxFragment、RxDialogFragment、RxFragmentActivity。
一、bindToLifecycle()方法
在子类使用Observable中的compose操作符，调用，完成Observable发布的事件和当前的组件绑定，实现生命周期同步。从而实现当前组件生命周期结束时，自动取消对Observable订阅。
Observable.interval(1, TimeUnit.SECONDS)
.compose(this.bindToLifecycle())
.subscribe(new Action1&Long&() {
public void call(Long num) {
Log.i(TAG, &
二、bindUntilEvent()&方法
使用ActivityEvent类，其中的CREATE、START、 RESUME、PAUSE、STOP、 DESTROY分别对应生命周期内的方法。使用bindUntilEvent指定在哪个生命周期方法调用时取消订阅。
Observable.interval(1, TimeUnit.SECONDS)
.compose(this.bindUntilEvent(ActivityEvent.PAUSE))
.subscribe(mSub);
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致带你学开源项目：RxLifecycle-当Activity被destory时自动暂停网络请求 - 简书
带你学开源项目：RxLifecycle-当Activity被destory时自动暂停网络请求
大幅提高自身技术实力最有效的途径之一就是学习世界级优秀开源项目的精髓，而本人的《带你学开源项目》系列文章将持续更新，对当前Android开发界最优秀的开源项目进行深入分析
本人的《带你学开源项目系列文章》采取的分析思路不是从源码里抽代码出来一步步跟踪，了解其具体实现，而是通过提出问题，一步步思考解决方法，从而学习到开源项目的思维精华。笔者认为这种方式更有利于读者提高自身思维方式和技术能力。
二、 开源项目
地址： 。该项目是为了防止RxJava中subscription导致内存泄漏而诞生的，核心思想是通过监听Activity、Fragment的生命周期，来自动断开subscription以防止内存泄漏。
基本用法如下：
myObservable
.compose(RxLifecycle.bindUntilEvent(lifecycle, ActivityEvent.DESTROY))
.subscribe();
此处myObservable可以看成一个耗时的网络请求，通过绑定到ActivityEvent.DESTROY，一旦Activity发生了DESTORY生命周期，数据就不会再流向subscriber，即不会对这些数据进行任何处理和UI绘制，从而提高安全性。
Android开发中常会有这样一个场景：
发送网络请求 -& 2. 服务器处理请求并返回数据 -& 3. client端接收数据，绘制UI。
在前两步一般都是不会出现问题的，但是在第三步，当数据返回给client端时，如果页面已经不在了，那么就无法去绘制UI，很有可能会导致意向不到的问题。因此，为了解决这个问题，一个好的思路就是当页面离开时，自动断开网络请求数据的处理过程，即数据返回后不再进行任何处理。
要达到上面这样一个功能，我们可以思考，至少需要两部分：
随时监听Activity(Fragment)的生命周期并对外发射出去；
在我们的网络请求中，接收生命周期并进行判断，如果该生命周期是自己绑定的，如Destory，那么就断开数据向下传递的过程。
可以看到，首先有一个核心功能要实现：就是既能够监听Activity生命周期事件并对外发射，又能够接收每一个生命周期事件并作出判断。为了实现这个功能，可以联想到RxJava中的Subject，既能够发射数据，又能够接收数据。
六、 Subject介绍
了解Subject的读者可以跳过这部分。
如何理解Subject呢？
很容易，在RxJava里面，Observable是数据的发射者，它会对外发射数据，然后经过map、flatmap等等数据处理后，最终传递给Observer，这个数据接收者。因此，抛开中间数据处理不管，可以看出，Observable对外发射数据，是数据流的开端；Observer接收数据，是数据流的末端。
那么Subject呢？看一眼源码：
* Represents an object that is both an Observable and an Observer.
public abstract class Subject&T, R& extends Observable&R& implements Observer&T& {}
首先，它extends Observable&R&，说明Subject具备了对外发射数据的能力，即拥有了from()、just()等等；另外，它又implements Observer&T&，说明又能够处理数据，具备onNext()、onCompleted等等。
然后，Subject毕竟只是一个抽象类，那么我们要如何使用它呢？
这里介绍一种最简单的：PublishSubject:
PublishSubject&Object& subject = PublishSubject.create();
// myObserver will receive "one" & "two" and onCompleted events
subject.subscribe(myObserver);
subject.onNext("one");
subject.onNext("two");
subject.onCompleted();
这里做的事情很简单，先创建一个PublishSubject -& 绑定一个myObserver，此时subject扮演了Observable的角色，把数据发射给myObserver -& 然后subject处理接收了两个数据one、two -& 最终这些数据都传递给了myObserver。所以，subject扮演的角色是:
数据one、two
(Observer) subject (Observable)
myObserver
简单来说，我们把数据one、two塞给subject，然后subject又发射给了myObserver。
七、 BaseActivity监听生命周期
那么我们先来实现生命周期监听功能，基本思路是：在BaseActivity里创建一个PublishSubject对象，在每个生命周期发生时，把该生命周期事件传递给PublishSubject。具体实现如下(只写部分生命周期，其他类似)：
class BaseActivity {
protected final PublishSubject&ActivityLifeCycleEvent& lifecycleSubject = PublishSubject.create();
protected void onCreate(Bundle savedInstanceState) {
lifecycleSubject.onNext(ActivityLifeCycleEvent.CREATE);
protected void onPause() {
lifecycleSubject.onNext(ActivityLifeCycleEvent.PAUSE);
protected void onStop() {
lifecycleSubject.onNext(ActivityLifeCycleEvent.STOP);
这样的话，我们把所有生命周期事件都传给了lifecycleSubject了，或者说，lifecycleSubject已经接收到了并能够对外发射各种生命周期事件的能力了。
八、 改良每一个Observable，接收生命周期并自动断开自身
通常我们的一次网络请求长这样：
networkObservable
.subscribe(new Observer(
handleUI()
其中，networkObservable表示一个通用的网络请求，会接收网络数据并传递给Observer去绘制UI。
现在，我们希望这个networkObservable监听Activity的DESTORY事件，一旦发生了DESTORY就自动断开Observer，即使网络数据回来了也不再传递给Observer去绘制UI。即：
networkObservable
.compose(bindUntilEvent(ActivityLifeCycleEvent.DESTORY))
.subscribe(new Observer(
handleUI()
因此，我们需要实现
bindUntilEvent(ActivityLifeCycleEvent.DESTORY)
这个方法，那如何实现呢？
我们知道lifecycleSubject能够发射生命周期事件了，那么我们可以让networkObservable去检查lifecycleSubject发出的生命周期，如果和自己绑定的生命周期事件一样，那就自动停掉即可。
九、 改装networkObservable
对于networkObservable自动停掉，我们可以利用操作符
networkObservable.takeUntil(otherObservable)
它的作用是监听otherObservable，一旦otherObservable对外发射了数据，就自动把networkObservable停掉；
那otherObservable何时对外发射数据呢？当然是lifecycleSubject发射出的生命周期事件等于绑定的生命周期事件时，开始发射。
otherObservable = lifecycleSubject.takeFirst(new Func1&ActivityLifeCycleEvent, Boolean&() {
public Boolean call(ActivityLifeCycleEvent activityLifeCycleEvent) {
return activityLifeCycleEvent.equals(bindEvent);
其中的关键是判断activityLifeCycleEvent.equals(bindEvent);，一旦条件满足，otherObservable就对外发射数据，然后networkObservable就立即自动停掉。
十、 合并 生命周期监听 与 networkObservable改良
在BaseActivity里添加lifecycleSubject，并把每一个生命周期事件按时传递给lifecycleSubject
在BaseActivity里添加一个bindUntilEvent方法:
public &T& Observable.Transformer&T, T& bindUntilEvent(@NonNull final ActivityLifeCycleEvent event) {
return new Observable.Transformer&T, T&() {
public Observable&T& call(Observable&T& sourceObservable) {
Observable&ActivityLifeCycleEvent& compareLifecycleObservable =
lifecycleSubject.takeFirst(new Func1&ActivityLifeCycleEvent, Boolean&() {
public Boolean call(ActivityLifeCycleEvent activityLifeCycleEvent) {
return activityLifeCycleEvent.equals(event);
return sourceObservable.takeUntil(compareLifecycleObservable);
在任意一个网络请求 networkObservable 处改良
networkObservable
.compose(bindUntilEvent(ActivityLifeCycleEvent.DESTORY))
.subscribe(new Observer(
handleUI()
文中提到的networkObservable是网络请求，但实际上这不限于网络请求，任何耗时操作如文件io操作等都可以利用这个方法，来监听生命周期并自动暂停。
对于Fragment中的处理方法也是类似。
Big Fan of Full-Stack.
GitHub: https://github....}