为什么需要Lifecycle组件
Lifecycle组件包括LifecycleOwner、LifecycleObserver。为什么需要Lifecycle组件？一项新的技术的提出肯定是为了解决痛点问题，如果使用过MVP模式的话，有个问题：Presenter感知Activity或者Fragment的生命周期？你可能会这样做，Presenter中定义多个和Activity或者Fragment相应的生命周期方法，然后在Activity或者Fragment中调用Presenter中定义的方法。比如下面的这个例子：
/**
* Main Presenter
*/
public class MainPresenter implements IPresenter {
public MainPresenter(Context context){
}
@Override
public void onCreate() {
}
@Override
public void onStart() {
}
@Override
public void onResume() {
}
@Override
public void onPause() {
}
@Override
public void onStop() {
}
@Override
public void onDestroy() {
}
}
public interface IPresenter {
void onCreate();
void onStart();
void onResume();
void onPause();
void onStop();
void onDestroy();
}
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private IPresenter mPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d(TAG, "onCreate: ");
setContentView(R.layout.activity_main);
mPresenter = new MainPresenter(this);
mPresenter.onCreate();
}
@Override
protected void onStart() {
super.onStart();
Log.d(TAG, "onStart: ");
mPresenter.onStart();
}
@Override
protected void onResume() {
super.onResume();
Log.d(TAG, "onResume: ");
mPresenter.onResume();
}
@Override
protected void onPause() {
super.onPause();
Log.d(TAG, "onPause: ");
mPresenter.onPause();
}
@Override
protected void onStop() {
super.onStop();
Log.d(TAG, "onStop: ");
mPresenter.onStop();
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy: ");
mPresenter.onDestroy();
}
}
上面的例子很容易理解，IPresenter中定义和生命周期相关的几个方法，然后在MainActivity中调用对应的方法。这样做会有个问题：在MainActivity中的每个生命周期方法中都要调用一次IPresenter中的接口，对于爱偷懒的程序员来说，这是不能接受的，所以Lifecycle组件就诞生了。
public class MainPresenter implements IPresenter {
private static final String TAG = "MainPresenter";
public MainPresenter(Context context){
}
@Override
public void onCreate(LifecycleOwner owner) {
Log.d(TAG, "onCreate: ");
}
@Override
public void onStart(LifecycleOwner owner) {
Log.d(TAG, "onStart: ");
}
@Override
public void onResume(LifecycleOwner owner) {
Log.d(TAG, "onResume: ");
}
@Override
public void onPause(LifecycleOwner owner) {
Log.d(TAG, "onPause: ");
}
@Override
public void onStop(LifecycleOwner owner) {
Log.d(TAG, "onStop: ");
}
@Override
public void onDestroy(LifecycleOwner owner) {
Log.d(TAG, "onDestroy: ");
}
}
public interface IPresenter extends DefaultLifecycleObserver{
}
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private IPresenter mPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d(TAG, "onCreate: ");
setContentView(R.layout.activity_main);
mPresenter = new MainPresenter(this);
getLifecycle().addObserver(mPresenter);
}
@Override
protected void onStart() {
super.onStart();
Log.d(TAG, "onStart: ");
}
@Override
protected void onResume() {
super.onResume();
Log.d(TAG, "onResume: ");
}
@Override
protected void onPause() {
super.onPause();
Log.d(TAG, "onPause: ");
}
@Override
protected void onStop() {
super.onStop();
Log.d(TAG, "onStop: ");
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy: ");
}
}
代码也很简单，IPrestener接口继承DefaultLifecycleObserver接口，然后MainPresenter实现IPresenter接口，在MainPresenter中，我把DefaultLifecycleObserver中生命周期的方法全实现了，也可以选择实现其中几个，比如你只关心MainActivity的onCreate() 和onDestroy()，那么你就可以在MainPresenter中实现onCreate()和onDestroy()方法。借助实现DefaultLifecycleObserver接口可以让我们少写很多代码。知道为什么需要Lifecycle组件后，你可能会问了，Lifecycle组件实现的原理是什么？这就是下面我要将的内容了。
Lifecycle组件原理
一般讲到原理，你可能会看到一堆文字的描述，然后就没有看下去的欲望了，能不能来点生动的，比如带点颜色的？好，我懂你，来张高清无码图。
我们以V4包中的Fragment（AppCompatActivity类似）为例，看下Fragment和LifecycleOwner、LifecycleObserver、Lifecycle之间的类关系图。
Lifecycle组件成员Lifecycle被定义成了抽象类，LifecycleOwner、LifecycleObserver被定义成了接口；
Fragment实现了LifecycleOwner接口，该只有一个返回Lifecycle对象的方法getLifecyle()；
Fragment中getLifecycle()方法返回的是继承了抽象类Lifecycle的LifecycleRegistry。
-
LifecycleRegistry中定义嵌套类ObserverWithState，该类持有GenericLifecycleObserver对象，而GenericLifecycleObserver是继承了LifecycleObserver的接口。
对于Fragment、Lifecycle、LifecycleOwner、LifecycleObserver的关系有了一定了解后，可以看一个更直观的图，也就是下面的时序图：
我们在Fragment（AppCompatActivity也一样）中调用getLifecycle()方法得到LifecycleRegistry对象，然后调用addObserver()方法并将实现了LifecycleObserver接口的对象作为参数传进去。这样一个过程就完成了注册监听的过程。
后续就是Fragment生命周期变化时，通知LifecycleObserver的过程：Fragment的performXXX()、onXXX()方法；LifecycleRegistry的handleLifecycleEvent()方法；LifecycleObserver的onXXX()方法。
-
如果你细心点看上面的时序图，你会发现Fragment中performCreate()、performStart()、performResume()会先调用自身的onXXX()方法，然后再调用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中会先LifecycleRegistry的handleLifecycleEvent()方法 ，然后调用自身的onXXX()方法。比如上面的例子中，打印出来的结果也确实符合我们的分析，打印结果如下：
12-01 14:12:59.250 1398-1398/com.shymanzhu.architecture D/MainActivity: onCreate: 12-01 14:12:59.342 1398-1398/com.shymanzhu.architecture D/MainPresenter: onCreate: 12-01 14:12:59.345 1398-1398/com.shymanzhu.architecture D/MainActivity: onStart: 12-01 14:12:59.345 1398-1398/com.shymanzhu.architecture D/MainPresenter: onStart: 12-01 14:12:59.346 1398-1398/com.shymanzhu.architecture D/MainActivity: onResume: 12-01 14:12:59.346 1398-1398/com.shymanzhu.architecture D/MainPresenter: onResume: 12-01 14:12:59.601 1398-1412/com.shymanzhu.architecture D/OpenGLRenderer: Use EGL_SWAP_BEHAVIOR_PRESERVED: true 12-01 14:12:59.609 1398-1398/com.shymanzhu.architecture I/imx6.gralloc: open gpu gralloc module! 12-01 14:12:59.847 1398-1412/com.shymanzhu.architecture I/OpenGLRenderer: Initialized EGL, version 1.4 12-01 14:13:27.348 1398-1398/com.shymanzhu.architecture D/MainPresenter: onPause: 12-01 14:13:27.349 1398-1398/com.shymanzhu.architecture D/MainActivity: onPause: 12-01 14:13:28.265 1398-1398/com.shymanzhu.architecture D/MainPresenter: onStop: 12-01 14:13:28.266 1398-1398/com.shymanzhu.architecture D/MainActivity: onStop: 12-01 14:13:28.267 1398-1398/com.shymanzhu.architecture D/MainPresenter: onDestroy: 12-01 14:13:28.267 1398-1398/com.shymanzhu.architecture D/MainActivity: onDestroy:
到现在为止，是不是觉得对大体的框架和流程更加清楚了呢，其实这个Lifecycle组件就是一套设计模式中观察者模式的例子。按道理说，到这里也差不多结束了，具体的细节就是去跟源码了（既然这么说了，肯定有“但是”，机智如你），但是我觉得还是有必要将一些细节说明下。
部分细节
LifecycleOwner、LifecycleObserver、Lifecycle的定义都很简洁，就没必要列举出来了，我们从流程图可以看出来，我们要做的内容主要是实现LifecycleObserver接口，然后通过实现了LifecycleOwner接口的对象进行注册，以监听其生命周期，后续就是坐等通知了。
实现LifecycleObserver接口
从上面的类关系图，我们可以看到有三个接口GenericLifecycleObserver、FullLifecycleObserver、DefaultLifecycleObserver都直接或者间接继承了LifecycleObserver。然而GenericLifecycleObserver是隐藏的，我们用不了。那我们该怎么实现LifecycleObserver接口呢，有两种方式：
- 实现DefaultLifecycleObserver接口，然后重写里面生命周期方法；
- 直接实现LifecycleObserver接口，然后通过注解的方式来接收生命周期的变化；
对于这两种形式，Lifecycle.java文档中是建议使用第一种方式，因为文档中说明了，随着Java8成为主流，注解的方式会被弃用。
添加观察者
实现LifecycleOwner没什么好说的，我们直接看添加观察者（ addObserver() ），LifecycleRegistry实现了Lifecycle接口，addObserver()实现如下：
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
在该方法中主要关注一点：
- 根据observer和initialState构造ObserverWithState对象statefulObserver，然后将该对象存入mObserverMap，可以简单的把它理解成用来保存观察者的Map。
坐等通知
添加观察者后，那观察者接下来就是坐等通知了。从上面的时序图中，我们看到Fragment是通过LifecycleRegistry.handleLifecycleEvent()方法通知LifecycleRegistry其生命周期的，那我们看下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(); //看下sync()方法的具体实现
mHandlingEvent = false;
}
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
+ "new events from it.");
return;
}
while (!isSynced()) {
mNewEventOccurred = false;
// no need to check eldest for nullability, because isSynced does it for us.
//比较当前的生命周期和Map中第一个的观察者的生命周期，下面的另一个if语句类似。
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);
}
}
mNewEventOccurred = false;
}
//看下forwardPass()方法
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
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;
}
}
代码中大体的细节就是这样子，当然更细的内容只能通过你自己去了解了，建议明白Lifecycle组件的框架和结构后，再去看它实现的细节，而不是一上来就深究代码，那让会让你只见树木不见森林。
