Android开发之深度项目设计探索(二)

《Android开发之深度项目设计探索(一)》 这篇文章中,主要描述了深度项目架构设计会涉及到的一些知识点,那么这篇文章主要介绍的是 RxLifecycle 使用及源码分析。

RxLifecycle :

在Android进行面试的时候,经常会被问到的就是Android的内存泄漏、泄漏场景、泄漏原因以及解决办法。如果你提到了Rxjava2,面试官可能会接连发问Rxjava2在使用过程中会有一些什么问题?这时就可以谈到Rxjava如果在一些特定场景没有及时解绑订阅可能会导致内存泄漏。

泄漏的原因是:当RxJava发布一个订阅后,此时页面执行了finish的生命周期,但订阅逻辑还未完成。如果没有及时取消订阅,就会导致Activity/Fragment无法被回收,从而引发内存泄漏。但是相应的,Rxjava系列也提供了解决办法,那就是使用RxLifecycle 。

RxLifecycle官方文档

通过官方文档了解发现,RxLifecycle库的使用和集成也是简单和快捷的

A:RxLifecycle对应的依赖(最新版本)

// 这是RxLifecycle最主要的依赖
implementation 'com.trello.rxlifecycle2:rxlifecycle:2.2.2'

// If you want to bind to Android-specific lifecycles
//如果你想绑定Android的生命周期
implementation 'com.trello.rxlifecycle2:rxlifecycle-android:2.2.2'

// If you want pre-written Activities and Fragments you can subclass as providers
//如果想在预先写好的Activities and Fragments,你可以作为其父类的子类
implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.2'

// If you want pre-written support preference Fragments you can subclass as providers
//如果想在预先支持的 Fragments,你可以作为其父类的子类
implementation 'com.trello.rxlifecycle2:rxlifecycle-components-preference:2.2.2'

// If you want to use Navi for providers
// Android使用的库,继承NaviActivity使用
implementation 'com.trello.rxlifecycle2:rxlifecycle-navi:2.2.2'

// If you want to use Android Lifecycle for providers
//如果你想为其提供Android生命周期
implementation 'com.trello.rxlifecycle2:rxlifecycle-android-lifecycle:2.2.2'

// If you want to use Kotlin syntax
//如果你想使用Kotlin语法
implementation 'com.trello.rxlifecycle2:rxlifecycle-kotlin:2.2.2'

// If you want to use Kotlin syntax with Android Lifecycle
//如果你想使用Kotlin语法作用在Android生命周期上
implementation 'com.trello.rxlifecycle2:rxlifecycle-android-lifecycle-kotlin:2.2.2'

下面是一些基本的使用和说明:

首先是 绑定生命周期:

 myObservable.compose(RxLifecycle.bind(lifecycle)).subscribe();

接着是 绑定特殊的生命周期(onStart onStop等等):

myObservable.compose(RxLifecycle.bindUntilEvent(lifecycle, ActivityEvent.DESTROY))
    .subscribe();

然后是 通过RxLifecycle在适当的时间来结束:

myObservable.compose(RxLifecycleAndroid.bindActivity(lifecycle)).subscribe();

通过文档我们可以知道:如果在onStart( )这个生命周期里面绑定,它就会在onStop()这个终止绑定;如果我们在onPause( )之后订阅, 那么它就会在其下一个生命周期终止绑定,(在onPause( )之后订阅,因为onStop()是其下一个生命周期,如果Activity执行到了这里,就会解绑)

下面上一段代码加深RxLifecycle的理解和使用:

public class LifeActivity extends RxAppCompatActivity{

