Android-Jetpack架构组件(二)带你了解Lifecycle,给2021的移动开发一些建议

本文介绍了Android Jetpack中的Lifecycle组件,强调了在Activity和Fragment中管理生命周期的重要性,通过示例展示了如何依赖和使用Lifecycle库,包括添加Observer以及在Activity和MVP模式中的应用。同时,提出了在2021年移动开发中使用Lifecycle来提高代码维护性和正确处理生命周期回调的建议。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

@Override
protected void onResume() {
super.onResume();
myPresenter.onResume();
}

@Override
protected void onPause() {
super.onPause();
myPresenter.onPause();
}
}

class MyPresenter{

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整资料开源分享

void onResume() {

}
void onPause() {

}
}

这两个例子的写法已经很普遍了,实现起来也不难,但实际开发中,可能会有多个组件在Activity的生命周期中进行回调,这样Activity的生命周期的方法中可能就需要放大量的代码,这就使得它们难以维护。
还有一个问题是,如果我们在组件中做了耗时操作(比如在onStart方法),这种写法就无法保证组件在Activity或者Fragment停止之前完成启动。
因此我们需要一个能管理Activity和Fragment的生命周期的库,这个库就是Lifecycle。

2.如何使用Lifecycle

分别来介绍下依赖Lifecycle库和Lifecycle基本用法。

2.1 依赖Lifecycle库

官网给出的依赖代码如下所示:

dependencies {
def lifecycle_version = “2.0.0”

// ViewModel and LiveData
implementation “androidx.lifecycle:lifecycle-extensions: l i f e c y c l e v e r s i o n " / / a l t e r n a t i v e l y − j u s t V i e w M o d e l i m p l e m e n t a t i o n " a n d r o i d x . l i f e c y c l e : l i f e c y c l e − v i e w m o d e l : lifecycle_version" // alternatively - just ViewModel implementation "androidx.lifecycle:lifecycle-viewmodel: lifecycleversion"//alternativelyjustViewModelimplementation"androidx.lifecycle:lifecycleviewmodel:lifecycle_version” // For Kotlin use lifecycle-viewmodel-ktx
// alternatively - just LiveData
implementation “androidx.lifecycle:lifecycle-livedata: l i f e c y c l e v e r s i o n " / / a l t e r n a t i v e l y − L i f e c y c l e s o n l y ( n o V i e w M o d e l o r L i v e D a t a ) . S o m e U I / / A n d r o i d X l i b r a r i e s u s e t h i s l i g h t w e i g h t i m p o r t f o r L i f e c y c l e i m p l e m e n t a t i o n " a n d r o i d x . l i f e c y c l e : l i f e c y c l e − r u n t i m e : lifecycle_version" // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI // AndroidX libraries use this lightweight import for Lifecycle implementation "androidx.lifecycle:lifecycle-runtime: lifecycleversion"//alternativelyLifecyclesonly(noViewModelorLiveData).SomeUI//AndroidXlibrariesusethislightweightimportforLifecycleimplementation"androidx.lifecycle:lifecycleruntime:lifecycle_version”

annotationProcessor “androidx.lifecycle:lifecycle-compiler: l i f e c y c l e v e r s i o n " / / F o r K o t l i n u s e k a p t i n s t e a d o f a n n o t a t i o n P r o c e s s o r / / a l t e r n a t e l y − i f u s i n g J a v a 8 , u s e t h e f o l l o w i n g i n s t e a d o f l i f e c y c l e − c o m p i l e r i m p l e m e n t a t i o n " a n d r o i d x . l i f e c y c l e : l i f e c y c l e − c o m m o n − j a v a 8 : lifecycle_version" // For Kotlin use kapt instead of annotationProcessor // alternately - if using Java8, use the following instead of lifecycle-compiler implementation "androidx.lifecycle:lifecycle-common-java8: lifecycleversion"//ForKotlinusekaptinsteadofannotationProcessor//alternatelyifusingJava8,usethefollowinginsteadoflifecyclecompilerimplementation"androidx.lifecycle:lifecyclecommonjava8:lifecycle_version”

// optional - ReactiveStreams support for LiveData
implementation “androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version” // For Kotlin use lifecycle-reactivestreams-ktx

// optional - Test helpers for LiveData
testImplementation “androidx.arch.core:core-testing:$lifecycle_version”
}

