Android架构组件（一）：Lifecycle
前言
谷歌在17年发布了Android架构组件1.0稳定版，用来帮助开发者们简化开发流程，并为App的开发架构提供指南。这次发布的架构包含了声明周期管理，数据持久性等提供了一系列库，并且该架构相互之间完美的融合到了一起，有助于我们使用更少的样板代码写出模块化的App。
他们包含：
- Lifecycle（生命周期管理）
- LiviData（基于观察者模式的可感知生命周期的数据持有类）
- Viewmodel（将view和model分开的组件）
- Room（简单强大的数据存储组件）
接下来我会用一系列文章和大家一起了解和使用这些组件。
系列文章也会收录到我的博客（Power）里，方便大家查阅。
好了，首先我们先来学习下基础组件：Lifecycle
什么是Lifecycle？
在讲解之前，我们先来分析下没用该组件之前我们常用的MVP模式中，Presenter是如何绑定activity/Fragment的生命周期？
//presenter
Public class Presenter{
public void attachView(T view) {
//do something
}
public void detachView() {
//do something
}
}
//activity
public class Activity extends AppCompatActivity{
private Presenter presenter;
public void onCreate(...) {
presenter= new Presenter();
presenter.attachView(this);
}
public void onDestroy() {
super.onDestroy();
presenter.detachView();
}
}
相信大多数开发者对上述代码很清楚了，我们常把activity和prsenter的绑定和分离都写在了base基类里用于同步两者的生命周期。上述的代码并没有什么逻辑错误，不过接下来的Lifecycle会让生命周期管理变得更加丝滑~
/*
* presenter继承LifecycleObserver
* 1.通过注解的方式实现Lifecycle的观察者方法
*/
Public class Presenter extends LifecycleObserver{
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
void onAny(LifecycleOwner owner, Lifecycle.Event event) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreate() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void onDestroy() {
}
}
/*
* 在activity里添加Observer
*/
public class Activity extends AppCompatActivity{
private Presenter presenter;
public void onCreate(...) {
presenter= new Presenter();
//2.添加LifecycleObserver实现同步
getLifecycle().addObserver(presenter);
}
public void onDestroy() {
super.onDestroy();
}
}
通过上述代码我们了解到，presenter通过继承LifecycleObserver实现生命周期方法，并在activity/Fragment中addObserver()中传入presenter对象就可以绑定两者的生命周期了。而且Lifecycle提供了所有的生命周期事件，选择你所需要的生命周期并通过注解进行声明就可以了。
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
void onAny(LifecycleOwner owner, Lifecycle.Event event) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreate() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void onDestroy() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void onStart() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
void onStop() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void onResume() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause() {
}
那么，Lifecycle的工作原理是什么？我们继续分析。
Lifecycle的工作原理
我们先祭出一张整体架构图：
我们来看下大致的工作原理：
- Lifecycle（生命周期）：该抽象类提供了addOberserver，removeObser，getCurrentState抽象方法，生命周期的事件和状态的枚举类。
public abstract class Lifecycle {
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
@NonNull
public abstract State getCurrentState();
@SuppressWarnings("WeakerAccess")
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
-
LifecycleObserver接口（Lifecycle观察者）：实现该接口的类，通过注解的方式，可以通过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册,被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。
-
LifecycleOwner接口（Lifecycle持有者）：实现该接口的类持有生命周期(Lifecycle对象)，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
该接口提供了getLifecycle()方法返回Lifecycle对象
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
activity继承的AppCompatActivity父类v4包里的FragmentActivity已经实现了该接口，
v4包里的fragment同理也替我们实现了LifecycleObserver接口。
//AppCompatActivity继承自FragmentActivity继承自SupportActivity，该类里的getLifecycle()方法返回了lifecycle对象
public class FragmentActivity extends SupportActivity implements ViewModelStoreOwner, OnRequestPermissionsResultCallback, RequestPermissionsRequestCodeValidator {
...
public Lifecycle getLifecycle() {
return super.getLifecycle();
}
}
public class SupportActivity extends Activity implements LifecycleOwner, Component {
...
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
public Lifecycle getLifecycle() {
return this.mLifecycleRegistry;
}
}
//fragment同理，就不贴代码了，大家可以去源码里查看。
从上述的代码我们不难发现，实现的getLifecycle()方法，实际上返回的是 LifecycleRegistry对象，LifecycleRegistry对象实际上继承了Lifecycle
public class LifecycleRegistry extends Lifecycle {
...
}
那么持有Lifecycle对象有什么作用呢？实际上Fragment已经给出了答案。在fragment的生命周期方法中LifecycleRegistry都会发送对应的生命周期事件给内部的handleLifecycleEvent()方法；
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把事件发送出去后，都做了什么事情？接下来我们来看下LifecycleRegistry内部的实现
public class LifecycleRegistry extends Lifecycle {
...
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
private void moveToState(State next) {
...
sync();
}
private void sync() {
...
//通过里边的backwardPass()和forwardPass()方法循环遍历
}
private void forwardPass(LifecycleOwner lifecycleOwner) {
...
while (...) {
...
ObserverWithState observer = entry.getValue();
while (...) {
//通知状态变化
pushParentState(observer.mState);
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
}
通过代码我们了解到handleLifecycleEvent里通过getStateAfter()方法获取当前的状态，并且通过moveToState() 方法修改Lifecycle的状态值，紧接着遍历所有LifecycleObserver 并同步且通知其状态发生变化，因此就能触发已经实现LifecycleObserver接口的类中对应的生命周期事件。
现在是时候祭出 Lifecycle时序图 来更好的理解工作原理
以上就是Lifecycle的基本工作原理，为缩短文章篇幅和可读性，文章里涉及的代码是源码的精简版，如若原理不详细，请移步源码阅读。
参考&感谢
Android官方架构组件Lifecycle:生命周期组件详解&原理分析
玩Android
总结
我们通过文章已经基本了解了lifecycle的工作原理，并且利用lifecycle可以更好对一些事件进行生命周期的管理。其实lifecycle原生支持livedata（顾名思义，动态数据容器），所以我们下一篇的重点就是学习和分析livedata的用法和构造。
这几年在开发过程中一直使用MVP架构，并且项目结构变大以后非常多的接口类出现了，导致项目中很臃肿。也在不少博客中看到MMVM的架构的应用，但是对于许多架构了解不深刻，导致代码阅读很吃力，才有了系统学习Android架构的想法，并且计划学习完Android架构系列以后，试着搭建自己的MVVM框架，并逐渐延伸到组件化开发，从而做到真正的学以致用。