横向对比Jetpack、RxJava、Glide框架中对组件生命周期Lifecycle感知原理

super.onAttach(context);
registerFragmentWithRoot(getActivity());
}

@Override
public void onDetach() {
super.onDetach();
unregisterFragmentWithRoot();
}
…

• RequestManagerFragment在构造函数中默认创建一个ActivityFragmentLifecycle类型的成员变量。
• 在attach中registerFragmentWithRoot(),在onDetach()中unregisterFragmentWithRoot();
• 在RequestManagerFragment的对象中onStart（），onStop，中调用Lifecycle的响应函数
• 在RequestManager当中会向ActivityFragmentLifecycle注册监听对象，于是RequestManager就会对组件生命周期做出相应的反应。
• 另外当该Fragment作为一个子Fragment被添加到Fragment当中感知Fragment时，涉及到子Fragment管理可参考

1.5、RequestManager对Activity/Fragment生命周期感知

public class RequestManager implements LifecycleListener
protected final Glide glide;
protected final Context context;
final Lifecycle lifecycle;
private final RequestTracker requestTracker;
…
RequestManager(…) {
…
//RequestManager将自身注册到Lifecycle中也就是RequestManagerFragment中的Lifecycle
lifecycle.addListener(this);
lifecycle.addListener(connectivityMonitor);
}
public synchronized boolean isPaused() {
return requestTracker.isPaused();
}
public synchronized void pauseRequests() {
requestTracker.pauseRequests();
}
public synchronized void pauseAllRequests() {
requestTracker.pauseAllRequests();
}
public synchronized void resumeRequests() {
requestTracker.resumeRequests();
}
//相应的生命周期函数中使用处理土拍你请求
@Override
public synchronized void onStart() {
resumeRequests();
targetTracker.onStart();
}
@Override
public synchronized void onStop() {
pauseRequests();
targetTracker.onStop();
}
//在onDestoty中取消解除绑定释放请求中的设计的资源
@Override
public synchronized void onDestroy() {
targetTracker.onDestroy();
targetTracker.clear();
requestTracker.clearRequests();
lifecycle.removeListener(this);
…
glide.unregisterRequestManager(this);
}
}

• RequestManager实现了LifecycleListener,且创建的时候传入了Lifecycle参数赋值给成员变量。
• 被该RequestManager管理的请求都存放在RequestTracker对象这个成员变量属性中。
• RequestManager通过Lifecycle感知组件生命周期变化，在相应的生命周期状态下实现的LifecyleListener对应的回调函数会被执行，然后通过RequestTracker管理自己所关联的Request对象们。

Glide中Lifecycle小结

为一个Request拥有所在组件的感知能力需要以下步骤：
1.从给定的组件（Fragment/FragmentActivity/Activity…）获取出FragmentManager。

2.创建一个不带界面的Fragment（SupportRequestManagerFragment/RequestManagerFragment),这个不带界面的Frament有个Lifecycle成员变量，在Fragment创建的时候被初始化，用于监听此Fragment的生命周期。

3.将不带界面的Frament添加进给定组件。

4.创建RequestManager，RequestManager实现了LifecycleListener，创建的时候会传入无界面fragment中成员Lifecyle，RequestManager会把自己注册到Lifecycle中，这样RequestManager就拥有了感知组件生命周期的能力。

2、RxLifecycle

对RxLifecycle原理分析主要是依据trello的RxLifecycle，github传送门点这里

2.1、简单使用

在Activity中使用为例，主要是使用以下两个方法：

bindUntilEvent(@NonNull ActivityEvent event)

bindToLifecycle()

使用的姿势是这样的：当Activity 回调onDestory生命周期函数的时候，就会解除订阅。

Observable.interval(1, TimeUnit.SECONDS)
.compose(bindUntilEvent(ActivityEvent.DESTROY))
.subscribe();

2.2、RxActivity构成

追根溯源看看 要先理解Rxjava2中compose()操作符的含义 compose操作符是在不破坏rxjava流式基础上把当前的Observable转换为另一个Observable，传入的是一个Transformer对象使用。更为详细的关于这个操作符的介绍点这

public abstract class RxActivity extends Activity implements LifecycleProvider {

private final BehaviorSubject lifecycleSubject = BehaviorSubject.create();
@CheckResult
public final LifecycleTransformer bindUntilEvent(@NonNull ActivityEvent event) {
return RxLifecycle.bindUntilEvent(lifecycleSubject, event);
}

public final LifecycleTransformer bindToLifecycle() {
return RxLifecycleAndroid.bindActivity(lifecycleSubject);
}

protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
lifecycleSubject.onNext(ActivityEvent.CREATE);
}
…
…
protected void onDestroy() {
lifecycleSubject.onNext(ActivityEvent.DESTROY);
super.onDestroy();
}
}

