2022 · 让我带你Jetpack架构组件从入门到精通 — Lifecycle

前言

不是标题党！作者会尽力把文章写的更容易理解也更充满深度，本文也随作者的持续学习，持续更新，有问题欢迎在评论区提出~

最近更新时间：2022-06-17

介绍

Jetpack的正式亮相是在2018年的Google I/O大会上，距今已经过去了四年，在当初的基础上又多了许多的新组件，每个组件都给开发者提供了一个标准， 能够帮助开发者减少样板代码并编写可在各种 Android 版本和设备中一致运行的 代码，让开发者能够集中精力编写重要的业务代码。但是，也有很多Android工程师四年过去了都停留在：知道、了解过、但没用过。也有很多朋友想要好好学习Jetpack，但是又无奈网上的知识点太过分散。本系列文章目标就是带大家完整的学习Jetpack组件，由浅入深。

常用架构组件图

本系列源码地址：

https://github.com/taxze6/Jetpack_learn/tree/main/Jetpack_basic_learn

现在就让我们进入Jetpack的世界，第一站就是Lifecycle生命周期管理组件！

Lifecycle

官方文档：

https://developer.android.google.cn/jetpack/androidx/releases/lifecycle

推荐阅读：

深入理解AAC架构 - Lifecycle整体机制源码

推荐阅读：

Lifecycle，看完这次就真的懂了

我相信，在你第一次看见Lifecycle时，你会有下面四个疑问：

• Lifecycle到底是什么呢？

• 它是用来干什么的？

• 它有什么优势呢？

• 它要怎么用呢?

Lifecycle是什么：

• life:生命,(某事物)的存在期

• cycle:周期

Lifecycle就是生命周期的意思。它是一个生命周期感知型组件，用来感知响应别的组件，例如感知Activity和Fragment的生命周期状态的变化。

Lifecycle用来干什么：

 Lifecycle能够自动感知其他组件的生命周期，能够降低组件之间的耦合性。

在android开发中，生命周期这个词很重要，因为内存泄漏和它有很大很大的关系，内存泄漏的最主要原因是因为对象的内存无法被回收，短生命周期对象被长生命周期对象所引用时，短生命周期对象不使用时无法被回收…..情况下，就造成了内存泄漏。（此处留个坑，也许以后会写关于内存泄漏如何解决方面的知识，现在大家可以先看其他资料学习）

大家此时心里会想，我要管理生命周期，但是android的activity不是自带了生命周期的函数吗，我在它里面修改不就行了，你要说有耦合，那全抽到Base类中不就好了。办法总是有的嘛~ 确实，在平时开发时，我们会封装一个BaseActivity，然后让所有的Activity都继承于它。BaseActivity一般会覆写onCreate、onStart 、onResume、onPause、onStop、onDestroy以及onRestart函数，并在其中加上日志信息，方便观察每个活动的各种状态。我们可以想到封装BaseActivity，那么官方肯定也会想到，于是就出现了Lifecycle。

lifecycle有什么优势呢？

既然，我们自己封装BaseActivity就基本能够管理生命周期了，那么官方为何还要 推出Lifecycle这个组件呢？

优势：

• Lifecycler实现了执行的逻辑和活动的分离，代码解耦并且增加了代码的额可读性

• Lifecycler在活动结束时自定移除监听，避免了声明周期的问题

如何使用Lifecycle呢？

先来了解一下lifecycle的核心类：

• Lifecycle

• Lifecycle是一个抽象类，实现子类为LifecycleRegistry

 class LifecycleRegistry extends Lifecycle{
 .......
 }


• lifecycleRegister

• lifecycle的唯一子类，用于在生命周期变化时触发自身状态和相关观察者的订阅回调逻辑

• LifecycleOwner

• 用于连接有生命周期的对象

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


• LifecycleObserver

• Lifecycle观察者

• State（Lifecycle的抽象类内部）

• 表示当前生命周期所处状态

 public enum State {
 DESTROYED,
 INITIALIZED,
 CREATED,
 STARTED,
 RESUMED;
 public boolean isAtLeast(@NonNull State state) {
 return compareTo(state) >= 0;
 }
 }


• Event（Lifecycle的抽象类内部）

• 当前生命周期改变对应的事件

 public enum Event {
 ON_CREATE,
 ON_START,
 ON_RESUME,
 ON_PAUSE,
 ON_STOP,
 ON_DESTROY,
 ON_ANY;
 ......
 }


在了解了这些类和接口的用处之后，再去学习如何使用和源码分析就简单很多了。

Lifecycle的使用：

• gradle的引用

 dependencies {
 def lifecycle_version = "2.5.0-rc01"
 def arch_version = "2.1.0"
 kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
 implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
 implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
 implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
 implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"
 testImplementation "androidx.arch.core:core-testing:$arch_version"
 }

>  这里可以发现我们导入了lifecycle-service，lifecycle-process这两个组件，因为，在新版的SDK中，Activity/Fragment已经默认实现了LifecycleOwner接口，针对Service，Android 单独提供了LifeCycleService，而不是像Activity、Fragment默认实现了LifeCycleOwner。针对Application，Android 提供了ProcessLifeCycleOwner 用于监听整个应用程序的生命周期。


现在就让我们用两种方式实现对Activity生命周期的监听吧

