Jetpack Lifecycle 详解

Posted 编程的平行世界

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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的使用场景:

这里留下几个问题:

  • 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 缓存封装

以上是关于Jetpack Lifecycle 详解的主要内容,如果未能解决你的问题,请参考以下文章

Jetpack 之 LifeCycle 组件使用详解

Android Jetpack架构组件一文带你了解Lifecycle(使用篇)

Android Jetpack架构组件一文带你了解Lifecycle(原理篇)

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

Android Jetpack组件 - ViewModel,LiveData使用以及原理

Jetpack Lifecycle 该怎么看?