前言

這一篇文章來介紹Android Jetpack架構組件的Lifecycle，Lifecycle用於幫助開發者管理Activity和Fragment 的生命週期，由於Lifecycle是LiveData和ViewModel的基礎，所以需要先學習它。

1.爲什麼需要Lifecycle

在應用開發中，處理Activity或者Fragment組件的生命週期相關代碼是必不可免的，官方文檔中舉了一個例子，這裏簡化一下，在Activity中寫一個監聽，在Activity的不同生命週期方法中調用這個監聽。

public class MainActivity extends AppCompatActivity {
 private MyListener myListener;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
 myListener = new MyListener(MainActivity.this);
 }
 @Override
 protected void onStart() {
 super.onStart();
 myListener.start();
 }
 @Override
 protected void onStop() {
 super.onStop();
 myListener.stop();
 }
}
class MyListener {
 public MyListener(Context context) {
 ...
 }
 void start() {
 ...
 }
 void stop() {
 ...
 }
}

再舉個MVP中常見的情況，如下所示。

public class MainActivity extends AppCompatActivity {
 private MyPresenter myPresenter;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
 myPresenter = new MyPresenter();
 }
 @Override
 protected void onResume() {
 super.onResume();
 myPresenter.onResume();
 }
 @Override
 protected void onPause() {
 super.onPause();
 myPresenter.onPause();
 }
}
class MyPresenter{
 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:$lifecycle_version"
 // alternatively - just ViewModel
 implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
 // alternatively - just LiveData
 implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
 // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
 // AndroidX libraries use this lightweight import for Lifecycle
 implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
 annotationProcessor "androidx.lifecycle:lifecycle-compiler:$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:$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:$lifecycle_version"
 // 僅僅包含ViewModel
 implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
 // 僅僅包含LiveData
 implementation "android.arch.lifecycle:livedata:$lifecycle_version"
 // 僅僅包含Lifecycles
 implementation "android.arch.lifecycle:runtime:$lifecycle_version"

 annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
 // 如果用Java8, 用於替代compiler
 implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
 // 可選，ReactiveStreams對LiveData的支持
 implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"
 // 可選，LiveData的測試
 testImplementation "android.arch.core:core-testing:$lifecycle_version"
}

實際上我們不需要全部把這些代碼全寫進build.gralde進去（當然全寫進去也不會有什麼錯），因爲Gradle默認是支持依賴傳遞的。我們直接添加如下依賴就可以滿足日常的工作，如果缺少哪個庫，再去單獨添加就好了。

implementation "android.arch.lifecycle:extensions:1.1.1"

添加這一句代碼就依賴瞭如下的庫。

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：

public class MainActivity extends AppCompatActivity {
 private static final String TAG = "test";
 private IPresenter mPresenter;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
 mPresenter = new MyPresenter();
 getLifecycle().addObserver(mPresenter);
 }
 @Override
 protected void onResume() {
 super.onResume();
 Log.d(TAG, "onResume");
 }
 @Override
 protected void onPause() {
 super.onPause();
 Log.d(TAG, "onPause");
 }
}

MainActivity成爲了被觀察者，當它的生命週期發生變化時，MyPresenter就可以觀察到，這樣就不需要在MainActivity的多個生命週期方法中調用MyPresenter的方法了。打印的日誌如下：

D/test: onResume
D/test: Lifecycle call onResume
D/test: Lifecycle call onPause
D/test: onPause

4.自定義LifecycleOwner

如果想實現自定義LifecycleOwner，可以使用LifecycleRegistry，它是Lifecycle的實現類。Android Support Library 26.1.0及其之後的版本，Activity和Fragment已經默認實現了LifecycleOwner接口，因此我們可以這麼寫：

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleRegistry;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MyActivity extends AppCompatActivity {
 private LifecycleRegistry lifecycleRegistry;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 lifecycleRegistry = new LifecycleRegistry(this);
 lifecycleRegistry.markState(Lifecycle.State.CREATED);
 }
 @Override
 public void onStart() {
 super.onStart();
 lifecycleRegistry.markState(Lifecycle.State.STARTED);
 }
 @NonNull
 @Override
 public Lifecycle getLifecycle() {
 return lifecycleRegistry;
 }
}

通過新建LifecycleRegistry，爲LifecycleRegistry設置Lifecycle的各種狀態，並通過getLifecycle方法返回該LifecycleRegistry。

總結

這一篇介紹了Lifecycle的基本用法，並通過兩個小例子來幫助大家消化理解，具體在項目中的使用也不難，唯一還算難點的是Lifecycle的原理

最後

感謝大家能耐着性子，看完我囉哩囉嗦的文章。

願與各位堅守在Android開發崗位的同胞們互相交流學習，共同進步！

在這裏我也分享一份自己收錄整理的Android學習PDF+架構視頻+面試文檔+源碼筆記，還有高級架構技術進階腦圖、Android開發面試專題資料，高級進階架構資料幫助大家學習提升進階，也節省大家在網上搜索資料的時間來學習，也可以分享給身邊好友一起學習

如果你有需要的話，可以點贊

Android Jetpack架構組件：一文帶你瞭解Lifecycle（使用篇）

前言

1.爲什麼需要Lifecycle

2.如何使用Lifecycle

3.Lifecycle應用舉例

總結

最後

如何使用 JS 判斷用戶是否處於活躍狀態

lightdb秒級增加列和刪除列（not null帶默認值）

通過HPA+CronHPA組合應對業務複雜彈性伸縮場景

❤️‍🔥 Solon Cloud Event 新的事務特性與應用

Android項目重構實踐：從 Fresco 到 Glide 低成本重構方案

Android開發：生成桌面快捷方式是這樣做的

主流app破解—你以爲用C進行加密就可以高枕無憂了？

Android開發：OpenGL 實現視頻編輯中的轉場效果

2019年底面經，新出爐的Android高級面試記錄，我死在了NDK上……

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結