    @Override
    protected void onStart() {
        super.onStart();

        Observable.interval(2, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .compose(this.bindToLifecycle())
                .subscribe();
    }

}

理论上我们需要使用compose操作符,然后加上bindToLifecycle即可完成简单的使用(注意:这里的 LifeActivity继承的是RxAppCompatActivity)看到了这里,可能疑惑的是,RxLifecycle具体的绑定该如何理解?里面的生命周期又是如何操作的?

是这样,这里的生命周期是由 LifecycleProvider<T> 来提供的,实现的方式有以下四种:
1:继承父类,RxActivity, RxFragment
2:使用 Navi 以及 Rxlifecycle-navi
3:使用 Android's lifecycle
4:自己编写实现

首先看第一种:也就是上面的代码,直接继承RxAppCompatActivity,然后点开RxAppCompatActivity源码会发现很多事情,这个后面说。

第二种:继承NaviActivity(需要导入上面提供的Navi对应的依赖)下面是参考代码

public class NaviLifeActivity extends NaviActivity{

    private final LifecycleProvider<ActivityEvent> provider
            = NaviLifecycle.createActivityLifecycleProvider(this);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initLifecycle();
    }
      
    private void initLifecycle(){
        Observable.interval(2, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .compose(provider.bindToLifecycle())
                .subscribe();
    }
}

第三种和第四种由于涉及到另外的内容这里就不描述了。

值得一提的是:compose方法需在subscribeOn方法之后使用。

RxLifecycle源码分析:

说到源码,我们首先进入RxAppCompatActivity看看,因为compose(this.bindToLifecycle()) 这句API里面的this,代表的就是当前继承了RxAppCompatActivity的子类,奔着研究分析的精神,下面是
RxAppCompatActivity 的源码:

public abstract class RxAppCompatActivity extends AppCompatActivity implements LifecycleProvider<ActivityEvent> {

    private final BehaviorSubject<ActivityEvent> lifecycleSubject = BehaviorSubject.create();

    @Override
    @NonNull
    @CheckResult
    public final Observable<ActivityEvent> lifecycle() {
        return lifecycleSubject.hide();
    }

    @Override
    @NonNull
    @CheckResult
    public final <T> LifecycleTransformer<T> bindUntilEvent(@NonNull ActivityEvent event) {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event);
    }

    @Override
    @NonNull
    @CheckResult
    public final <T> LifecycleTransformer<T> bindToLifecycle() {
        return RxLifecycleAndroid.bindActivity(lifecycleSubject);
    }

    @Override
    @CallSuper
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        lifecycleSubject.onNext(ActivityEvent.CREATE);
    }

    @Override
    @CallSuper
    protected void onStart() {
        super.onStart();
        lifecycleSubject.onNext(ActivityEvent.START);
    }

    @Override
    @CallSuper
    protected void onResume() {
        super.onResume();
        lifecycleSubject.onNext(ActivityEvent.RESUME);
    }

    @Override
    @CallSuper
    protected void onPause() {
        lifecycleSubject.onNext(ActivityEvent.PAUSE);
        super.onPause();
    }

    @Override
    @CallSuper
    protected void onStop() {
        lifecycleSubject.onNext(ActivityEvent.STOP);
        super.onStop();
    }

    @Override
    @CallSuper
    protected void onDestroy() {
        lifecycleSubject.onNext(ActivityEvent.DESTROY);
        super.onDestroy();
    }
}

可以看到在Activity具体生命周期里面进行了对应的事件发送!

1:BehaviorSubject与ActivityEvent

RxAppCompatActivity源码中内部第一行代码是创建了一个BehaviorSubject实例对象,里面的泛型是ActivityEvent,首先看下 ActivityEvent

/**
 * Lifecycle events that can be emitted by Activities.
 */
public enum ActivityEvent {

    CREATE,
    START,
    RESUME,
    PAUSE,
    STOP,
    DESTROY

}

哦,细心的你一眼就看到了这是个枚举,里面的value对应的就是Activity生命周期的那些生命周期(因为在生命周期里面进行了发射嘛);那么,什么是BehaviorSubject?BehaviorSubject的由于源码较多这里就不贴出来了,这个类它继承了Subject<T>,那 Subject<T> 又是什么?源码如下:

public abstract class Subject<T> extends Observable<T> implements Observer<T> {
    /**
     * Returns true if the subject has any Observers.
     * <p>The method is thread-safe.
     * @return true if the subject has any Observers
     */
    public abstract boolean hasObservers();