官网用的是AndroidX,因为使用AndroidX,可能会产生一些迁移的问题,这里的举例就不使用AndroidX,而是使用lifecycleandroid.arch.lifecycle库,如下所示。

dependencies {
def lifecycle_version = “1.1.1”

// 包含ViewModel和LiveData
implementation “android.arch.lifecycle:extensions: l i f e c y c l e v e r s i o n " / / 仅 仅 包 含 V i e w M o d e l i m p l e m e n t a t i o n " a n d r o i d . a r c h . l i f e c y c l e : v i e w m o d e l : lifecycle_version" // 仅仅包含ViewModel implementation "android.arch.lifecycle:viewmodel: lifecycleversion"//ViewModelimplementation"android.arch.lifecycle:viewmodel:lifecycle_version” // For Kotlin use viewmodel-ktx
// 仅仅包含LiveData
implementation “android.arch.lifecycle:livedata: l i f e c y c l e v e r s i o n " / / 仅 仅 包 含 L i f e c y c l e s i m p l e m e n t a t i o n " a n d r o i d . a r c h . l i f e c y c l e : r u n t i m e : lifecycle_version" // 仅仅包含Lifecycles implementation "android.arch.lifecycle:runtime: lifecycleversion"//Lifecyclesimplementation"android.arch.lifecycle:runtime:lifecycle_version”

annotationProcessor “android.arch.lifecycle:compiler: l i f e c y c l e v e r s i o n " / / F o r K o t l i n u s e k a p t i n s t e a d o f a n n o t a t i o n P r o c e s s o r / / 如 果 用 J a v a 8 , 用 于 替 代 c o m p i l e r i m p l e m e n t a t i o n " a n d r o i d . a r c h . l i f e c y c l e : c o m m o n − j a v a 8 : lifecycle_version" // For Kotlin use kapt instead of annotationProcessor // 如果用Java8, 用于替代compiler implementation "android.arch.lifecycle:common-java8: lifecycleversion"//ForKotlinusekaptinsteadofannotationProcessor//Java8,compilerimplementation"android.arch.lifecycle:commonjava8:lifecycle_version”

// 可选,ReactiveStreams对LiveData的支持
implementation “android.arch.lifecycle:reactivestreams:$lifecycle_version”

// 可选,LiveData的测试
testImplementation “android.arch.core:core-testing:$lifecycle_version”
}

实际上我们不需要全部把这些代码全写进build.gralde进去(当然全写进去也不会有什么错),因为Gradle默认是支持依赖传递的,不知道什么是依赖传递的看Android Gradle (二)签名配置和依赖管理这篇文章。
我们直接添加如下依赖就可以满足日常的工作,如果缺少哪个库,再去单独添加就好了。

添加这一句代码就依赖了如下的库。
eXj6eJ.png

2.2 Lifecycle基本用法

先不谈Activity和Fragment中如何使用,先举一个Lifecycle的简单例子。

public class MyObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void connectListener() {

}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void disconnectListener() {

}
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());//1

新建一个MyObserver类,它实现了LifecycleObserver接口,说明MyObserver成为了一个Lifecycle的观察者。
然后在注释1处将MyObserver添加到LifecycleOwner中。LifecycleOwner是一个接口,其内部只有一个方法getLifecycle(),getLifecycle方法用于获取Lifecycle,这样就可以将MyObserver添加到Lifecycle中,当Lifecycle的生命周期发生变化时,MyObserver就会观察到,或者说是感知到。

如果使用是Java8 ,那么可以使用DefaultLifecycleObserver来替代LifecycleObserver:

class MyObserver implements DefaultLifecycleObserver {
@Override
public void onCreate(LifecycleOwner owner) {

}
}

