开头：长期以来，Android架构都是我一直想要学习的目标，中间思考过很多方面，有的时候觉得要根据业务来，有的时候想脱离具体繁杂业务向上抽离出方向。如果有各位读者有这方面的经验，希望可以向我推荐。谢谢！
好了，接下来直接进入正题：
标题也可以看到，Android组建架构：Lifecycle，为什么要聊一聊这个呢？其实这个东西在一年前Google就有alpha版推出，不过那个时候因为各种原因没有继续研究学习，令人高兴的是google现在已经推出了release版本，并且 Lifecycle也正式植入了SupportActivity（AppCompatActivity的基类）和Fragment中，今天我们就来一起了解一下Lifecycle的实现原理和基本使用。
一、Lifecycle简介&基础使用
为什么要引进Lifecycle？
我们在处理Activity或者Fragment组件的生命周期相关时，不可避免会遇到这样的问题：
我们在Activity的onCreate()中初始化某些成员（比如MVP架构中的Presenter，或者AudioManager、MediaPlayer等），然后在onStop中对这些成员进行对应处理，在onDestroy中释放这些资源，这样导致我们的代码也许会像这样：
class MyPresenter{
public MyPresenter() {
}
void create() {
//do something
}
.
.//各个生命周期根据实际需要
.
void destroy() {
//do something
}
}
class MyActivity extends AppCompatActivity {
private MyPresenter presenter;
public void onCreate(...) {
presenter= new MyPresenter ();
presenter.create();
}
.
.//各个生命周期根据实际需要
.
public void onDestroy() {
super.onDestroy();
presenter.destory();
}
}
代码没有问题，关键问题是，实际生产环境中 ，这样的代码会非常复杂，你最终会有太多的类似调用并且会导致 onCreate() 和 onDestroy() 方法变的非常臃肿。
Lifecycle的解决方式
Lifecycle是一个类，它持有关于组件（如 Activity 或 Fragment）生命周期状态的信息，并且允许其他对象观察此状态。
1、Prestener继承LifecycleObserver接口
public interface IPresenter extends LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreate(@NotNull LifecycleOwner owner);
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void onDestroy(@NotNull LifecycleOwner owner);
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
void onLifecycleChanged(@NotNull LifecycleOwner owner,
@NotNull Lifecycle.Event event);
}
public class BasePresenter implements IPresenter {
private static final String TAG = "BasePresenter";
@Override
public void onLifecycleChanged(@NotNull LifecycleOwner owner, @NotNull Lifecycle.Event event) {
}
@Override
public void onCreate(@NotNull LifecycleOwner owner) {
Log.d("tag", "BasePresenter.onCreate" + this.getClass().toString());
}
@Override
public void onDestroy(@NotNull LifecycleOwner owner) {
Log.d("tag", "BasePresenter.onDestroy" + this.getClass().toString());
}
}
这里我直接将我想要观察到Presenter的生命周期事件都列了出来，然后封装到BasePresenter 中，这样每一个BasePresenter 的子类都能感知到Activity容器对应的生命周期事件，并在子类重写的方法中，对应相应行为。
2、在Activity/Fragment容器中添加Observer：
public class MainActivity extends AppCompatActivity {
private IPresenter mPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d("tag", "onCreate" + this.getClass().toString());
setContentView(R.layout.activity_main);
mPresenter = new MainPresenter(this);
getLifecycle().addObserver(mPresenter);//添加LifecycleObserver
}
@Override
protected void onDestroy() {
Log.d("tag", "onDestroy" + this.getClass().toString());
super.onDestroy();
}
}
如此，每当Activity发生了对应的生命周期改变，Presenter就会执行对应事件注解的方法：
除onCreate和onDestroy事件之外，Lifecycle一共提供了所有的生命周期事件，只要
通过注解进行声明，就能够使LifecycleObserver观察到对应的生命周期事件
二、原理分析
一图胜千言:
我们先将重要的这些类挑选出来：
LifecycleObserver接口（ Lifecycle观察者）：实现该接口的类，通过注解的方式，可以通过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册,被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。
LifecycleOwner接口（Lifecycle持有者）：实现该接口的类持有生命周期(Lifecycle对象)，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
Lifecycle(生命周期)：和LifecycleOwner不同的是，LifecycleOwner本身持有Lifecycle对象，LifecycleOwner通过其Lifecycle getLifecycle()的接口获取内部Lifecycle对象。
State(当前生命周期所处状态)：如图所示。
Event(当前生命周期改变对应的事件)：如图所示，当Lifecycle发生改变，如进入onCreate,会自动发出ON_CREATE事件。
了解了这些类和接口的职责，接下来原理分析就简单很多了，我们以Fragment为例，来看下实际Fragment等类和上述类或接口的联系：
1、Fragment：LifecycleOwner
Fragment(Activity同理，我们 本文以Fragment为例，下同)：实现了LifecycleOwner接口，这意味着Fragment对象持有生命周期对象（Lifecycle），并可以通过Lifecycle getLifecycle()方法获取内部的Lifecycle对象：
public class Fragment implements xxx, LifecycleOwner {
//...省略其他
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
可以看到，实现的getLifecycle()方法，实际上返回的是 LifecycleRegistry 对象，LifecycleRegistry对象实际上继承了 Lifecycle，这个下文再讲。
持有Lifecycle有什么作用呢？实际上在Fragment对应的生命周期内，都会发送对应的生命周期事件给内部的 LifecycleRegistry对象处理：
public class Fragment implements xxx, LifecycleOwner {
//...
void performCreate(Bundle savedInstanceState) {
onCreate(savedInstanceState); //1.先执行生命周期方法
//...省略代码
//2.生命周期事件分发
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
onStart();
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
onResume();
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
//3.注意，调用顺序变了
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
//...
onPause();
}
void performStop() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
//...
onStop();
}
void performDestroy() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
//...
onDestroy();
}
}
随着Fragment不同走到不同的生命周期，除了暴露给我们的生命周期方法onCreate/onStart/…./onDestroy等，同时，Fragment内部的Lifecycle对象（就是mLifecycleRegistry）还将生命周期对应的事件作为参数传给了 handleLifecycleEvent() 方法。
注意点1:你会发现Fragment中performCreate()、performStart()、performResume()会先调用自身的onXXX()方法，然后再调用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中会先LifecycleRegistry的handleLifecycleEvent()方法 ，然后调用自身的onXXX()方法。
时序图：
我们从图中可以看到，当Fragment将生命周期对应的事件交给其内部的Lifecycle处理后， LifecycleObserver （就是我们上文自定义的Presenter），就能够接收到对应的生命周期事件，这是如何实现的呢？
2、LifecycleRegistry：Lifecycle
首先确认一点，LifecycleRegistry 就是 Lifecycle 的子类：
public class LifecycleRegistry extends Lifecycle {
}
我们看一下 Lifecycle 类
public abstract class Lifecycle {
//注册LifecycleObserver （比如Presenter）
public abstract void addObserver(@NonNull LifecycleObserver observer);
//移除LifecycleObserver
public abstract void removeObserver(@NonNull LifecycleObserver observer);
//获取当前状态
public abstract State getCurrentState();
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
Lifecycle没什么要讲的，几个抽象方法也能看懂，作为Lifecycle的子类，LifecycleRegistry 同样也能通过addObserver方法注册LifecycleObserver （就是Presenter），当LifecycleRegistry 本身的生命周期改变后（可以想象，内部一定有一个成员变量State记录当前的生命周期），LifecycleRegistry 就会逐个通知每一个注册的LifecycleObserver ，并执行对应生命周期的方法。
我们看一下LifecycleRegistry 的handleLifecycleEvent()方法：
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
看方法的名字我们就可以知道，handleLifecycleEvent方法会通过 getStateAfter 获取当前应处的状态并修改 Lifecycle本身的State 值，紧接着遍历所 LifecycleObserver 并同步且通知其状态发生变化，因此就能触发LifecycleObserver 对应的生命周期事件。