    /**
     * Returns true if the subject has reached a terminal state through an error event.
     * <p>The method is thread-safe.
     * @return true if the subject has reached a terminal state through an error event
     * @see #getThrowable()
     * @see #hasComplete()
     */
    public abstract boolean hasThrowable();

    /**
     * Returns true if the subject has reached a terminal state through a complete event.
     * <p>The method is thread-safe.
     * @return true if the subject has reached a terminal state through a complete event
     * @see #hasThrowable()
     */
    public abstract boolean hasComplete();

    /**
     * Returns the error that caused the Subject to terminate or null if the Subject
     * hasn't terminated yet.
     * <p>The method is thread-safe.
     * @return the error that caused the Subject to terminate or null if the Subject
     * hasn't terminated yet
     */
    @Nullable
    public abstract Throwable getThrowable();

    /**
     * Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and
     * onComplete methods, making them thread-safe.
     * <p>The method is thread-safe.
     * @return the wrapped and serialized subject
     */
    @NonNull
    public final Subject<T> toSerialized() {
        if (this instanceof SerializedSubject) {
            return this;
        }
        return new SerializedSubject<T>(this);
    }
}

哦,上帝,Subject继承了Observable、又实现了Observer接口,这也就说明Subject即可作为被观察者,也可以作为观察者。同理,他的子类BehaviorSubject也具备同样的功能。
下面是关于BehaviorSubject操作符的一张图:


Android开发之深度项目设计探索(二)
BehaviorSubject

BehaviorSubject的简单理解就是,发送离订阅最近的上一个值,没有上一个值的时候会发送默认值,接下来(如果有数据)则继续发射原始Observable的数据。

2:bindUntilEvent( ActivityEvent event) 、LifecycleTransformer、takeUntil

在RxAppCompatActivity 源码中我们看到了bindUntilEvent()这个方法,最终的的返回值类型是 LifecycleTransformer 那这个LifecycleTransformer又是什么?

public final class LifecycleTransformer<T> implements ObservableTransformer<T, T>,
                                                      FlowableTransformer<T, T>,
                                                      SingleTransformer<T, T>,
                                                      MaybeTransformer<T, T>,
                                                      CompletableTransformer
{
    final Observable<?> observable;

    LifecycleTransformer(Observable<?> observable) {
        checkNotNull(observable, "observable == null");
        this.observable = observable;
    }

    @Override
    public ObservableSource<T> apply(Observable<T> upstream) {
        return upstream.takeUntil(observable);
    }
  //......
}

经过源码可以发现,这个LifecycleTransformer实现了大量的XXXTransformer,内部的方法大都使用了apply方法,这个方法实则是调用了takeUntil操作符,那么这个takeUntil操作符是什么意思?

Android开发之深度项目设计探索(二)
takeUntil

takeUntil操作符简单理解就是,当第二个Observable发射了一项数据或者终止时,丢弃原Observable发射的任何数据。注意:这里是满足条件丢弃任何发送的数据(该操作符的应用场景是不是,在onDestroy( )里面取消订阅,解决内存泄漏的隐患)

3:bindToLifecycle()

我们知道,绑定的API是bindToLifecycle()这一行代码,那么我们就抽丝剥茧,根据RxAppCompatActivity源码得知,bindToLifecycle()这行代码最终返回了 RxLifecycleAndroid.bindActivity(lifecycleSubject),源码跟进,进入到了RxLifecycleAndroid,下面是 RxLifecycleAndroid 源码:

public class RxLifecycleAndroid {

    private RxLifecycleAndroid() {
        throw new AssertionError("No instances");
    }