除此之外,不要忘了在build.gradle添加 "androidx.lifecycle:common-java8:<version>"

3.Lifecycle应用举例

应用举例准备两个示例,一个是在Activity中使用,一个是在第一小节的MVP例子上进行改进。

3.1 Activity中使用

package com.example.lifecycledemo1;

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

private static final String TAG = “MainActivity”;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getLifecycle().addObserver(new MyObserver());//1
}

public class MyObserver implements LifecycleObserver{

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void onResume(){
Log.d(TAG, “Lifecycle call onResume”);
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause(){
Log.d(TAG, “Lifecycle call onPause”);
}
}

@Override
protected void onResume() {
super.onResume();
Log.d(TAG, “onResume”);
}

@Override
protected void onPause() {
super.onPause();
Log.d(TAG, “onPause”);

}
}

先实现MyObserver,对ON_CREATE和ON_RESUME事件进行监听。因为在Android Support Library 26.1.0 及其之后的版本,Activity和Fragment已经默认实现了LifecycleOwner接口,所以在注释1处可以直接使用getLifecycle方法获取Lifecycle对象,这样MyObserver就可以观察MainActivity的生命周期变化了,LifecycleOwner可以理解为被观察者,MainActivity默认实现了LifecycleOwner接口,也就是说MainActivity是被观察者。
运行程序,打印的log如下所示。

D/MainActivity: onResume
D/MainActivity: Lifecycle call onResume
D/MainActivity: Lifecycle call onPause
D/MainActivity: onPause

只要在MainActivity的onCreate方法中添加MyObserver,那么MyObserver就可以观察到MainActivity的各个生命周期的变化。

3.2 MVP中使用

改写第一小节MVP的例子,先实现MyPresenter,如下所示。

public class MyPresenter implements IPresenter {
private static final String TAG = “test”;

@Override
public void onResume() {
Log.d(TAG, “Lifecycle call onResume”);
}

@Override
public void onPause() {
Log.d(TAG, “Lifecycle call onPause”);
}
}

interface IPresenter extends LifecycleObserver {

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
void onResume();

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
void onPause();
}

IPresenter接口继承自LifecycleObserver接口,MyPresenter又实现了IPresenter接口,这样MyPresenter成为了一个观察者。
接在在MainActivity中加入MyPresenter:

总结

学习技术是一条慢长而艰苦的道路,不能靠一时激情,也不是熬几天几夜就能学好的,必须养成平时努力学习的习惯。所以:贵在坚持!

最后如何才能让我们在面试中对答如流呢?

答案当然是平时在工作或者学习中多提升自身实力的啦,那如何才能正确的学习,有方向的学习呢?有没有免费资料可以借鉴?为此我整理了一份Android学习资料路线:

这里是一部分我工作以来以及参与过的大大小小的面试收集总结出来的一套BAT大厂面试资料专题包,主要还是希望大家在如今大环境不好的情况下面试能够顺利一点,希望可以帮助到大家。

好了,今天的分享就到这里,如果你对在面试中遇到的问题,或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己,对于自己的未来还不够了解不知道给如何规划。来看看同行们都是如何突破现状,怎么学习的,来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。

最后,祝愿即将跳槽和已经开始求职的大家都能找到一份好的工作!

这些只是整理出来的部分面试题,后续会持续更新,希望通过这些高级面试题能够降低面试Android岗位的门槛,让更多的Android工程师理解Android系统,掌握Android系统。喜欢的话麻烦点击一个喜欢再关注一下~

工作几年迷茫不知道该如何准备面试并突破现状提升自己,对于自己的未来还不够了解不知道给如何规划**。来看看同行们都是如何突破现状,怎么学习的,来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。

最后,祝愿即将跳槽和已经开始求职的大家都能找到一份好的工作!

这些只是整理出来的部分面试题,后续会持续更新,希望通过这些高级面试题能够降低面试Android岗位的门槛,让更多的Android工程师理解Android系统,掌握Android系统。喜欢的话麻烦点击一个喜欢再关注一下~

本文已被CODING开源项目:《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值