• Activity中有个一个BehaviorSubject的成员变量：lifecycleSubject。BehaviorSubject会发送离订阅最近的上一个值，当没有最近值的的时候会发送默认值。
• bindUntilEvent(ActivityEvent avt)最终会返回一个Transformer作为compose()方法的参数。
• bindUtliEvent方法是RxActivity实现了LifecycleProvider接口的方法，他的实现转交到了RxLifecycle.bindUntilEvent()

2.3 LifecycleTransformer构建

关于Transformer构建在RxlifeCycle类中主要是以下三个方法：

@CheckReturnValue
public static <T, R> LifecycleTransformer bindUntilEvent(@Nonnull final Observable lifecycle,@Nonnull final R event) {
…判空
return bind(takeUntilEvent(lifecycle, event));
}

使用filter()操作符，获取一个过滤出传入的指定事件，其他事件不向下游分发的Observer，也就是只发送指定事件的Observable。

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

将上一步得到的Observable其实是一个BehaviorSubject，当做构造参数传入LifecycleTransformer

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

2.4 LifecycleTransformer原理

看看LifecyclerTranformer里卖的啥药

public final class LifecycleTransformer implements ObservableTransformer<T, T>,
FlowableTransformer<T, T>,
SingleTransformer<T, T>,
MaybeTransformer<T, T>,
…
@Override
public ObservableSource apply(Observable upstream) {
return upstream.takeUntil(observable);
}
…

}

真相大白，对upstream也就是我们使用时，xxx.compose()时的那个Observerable进行了takeUtil（）操作。 takeUtil的语义是

---

Returns an Observable that emits the items emitted by the source Observable until a second ObservableSource emits an item. 返回一个发送事件的观察源，直到第二个被观察者发送数据。

综上 当给被观察序列compose了Transformer对象后，会在相应的生命周期函数中终止。

2.5 小结

• Activity中有个BehaviorSubject 在Activity的生命周期回调函数中发送向其发送相应的事件。
• 主要原理就是通过LifecycleProvider的bindUtilEvent方法构建LifecycleTransformr;
• LifecycleTransformer里面的apply操作就是将Observable进行TakeUtil操作。这个操作的效果就是中断上游Observerable的发送Observer取消。比如调用了bindUtilEvent（DESTORY_EVENT）也就是当原始的Observer接收到Event事件的时候就会取消解除Observer监听。

3、Jetpack Lifecycle

3.1、SupportActivity中对Lifecycle支持

SupportActivity类实现了LifecycleOwner结构

• Activity onCreate方法中调用了ReportFragment的injectIfNeedIn()方法

public class SupportActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
public Lifecycle getLifecycle() {
return this.mLifecycleRegistry;
}

• SupportActivity实现了LifecleOwner接口，这个接口只有一个方法geLifecycle();
• SupportActivity对这个接口的实现就是返回他的成员变量，LifecycleRegistry类型的成员变量。

3.2、ReportFragment生命周期变更

具有感知所在组件的能力在相应的生命周期回调函数里向LifecycleRegistry分发事件。

ReportFragment

public static void injectIfNeededIn(Activity activity) {
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
//立即执行拒绝异步
manager.executePendingTransactions();
}
}

private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
/2/
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}

注释2处

• 如果Activity实现了LifecyclerOwener,LifecycleOwner接口中方法就是返回一个Lifecycle。
• Lifecycle的实现类LifecycleRegistry，LifecycleRegistry负责管理和分发生命周期状态。
• manager.executePendingTransactions();表示立即执行，transaction是异步的。FragmentManager的Transaction是异步执行了，如果想要立即执行就使用commitNow他表示当前的commit直接执行；executePendingTransactions()会将所有pending在队列中还有你新提交的transactions都执行了。

3.3、处理生命周期事件LifecycleRegistry

先来一张官方的图

Jetpack对组件生命周期的管理有两个核心的概念事件（Event）和状态（State）。 他们直接的关系是事件驱动状态的转换。

一共有五种状态，五种状态之间是怎样通过事件驱动的方式实现转换的呢，如上图所示，

• INITIALIZED：这是一种初始状态。。
• DESTROYED ：死亡状态，ON_DESTORY事件驱动进入这种状态。
• CREATED ：创建状态，ON_CREATE事件和STOP事件驱动进入这种状态，ON_STOP事件驱动离开这种状态。
• STARTED : 开始状态，On_START事件和ON_PAUSE事件驱动进出该种状态，ON_RESUME和ON_STOP驱动离开该种状态。
• RESUME:ON_RESUME事件驱动进入该种状态，ON_PAUSE事件驱动离开这种状态。

图看百遍其意自现，其实当我们得知某种事件之后就能准确的得知出他将进入的状态体现就是在LifecycleRegistry的getStateAfter()方法中，就不用文字描述了很代码很能说明问题。