    /**
     * Binds the given source to an Activity lifecycle.
     * <p>
     * This helper automatically determines (based on the lifecycle sequence itself) when the source
     * should stop emitting items. In the case that the lifecycle sequence is in the
     * creation phase (CREATE, START, etc) it will choose the equivalent destructive phase (DESTROY,
     * STOP, etc). If used in the destructive phase, the notifications will cease at the next event;
     * for example, if used in PAUSE, it will unsubscribe in STOP.
     * <p>
     * Due to the differences between the Activity and Fragment lifecycles, this method should only
     * be used for an Activity lifecycle.
     *
     * @param lifecycle the lifecycle sequence of an Activity
     * @return a reusable {@link LifecycleTransformer} that unsubscribes the source during the Activity lifecycle
     */
    @NonNull
    @CheckResult
    public static <T> LifecycleTransformer<T> bindActivity(@NonNull final Observable<ActivityEvent> lifecycle) {
        return bind(lifecycle, ACTIVITY_LIFECYCLE);
    }

    /**
     * Binds the given source to a Fragment lifecycle.
     * <p>
     * This helper automatically determines (based on the lifecycle sequence itself) when the source
     * should stop emitting items. In the case that the lifecycle sequence is in the
     * creation phase (CREATE, START, etc) it will choose the equivalent destructive phase (DESTROY,
     * STOP, etc). If used in the destructive phase, the notifications will cease at the next event;
     * for example, if used in PAUSE, it will unsubscribe in STOP.
     * <p>
     * Due to the differences between the Activity and Fragment lifecycles, this method should only
     * be used for a Fragment lifecycle.
     *
     * @param lifecycle the lifecycle sequence of a Fragment
     * @return a reusable {@link LifecycleTransformer} that unsubscribes the source during the Fragment lifecycle
     */
    @NonNull
    @CheckResult
    public static <T> LifecycleTransformer<T> bindFragment(@NonNull final Observable<FragmentEvent> lifecycle) {
        return bind(lifecycle, FRAGMENT_LIFECYCLE);
    }

    /**
     * Binds the given source to a View lifecycle.
     * <p>
     * Specifically, when the View detaches from the window, the sequence will be completed.
     * <p>
     * Warning: you should make sure to use the returned Transformer on the main thread,
     * since we're binding to a View (which only allows binding on the main thread).
     *
     * @param view the view to bind the source sequence to
     * @return a reusable {@link LifecycleTransformer} that unsubscribes the source during the View lifecycle
     */
    @NonNull
    @CheckResult
    public static <T> LifecycleTransformer<T> bindView(@NonNull final View view) {
        checkNotNull(view, "view == null");

        return bind(Observable.create(new ViewDetachesOnSubscribe(view)));
    }

    // Figures out which corresponding next lifecycle event in which to unsubscribe, for Activities
    private static final Function<ActivityEvent, ActivityEvent> ACTIVITY_LIFECYCLE =
        new Function<ActivityEvent, ActivityEvent>() {
            @Override
            public ActivityEvent apply(ActivityEvent lastEvent) throws Exception {
                switch (lastEvent) {
                    case CREATE:
                        return ActivityEvent.DESTROY;
                    case START:
                        return ActivityEvent.STOP;
                    case RESUME:
                        return ActivityEvent.PAUSE;
                    case PAUSE:
                        return ActivityEvent.STOP;
                    case STOP:
                        return ActivityEvent.DESTROY;
                    case DESTROY:
                        throw new OutsideLifecycleException("Cannot bind to Activity lifecycle when outside of it.");
                    default:
                        throw new UnsupportedOperationException("Binding to " + lastEvent + " not yet implemented");
                }
            }
        };

    // Figures out which corresponding next lifecycle event in which to unsubscribe, for Fragments
    private static final Function<FragmentEvent, FragmentEvent> FRAGMENT_LIFECYCLE =
        new Function<FragmentEvent, FragmentEvent>() {
            @Override
            public FragmentEvent apply(FragmentEvent lastEvent) throws Exception {
                switch (lastEvent) {
                    case ATTACH:
                        return FragmentEvent.DETACH;
                    case CREATE:
                        return FragmentEvent.DESTROY;
                    case CREATE_VIEW:
                        return FragmentEvent.DESTROY_VIEW;
                    case START:
                        return FragmentEvent.STOP;
                    case RESUME:
                        return FragmentEvent.PAUSE;
                    case PAUSE:
                        return FragmentEvent.STOP;
                    case STOP:
                        return FragmentEvent.DESTROY_VIEW;
                    case DESTROY_VIEW:
                        return FragmentEvent.DESTROY;
                    case DESTROY:
                        return FragmentEvent.DETACH;
                    case DETACH:
                        throw new OutsideLifecycleException("Cannot bind to Fragment lifecycle when outside of it.");
                    default:
                        throw new UnsupportedOperationException("Binding to " + lastEvent + " not yet implemented");
                }
            }
        };

}

