JetPack架构---Lifecycle生命周期相关与原理
Posted 战国剑
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JetPack架构---Lifecycle生命周期相关与原理相关的知识，希望对你有一定的参考价值。
一、概念
Lifecycle是JetPack提供的生命周期感知型组件。这也是JetPack系列架构的一个主要基础组件。LiveData、ViewModel都与之相关。
Lifecycle常用于感知Activity、Fragment的生命周期。通过它可以编写与生命周期相关的解耦的代码。将Lifecycle传入某个类中，可以让该类与外部组件的生命周期关联。
二、使用示例
2-0：添加依赖
参照官网提示，添加具体依赖（点击查看）
2-1：定义一个观察者
//定义一个观察者
public class MyObserver implements LifecycleObserver
private static final String TAG = "MyObserver";
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void whenOnCreated()
Log.d(TAG, "生命周期OnCreated");
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void whenOnResumed()
Log.d(TAG, "生命周期OnResumed");
2-2：在Activity的onCreate中添加观察者
//添加观察者
getLifecycle().addObserver(new MyObserver());以上操作后，自定义的观察者MyObserver即可在activity的生命周期变换时，感知具体变换，并打印日志。
三、Lifecycle相关类
Lifecycle的机制，本质上是观察者模式，包含被观察者LifecycleOwner，观察者LifecycleObserver。
（1）LifecycleObserver:是一个空方法接口，用于标识观察者。
（2）LifecycleOwner: 是一个接口，持有方法Lifecycle getLifecycle()。
2-1：Lifecycle 是一个抽象类，该类含有addObserver、removeObserver等方法，以及生命周期的定义。
2-2：LifecycleRegistry 是Lifecycle的具体实现类，含有mObserverMap这样存储LifecycleObserver的集合。
四、源码分析
以前面的示例为例，在Activity中为何可以直接使用getLifecycle()方法并添加观察者-addObserver。
4-1：被观察者的定义与实现
ComponentActivity实现了LifecycleOwner接口以及该接口下的getLifecycle()方法。
//（1）ComponentActivity 实现LifecycleOwner接口
public class ComponentActivity extends Activity implements LifecycleOwner ...
//（2）getLifecycle()方法实现，返回Lifecycle类型对象
@NonNull
@Override
public Lifecycle getLifecycle()
return mLifecycleRegistry;
//--------以下备注mLifecycleRegistry的实现------------
//（3）中的mLifecycleRegistry实例。其中LifecycleRegistry的构造方法，传入了ComponentActivity的
// 实例（也即是LifecycleOwner的实例）
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
//（4）构造参数中传入的LifecycleOwner对象，会用于生命周期变动时的通知。
public class LifecycleRegistry extends Lifecycle
....
public LifecycleRegistry(@NonNull LifecycleOwner provider)
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
...
假设前面创建的Activity名为MainActivity。因MainActivity都是默认继承AppCompatActivity，而AppCompatActivity继承至ComponentActivity。则MainActivity默认实现了LifecycleOwner接口，是一个被观察者对象。
4-2：观察者的添加
此时通过getLifecycle().addObserver(new MyObserver());添加具体观察者对象，内部流程如下：
在4-1中，有说明getLifecycle()的具体实现，返回了Lifecycle的实现对象mLifecycleRegistry。因此，getLifecycle().addObserver实际会在mLifecycleRegistry中，进行添加观察者。
//mObserverMap 是LifecycleRegistry中定义的一个Map集合，用于存储观察者
@Override
public void addObserver(@NonNull LifecycleObserver observer)
....
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
....
至此，被观察者与观察者已被定义与添加完成。具体什么时候触发观察者的回调？见4-3
4-3：观察者回调触发时机
还是接着看ComponentActivity的onCreate方法。
//(1)ComponentActivity的onCreate中，ReportFragment.injectIfNeededIn(this)。将本activity的实
//例传入到了ReportFragment中
public class ComponentActivity extends Activity implements
LifecycleOwner,
KeyEventDispatcher.Component
....
@SuppressLint("RestrictedApi")
@Override
protected void onCreate(@Nullable Bundle savedInstanceState)
super.onCreate(savedInstanceState);
//此处是重点。
ReportFragment.injectIfNeededIn(this);
....
//(2)injectIfNeededIn该方法是ReportFragment中的静态方法
public class ReportFragment extends Fragment
public static void injectIfNeededIn(Activity activity)
//此处创建了一个新的Fragment（ReportFragment）
//如果FragmentManager中已有该Fragment，则不会重复创建
// use a framework fragment to get the correct timing of Lifecycle events
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null)
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions();
//（3）因ReportFragment绑定了ComponentActivity。ReportFragment的生命周期可通过下面方式对外通知
@Override
public void onActivityCreated(Bundle savedInstanceState)
super.onActivityCreated(savedInstanceState);
//onCreate事件
dispatch(Lifecycle.Event.ON_CREATE);
@Override
public void onStart()
super.onStart();
//onStart事件
dispatch(Lifecycle.Event.ON_START);
@Override
public void onResume()
super.onResume();
//onResume事件
dispatch(Lifecycle.Event.ON_RESUME);
@Override
public void onPause()
//onPause事件
dispatch(Lifecycle.Event.ON_PAUSE);
@Override
public void onStop()
//onStop事件
dispatch(Lifecycle.Event.ON_STOP);
@Override
public void onDestroy()
super.onDestroy();
//onDestroy事件
dispatch(Lifecycle.Event.ON_DESTROY);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
//（4）dispatch的具体实现如下
private void dispatch(@NonNull Lifecycle.Event event)
if (Build.VERSION.SDK_INT < 29)
//该注释说明以上路线只针对SDK_INT < 29的情况，大于29的情况，会从另一条路线走，暂不
//分析，原理类似
// Only dispatch events from ReportFragment on API levels prior
// to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
// added in ReportFragment.injectIfNeededIn
dispatch(getActivity(), event);
//(5)dispatch(getActivity(), event)具体内容
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event)
...
//此时会走到该逻辑
if (activity instanceof LifecycleOwner)
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry)
//最终还是会到LifecycleRegistry中，执行handleLifecycleEvent方法
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
//（6）LifecycleRegistry中handleLifecycleEvent
public void handleLifecycleEvent(@NonNull Lifecycle.Event event)
//获取下一步状态
State next = getStateAfter(event);
//移动至下一步
moveToState(next);
private void moveToState(State next)
if (mState == next)
return;
mState = next;
if (mHandlingEvent || mAddingObserverCounter != 0)
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
mHandlingEvent = true;
//同步观察者与被观察者
sync();
mHandlingEvent = false;
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);
//（7）同步观察者与被观察者sync()
private void sync()
while (!isSynced())
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0)
//后退
backwardPass(lifecycleOwner);
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0)
//前进
forwardPass(lifecycleOwner);
//(8)无论是backwardPass或者forwardPass方法，最终都调用：observer.dispatchEvent(...),用于回调
// 观察者
observer.dispatchEvent(lifecycleOwner, event);
//以上的observer是经过ObserverWithState封装的，是ObserverWithState中LifecycleEventObserver的
//实例。
static class ObserverWithState
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState)
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
void dispatchEvent(LifecycleOwner owner, Event event)
State newState = getStateAfter(event);
mState = min(mState, newState);
//最终触发观察者回调的地方
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
//（9）-----------以下备注（8）中LifecycleEventObserver对象mLifecycleObserver的定义----------
9-1：mLifecycleObserver实例
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
9-2：lifecycleEventObserver(Object object)
static LifecycleEventObserver lifecycleEventObserver(Object object)
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
if (isLifecycleEventObserver && isFullLifecycleObserver)
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
....
9-3:FullLifecycleObserverAdapter
class FullLifecycleObserverAdapter implements LifecycleEventObserver
private final FullLifecycleObserver mFullLifecycleObserver;
private final LifecycleEventObserver mLifecycleEventObserver;
FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
LifecycleEventObserver lifecycleEventObserver)
mFullLifecycleObserver = fullLifecycleObserver;
mLifecycleEventObserver = lifecycleEventObserver;
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event)
....
//回调onStateChanged
if (mLifecycleEventObserver != null)
mLifecycleEventObserver.onStateChanged(source, event);
以上是Lifecycle的源码流程梳理。
Lifecycle做为一个android提供的生命周期组件，除了以上介绍的用法外，还可以用于传入你需要生命周期的自定义组件中。管理组件的资源释放、数据处理、UI是否刷新等，有助于整体的稳定性、减少内存泄漏、代码简洁化等。
以上是关于JetPack架构---Lifecycle生命周期相关与原理的主要内容，如果未能解决你的问题，请参考以下文章
Android Jetpack架构组件——Lifecycle使用篇
Android jetpack架构组件Lifecycle实战与源码解析