• LifecycleObserver

我们需要创建一个MyLifecycleTest并继承于LifecycleObserver ，使用OnLifecycleEvent(此方法已过时)，实现对生命周期的监听。

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent
​
//OnLifecycleEvent已经过时了
class MyLifecycleTest : LifecycleObserver {
 companion object{
 private const val TAG = "MyLifecycleTest"
 }
 @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
 fun create() {
 Log.d(TAG, "create: ")
 }
​
 @OnLifecycleEvent(Lifecycle.Event.ON_START)
 fun start() {
 Log.d(TAG, "start: ")
 }
​
 @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
 fun resume() {
 Log.d(TAG, "resume: ")
 }
​
 @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
 fun pause() {
 Log.d(TAG, "pause: ")
 }
​
 @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
 fun stop() {
 Log.d(TAG, "stop: ")
 }
​
 @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
 fun destroy() {
 Log.d(TAG, "destroy: ")
 }
​
 @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
 fun any() {
// Log.d(TAG, "any: ")
 }
​
}


在MainActivity onCreate种调用addObserver方法新添加一个LifecycleObserver。

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
​
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)
 lifecycle.addObserver(MyLifecycleTest())
 }
}


• 使用
  DefaultLifecycleObserver

使用它需要映入androidx.lifecycle:lifecycle-common-java8，如果项目中使用了java8或者开启java8特性，那么官方推荐使用

DefaultLifecycleObserver

替代的

@OnLifecycleEvent

 注解实现（因为现在注解已经被弃用了），包括预编译。

我们创建一个

MyDefaultLifecycleObserver继承于DefaultLifecycleObserver

import android.util.Log
import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.LifecycleOwner
​
class MyDefaultLifecycleObserver : DefaultLifecycleObserver {
 companion object {
 private const val TAG = "MyDefaultLifecycleObserver"
 }
​
 override fun onCreate(owner: LifecycleOwner) {
 super.onCreate(owner)
 Log.d(TAG, "onCreate: ")
 }
​
 override fun onStart(owner: LifecycleOwner) {
 super.onStart(owner)
 Log.d(TAG, "onStart: ")
 }
​
 override fun onResume(owner: LifecycleOwner) {
 super.onResume(owner)
 Log.d(TAG, "onResume: ")
 }
​
 override fun onPause(owner: LifecycleOwner) {
 super.onPause(owner)
 Log.d(TAG, "onPause: ")
 }
​
 override fun onStop(owner: LifecycleOwner) {
 super.onStop(owner)
 Log.d(TAG, "onStop: ")
 }
​
 override fun onDestroy(owner: LifecycleOwner) {
 super.onDestroy(owner)
 Log.d(TAG, "onDestroy: ")
 }
}


然后我们再创建一个

MyApplication

通过

addObserver()

将

Observer

添加到

LifecycleRegistry

。

使用ProcessLifecycleOwner.get().lifecycle.addObserver(MyDefaultLifecycleObserver())

import android.app.Application
import androidx.lifecycle.ProcessLifecycleOwner
​
class MyApplication : Application() {
 override fun onCreate() {
 super.onCreate()
 ProcessLifecycleOwner.get().lifecycle.addObserver(MyDefaultLifecycleObserver())
 }
}


在AndroidManifest.xml中添加下面这行运行代码，当应用程序进程启动时，这个被指定的子类在任何应用的组件之前被实例化。

使用起来是很简单的，当然，这只是一个简单的例子，所以我们还需要探索一下Lifecycle的具体实现，并多多练习才能掌握好它。

举例几个Lifecycle的使用场景：

• Retrofit配合Lifecycle管理Http生命周期

• 这里推荐阅读：
  https://mp.weixin.qq.com/s/omCnmMX3XVq-vnKoDnQXTg

• 暂停和恢复动画绘制

• 视频的暂停与播放

• Handler 的消息移除

• ........

这里留下几个问题：

• Lifecycle的创建方式有哪几种（有什么不同，推荐使用哪一种）？

• Lifecycle是如何进行生命周期同步的？

• Event事件和State状态是什么关系？

• Lifecycle的注册，派发，感知的过程是怎么样的？

• 什么叫做嵌套事件？发生的时机是什么？Lifecycle是如何解决的？

请大家自己先寻找一下答案，在Jetpack源码分析系列我们会详细分析（这个系列还没写）。

基础系列：

2022 · 让我带你Jetpack架构组件从入门到精通 — Lifecycle (本文)

2022 · 让我带你Jetpack架构组件从入门到精通 — ViewModel&LiveData

以下部分还在码字，赶紧点个收藏吧

2022 · 让我带你Jetpack架构组件从入门到精通 — DataBinding

2022 · 让我带你Jetpack架构组件从入门到精通 — Navigation

2022 · 让我带你Jetpack架构组件从入门到精通 — Room

2022 · 让我带你Jetpack架构组件从入门到精通 — Paging3

2022 · 让我带你Jetpack架构组件从入门到精通 — WorkManager

2022 · 让我带你Jetpack架构组件从入门到精通 — ViewPager2

2022 · 让我带你Jetpack架构组件从入门到精通 — 登录注册页面实战（MVVM）

进阶系列：

协程 + Retrofit网络请求状态封装

Room 缓存封装

.....