嗯,首先看到bindActivity(final Observable<ActivityEvent> lifecycle)这个方法,这个方法最终返回了bind(lifecycle, ACTIVITY_LIFECYCLE);

请注意,前方高能: ACTIVITY_LIFECYCLE,这个ACTIVITY_LIFECYCLE的源码也是上面的截图,可以看到通过switch语句进行条件筛选最终返回ActivityEvent这个枚举里面的属性值(仔细观看的话源码下面还有Fragment对应的生命周期),可能你会问,为什么这是对应的生命周期?让我们首先看回bind(lifecycle, ACTIVITY_LIFECYCLE); 这个方法,点进去看,进入到了 RxLifecycle 这个类,源码如下:

public class RxLifecycle {

    private RxLifecycle() {
        throw new AssertionError("No instances");
    }

    /**
     * Binds the given source to a lifecycle.
     * <p>
     * When the lifecycle event occurs, the source will cease to emit any notifications.
     *
     * @param lifecycle the lifecycle sequence
     * @param event the event which should conclude notifications from the source
     * @return a reusable {@link LifecycleTransformer} that unsubscribes the source at the specified event
     */
    @Nonnull
    @CheckReturnValue
    public static <T, R> LifecycleTransformer<T> bindUntilEvent(@Nonnull final Observable<R> lifecycle,
                                                                @Nonnull final R event) {
        checkNotNull(lifecycle, "lifecycle == null");
        checkNotNull(event, "event == null");
        return bind(takeUntilEvent(lifecycle, event));
    }

    private static <R> Observable<R> takeUntilEvent(final Observable<R> lifecycle, final R event) {
        return lifecycle.filter(new Predicate<R>() {
            @Override
            public boolean test(R lifecycleEvent) throws Exception {
                return lifecycleEvent.equals(event);
            }
        });
    }

    /**
     * Binds the given source to a lifecycle.
     * <p>
     * This helper automatically determines (based on the lifecycle sequence itself) when the source
     * should stop emitting items. Note that for this method, it assumes <em>any</em> event
     * emitted by the given lifecycle indicates that the lifecycle is over.
     *
     * @param lifecycle the lifecycle sequence
     * @return a reusable {@link LifecycleTransformer} that unsubscribes the source whenever the lifecycle emits
     */
    @Nonnull
    @CheckReturnValue
    public static <T, R> LifecycleTransformer<T> bind(@Nonnull final Observable<R> lifecycle) {
        return new LifecycleTransformer<>(lifecycle);
    }

    /**
     * Binds the given source to a lifecycle.
     * <p>
     * This method determines (based on the lifecycle sequence itself) when the source
     * should stop emitting items. It uses the provided correspondingEvents function to determine
     * when to unsubscribe.
     * <p>
     * Note that this is an advanced usage of the library and should generally be used only if you
     * really know what you're doing with a given lifecycle.
     *
     * @param lifecycle the lifecycle sequence
     * @param correspondingEvents a function which tells the source when to unsubscribe
     * @return a reusable {@link LifecycleTransformer} that unsubscribes the source during the Fragment lifecycle
     */
    @Nonnull
    @CheckReturnValue
    public static <T, R> LifecycleTransformer<T> bind(@Nonnull Observable<R> lifecycle,
                                                      @Nonnull final Function<R, R> correspondingEvents) {
        checkNotNull(lifecycle, "lifecycle == null");
        checkNotNull(correspondingEvents, "correspondingEvents == null");
        return bind(takeUntilCorrespondingEvent(lifecycle.share(), correspondingEvents));
    }

