Jetpack系列 - Lifecycle从入门到源码

时间  2019-11-08
标签 jetpack 系列 lifecycle 入门 源码 繁體版
原文   原文链接

这篇文章旨在用最简单的方式教会你Lifecycle如何使用，及它的工做原理。java

Lifecycle介绍

Lifecycle是Google推出的JetPack框架组件的一个，主要是用来感知Activity和Fragment的生命周期，能够帮你写出更简洁，通用的代码。git

Lifecycle使用

总共两步github

  1. 第一步，编写本身的Observer类文件，并实现对应的监听方法，经过注解实现对响应生命周期方法的监听，代码以下：
public class MyLifeObserver implements LifecycleObserver {

  private static final String TAG = "MyLifeObserver";

  // OnLifecycleEvent()内的注解Lifecycle.Event.XXX 对应不一样的生命周期方法，你能够根据须要监听不一样的生命周期方法。
  // 方法名能够随意，这里为了方便理解定义为onResumeListener()。
  @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
  public void onResumeListener() {
    Log.d(TAG, "onResume: ");
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
  public void onPauseListener() {
    Log.d(TAG, "onPause: ");
  }

  @OnLifecycleEvent(Event.ON_DESTROY)
  public void onDestoryListener() {
    Log.d(TAG, "onDestory: ");
  }
复制代码
  1. 第二步在被监听的Activity/Fragment内注册：
public class MainActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    getLifecycle().addObserver(new MyLifeObserver());
  }
}
复制代码

无论你信不信，代码已经写完了！
bash


咱们跑一下代码： 

2019-02-28 12:00:40.068 com.example.lifecycledemo D/MyLifeObserver: onResume: 
2019-02-28 12:00:46.091 com.example.lifecycledemo D/MyLifeObserver: onPause: 
2019-02-28 12:00:46.416 com.example.lifecycledemo D/MyLifeObserver: onDestory: 
复制代码

Log 显示咱们写的 Observer 内的方法的确在 Activity 的指定周期内执行了。恭喜你，已经可以使用 Lifecycle 了！
可是注意几点：网络

  1. 一般咱们会 把MyLifeObserver 做为内部类写在另外一个 Activity/Fragment 中，以方便在监控到生命周期方法后作一些业务操做，以上代码为了快速看到效果而作了省略。
  2. 注意上面 Activity 的代码中，咱们的 Activity 继承了AppCompatActivity，AppCompatActivity 和 Fragment 都实现了LifecycleOwner 接口（Support Library 26.1.0以后的版本），因此能够直接拿来使用。若是你被监控的 Actiivty 是自定义的 Activity，须要手动继 承LifecycleOwner，具体操做以下：
1. 实现LifecycleOwner接口，并重写getLifecycle方法。
2. 手动在每一个生命周期方法中作标记。
复制代码

具体代码以下：框架

public class MyActivity extends Activity implements LifecycleOwner {
  private LifecycleRegistry mLifecycleRegistry;
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_my);
    //建立Lifecycle对象
    mLifecycleRegistry = *new*LifecycleRegistry(this);
    //作标记
    mLifecycleRegistry.markState(Lifecycle.State.CREATED);
    //添加观察者
    getLifecycle().addObserver(new MyLifeObserver());
  }

  @NonNull
  @Override
  public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
  }

  @Override
  public void onStart() {
    super.onStart();
    //作标记
    mLifecycleRegistry.markState(Lifecycle.State.STARTED);
  }

  @Override
  protected void onResume() {
    super.onResume();
    //作标记
    mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
  }

  @Override
  protected void onDestroy() {
    super.onDestroy();
    //作标记
    mLifecycleRegistry.markState(Lifecycle.State.DESTROYED); 
  }
}
复制代码

至此，Lifecycle 的使用方法已经介绍完了，由于 AppCompatActivity 已经帮咱们实现了 LifecycleOwner 接口，因此同窗们注意活学活用。
好比：在封装网络请求工具时候，传入当前 Activity 对象，当 Activity 对象生命周期为 Destory 时，撤销请求网络的操做。 Lifecycle 用武之地还有不少，这里只介绍最基础的，你如今能够思考如何经过 Lifecycle 来优化你的项目了。
若是你对Lifecyle的工做原理有兴趣，请继续阅读，我会带着你从源码一步一步彻底理解 Lifecycle 的工做原理。 若是没有兴趣，能够直接拉到文章末尾看总结~ide

Lifecycle的工做原理

