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

2401_84009529

于 2024-05-10 17:25:58 发布

阅读量606

点赞数 16

分类专栏：程序员文章标签： rxjava glide android

本文链接：https://blog.csdn.net/2401_84009529/article/details/138674515

版权

程序员专栏收录该内容

264 篇文章 0 订阅

订阅专栏

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中都有体现，他们是怎么工作的？

文末

架构师不是天生的，是在项目中磨练起来的，所以，我们学了技术就需要结合项目进行实战训练，那么在Android里面最常用的架构无外乎 MVC，MVP，MVVM，但是这些思想如果和模块化，层次化，组件化混和在一起，那就不是一件那么简单的事了，我们需要一个真正身经百战的架构师才能讲解透彻其中蕴含的深理。

移动架构师

系统学习技术大纲

一线互联网Android面试题总结含详解（初级到高级专题）

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！
结合项目进行实战训练，那么在Android里面最常用的架构无外乎 MVC，MVP，MVVM，但是这些思想如果和模块化，层次化，组件化混和在一起，那就不是一件那么简单的事了，我们需要一个真正身经百战的架构师才能讲解透彻其中蕴含的深理。

[外链图片转存中…(img-8gJIF39t-1715333147367)]

[外链图片转存中…(img-5m3SonAf-1715333147368)]

一线互联网Android面试题总结含详解（初级到高级专题）

[外链图片转存中…(img-YocPr4Yw-1715333147368)]

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！