    private static <R> Observable<Boolean> takeUntilCorrespondingEvent(final Observable<R> lifecycle,
                                                                       final Function<R, R> correspondingEvents) {
        return Observable.combineLatest(
            lifecycle.take(1).map(correspondingEvents),
            lifecycle.skip(1),
            new BiFunction<R, R, Boolean>() {
                @Override
                public Boolean apply(R bindUntilEvent, R lifecycleEvent) throws Exception {
                    return lifecycleEvent.equals(bindUntilEvent);
                }
            })
            .onErrorReturn(Functions.RESUME_FUNCTION)
            .filter(Functions.SHOULD_COMPLETE);
    }
}

最终执行到了 RxLifecycle 这个类源码里面的最后的两个方法!

4:takeUntilCorrespondingEvent()

takeUntilCorrespondingEvent这个方法内容较多,首先分析第一个,combineLatest操作符,这个操作符是指 将传进来的BehaviorSubject的事件进行了一次分割;假设我们现在在onCreate()方法里面进行RxLifecycle的绑定,那么这里的lifecycle.take(1).map(correspondingEvents)简单理解其对应的代码就是 RxLifecycleAndroid源码 里面的ACTIVITY_LIFECYCLE 中的,

 case CREATE:
 return ActivityEvent.DESTROY;

另外,lifecycle.skip(1)意味着除去第一个(ActivityEvent.CREATE),保留剩下的ActivityEvent枚举值

new BiFunction<R, R, Boolean>这行代码是对属性值进行判断:对比结果是
false,false,fasle,false,true

最后,onErrorReturn和filter这两行代码分别是对异常的处理以及判断是否应该结束订阅、

final class Functions {

    static final Function<Throwable, Boolean> RESUME_FUNCTION = new Function<Throwable, Boolean>() {
        @Override
        public Boolean apply(Throwable throwable) throws Exception {
            if (throwable instanceof OutsideLifecycleException) {
                return true;
            }

            //noinspection ThrowableResultOfMethodCallIgnored
            Exceptions.propagate(throwable);
            return false;
        }
    };

    static final Predicate<Boolean> SHOULD_COMPLETE = new Predicate<Boolean>() {
        @Override
        public boolean test(Boolean shouldComplete) throws Exception {
            return shouldComplete;
        }
    };

    static final Function<Object, Completable> CANCEL_COMPLETABLE = new Function<Object, Completable>() {
        @Override
        public Completable apply(Object ignore) throws Exception {
            return Completable.error(new CancellationException());
        }
    };

    private Functions() {
        throw new AssertionError("No instances!");
    }
}

综上:本次订阅,当Activity走到onStart生命周期时,为false,订阅不会取消,直到onDestroy,为true,订阅取消

5:最后调用的方法

根据逻辑,上面最终调用了下面的代码:

    public static <T, R> LifecycleTransformer<T> bind(@Nonnull final Observable<R> lifecycle) {
        return new LifecycleTransformer<>(lifecycle);
    }

可以看到,这里最终生成了一个LifecycleTransformer。

源码逻辑总结:

A:继承了RxAppCompatActivity的子类Activity,在每个生命的周期里,BehaviorSubject发射相对应的事件
B:bind方法主要是做赋值、匹配、判断
C:LifecycleTransformer内部进行takeUntil操作符,如果是true,就终止订阅,反之

如果这篇文章对你有帮助,希望各位看官留下宝贵的star,谢谢。

Ps:著作权归作者所有,转载请注明作者, 商业转载请联系作者获得授权,非商业转载请注明出处(开头或结尾请添加转载出处,添加原文url地址),文章请勿滥用,也希望大家尊重笔者的劳动成果。

上一篇:OpenvSwitch系列之十一 ovs-dpdk


下一篇:网易数帆基于DPDK的高性能四层负载均衡实践