咱们就以使用到的几个类为切入口，分析 Lifecycle 的工做原理。 咱们主要点进这几个类看(Crtl+单击类名)：LifecycleOwner.java，Lifecycle.java，LifecycleRegistry.java。工具

LifecycleOwner.java

这个很简单，LifecycleOwner定义了一个getLifecycle()方法，经过@NonNull强制咱们返回Lifecycle对象。代码以下：优化

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

复制代码

Lifecycle.java

代码以下：ui

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;
        }
    }
}
复制代码

Lifecycle的代码也并很少，注意它是一个抽象类。Lifecycle内部经过两个枚举分别定义了组件的生命周期的状态和事件。 下面这张图摘自Android开发者官网,介绍了State和Event的关系：

摘自Android开发者官网

简单说下这个图怎么看：看箭头，好比 ON_CREATE 箭头表示：State 从 INITIALIZED 变为 CREATED，会触发 ON_CREATE 的 Event。依次类推。

LifecycleRegistry.java

这个类的代码比较多，是 Lifecycle 的子类，也是监听组件声明周期的核心类。咱们就从使用到的方法一个一个来看：

A.构造方法，主要初始化了 mLifecycleOwner 和当前组件的状态(mState),没什么说的。

publicLifecycleRegistry(@NonNull LifecycleOwner provider) {
  mLifecycleOwner = new WeakReference<>(provider);
  mState = INITIALIZED;
}
复制代码

B. 咱们在 Lifecycle 的使用部分，继承了 LifecycleOwner，并在组件的生命周期内调用了 markState()方法。点进去以下：

public void markState(@NonNull State state) {
  moveToState(state);
}
复制代码

C. 省去了一些复杂逻辑的代码，咱们找到了这个核心的方法 sync():

private void moveToState(State next) {
 ...
  mHandlingEvent = true;
  sync();
  mHandlingEvent = false;
}

复制代码

D. 一样在 sync()方法中，忽略掉逻辑代码，咱们发现了正真执行的两个方法：backwardPass(),forwardPass()

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    while(!isSynced()) {
        mNewEventOccurred = false;
        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;
}

复制代码

E. 在 backwardPass()和 forwardPass()，调用了 observer.dispatchEvent(),看名字想必就是发送事件的方法了：

private void forwardPass(LifecycleOwner lifecycleOwner) {
    ...
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
    ...
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
 ...
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
 ...
}
复制代码

F. 咱们点击 dispatchEvent()方法，进入了下面这个静态内部类中，这个类中，就能够肯定了：Observer(下面代码中的 mLifecycleObserver)触监听定生命周期的方法在这里被触发了。 可是咱们如何肯定这个方法的 mLifecycleObserver 就是咱们实现的 Observer 呢？这个静态类还有一个方法，咱们点击一下看它在哪里被调用了：

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;
    }
}
复制代码

G. 很高兴，咱们来到了 addObserver()方法，你必定还记得咱们在讲解 Lifecycle 使用部分是，绑定 Observer 就是使用这个方法。

@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);
...
}
复制代码

H. 最后咱们看一眼 LifecycleObserver接口(观察者)，发现它是空的。其实咱们看到注解应该猜到，系统是经过 apt-processor(注释处理器)将咱们的 Observer 转换成 Lifecycle 真正须要类型 的Observer，下面是 OnLifecycleEvent 注解的声明：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}
复制代码

总结

看到这里，相信你们对 Lifecycle 的工做原理已经理解的差很少了吧，跟接口回调相似，咱们建立了 Obersver 的对象，而后将 Obersver 的引用交给 Lifecycle，在组件生命周期方法执行时，调用 Observer 的相应的方法。

固然，咱们本身也能够写一套接口回调来监控组件的生命周期，可是咱们不得不考虑在哪里设置监听器，生命周期的问题。 其实咱们使用 Lifecycle 真正的理由是，Lifecycle(LifecycleRegistry)类帮咱们处理了大量的与宿主组件生命周期相关的问题，使咱们的代码更简洁。专心处理业务逻辑便可。

END

我是雷加,若是您喜欢个人文章，请留下你的赞;若有疑问和建议，请在评论区留言
个人Github,欢迎关注~

Jetpack 专栏：
Lifecycle：Jetpack系列 - Lifecycle从入门到源码
ViewModel：Jetpack系列 - ViewModel从入门到源码
LiveData：Jetpack系列 - LiveData从入门到源码
Palette：Jetpack系列 - Palette 入门指南

--------------------------------------- The End

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程