Android架构组件（一）：Lifecycle

前言

谷歌在17年发布了Android架构组件1.0稳定版，用来帮助开发者们简化开发流程，并为App的开发架构提供指南。这次发布的架构包含了声明周期管理，数据持久性等提供了一系列库，并且该架构相互之间完美的融合到了一起，有助于我们使用更少的样板代码写出模块化的App。
他们包含：

Lifecycle（生命周期管理）
LiviData（基于观察者模式的可感知生命周期的数据持有类）
Viewmodel（将view和model分开的组件）
Room（简单强大的数据存储组件）

接下来我会用一系列文章和大家一起了解和使用这些组件。
系列文章也会收录到我的博客（Power）里，方便大家查阅。

好了，首先我们先来学习下基础组件：Lifecycle

什么是Lifecycle？

在讲解之前，我们先来分析下没用该组件之前我们常用的MVP模式中，Presenter是如何绑定activity/Fragment的生命周期？

//presenterPublic class Presenter{    public void attachView(T view) {        //do something    }        public void detachView() {        //do something    }}//activitypublic 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框架，并逐渐延伸到组件化开发，从而做到真正的学以致用。

前言

什么是Lifecycle？

Lifecycle的工作原理

参考&感谢

总结

更多相关文章

随机推荐