static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}

LifecycleRegistry实现了Lifecyle抽象类，是生命周期监听者和分发生命周期事件的实际管理和分发者。其中的方法

• public void addObserver(LifecycleObserver observer)继承自父类Lifecycle，添加生命周期监听。
• public void removeObserver( LifecycleObserver observer)继承自父类Lifecycle,移除某个生命周期监听。
• public void handleLifecycleEvent(Lifecycle.Event event)通知监听者最新的声明周期，并且存储。

3.3.1 通知更改 handleLifecycleEvent

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}

根据事件能获取到组件进入的下一个状态，然后将通知监听改变状态 ：moveToState(next);MoveToState（）方中，修改LifecycleRegistry中mState状态，然后调用 sync()方法。

private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();

LifecycleRegistry中有mObserverMap存储这生命周期观察者，FastSafeIterableMap是一个Map的数据结构,key为LifecycleObserver,value为ObserverWithState。

static class ObserverWithState {
State mState;
GenericLifecycleObserver mLifecycleObserver;

ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.getCallback(observer);
mState = initialState;
}

void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}

结

Glide vs RXJava vs Jetpack

• Glide作为一个加载图片的框架，当我们使用Glide.with(View/Fragment/View)时获取出具有感知组件生命周期的RequestManager并在相应的生命周期中开始/暂停/结束请求，结束是释放相应资源。对组件生命周期的感知的核心原理向Request/Activity中放入一没有界面的RequestManagerFragment，再相应的生命周期回调函数里调用方法通知外界注册了监听函数的监听者。
• Jetpack中对生命周期的管理其核心思想和Glide类似，也是放入向组件中放入一个无界面的ReportFragment，这个ReportFragment就拥有和组件同步的生命周期，依此来向外界通知生命状态，监听者做相应的处理。两个也是有不同，比如Glide关心onStart(),onStop()和onDestory()三个生命周期监听并且在相应的生命周期回调函数中做了相应的处理，在onStart（）中重试暂停或者失败的请求，在onStop中取消正在进行的请求，在destory中释放资源等。而Jetpack对 onCreate、onStart、onResume、onPause、onStop和onDestroy都做了监听，这样对监听者提供更了更全面的状态通知。
• RxLifecycle中使用Compose和TakeUnitl操作符，告诉在指定的生命周期状态下终止操作，相对于Glide和Jetpack中对生命周期的管理显得单薄，而且如果要直接使用的话还要集成RxActivity或者RxFragment，当然也可以自己实现用BehaviorSubject自己实现，但总的来说侵入性强。takeutil操作符带来的问题就是当操作被终止后还是会发送onComplete或者onError事件，这对于在这两个方法中有业务处理的情况来说不是一个优雅的实现。于是看到了知乎团队基于无界面Fragment感知组件生命周期的思想，实现了一套RxLifecycle有兴趣的可以参考知乎RxLifecycle

留点念想

• takeUntil()操作符是内部怎么做到中止操作的？
• Glide除了感知组件的生命周期是怎么感知网络变化并作出相应处理的？
• 关于对Jetpack中对组件生命周期监听的具体应用在LiveData和ViewModule中都有体现，他们是怎么工作的？
  自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总）

面试成功其实是必然的，因为我做足了充分的准备工作，包括刷题啊，看一些Android核心的知识点，看一些面试的博客吸取大家面试的一些经验，下面这份PDF是我翻阅了差不多1个月左右一些Android大博主的博客从他们那里取其精华去其糟泊所整理出来的一些Android的核心知识点， 全部都是精华中的精华，我能面试到现在资深开发人员跟我整理的这本Android核心知识点有密不可分的关系，在这里本着共赢的心态分享给各位朋友。

这份PDF囊括了JVM，Java集合，Java多线程并发，Java基础，生命周期，微服务， 进程,Parcelable 接口，IPC，屏幕适配,线程异步,ART，架构，Jetpack，NDK开发，计算机网络基础，类加载器，Android 开源库源码分析，设计模式汇总，Gradle 知识点汇总…

由于篇幅有限，就不做过多的介绍，大家请自行脑补

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

的精华，我能面试到现在资深开发人员跟我整理的这本Android核心知识点有密不可分的关系，在这里本着共赢的心态分享给各位朋友。
[外链图片转存中…(img-gpiDSzO4-1713674816857)]

这份PDF囊括了JVM，Java集合，Java多线程并发，Java基础，生命周期，微服务， 进程,Parcelable 接口，IPC，屏幕适配,线程异步,ART，架构，Jetpack，NDK开发，计算机网络基础，类加载器，Android 开源库源码分析，设计模式汇总，Gradle 知识点汇总…

由于篇幅有限，就不做过多的介绍，大家请自行脑补

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！