Lifecycle的基本使用和原理

最新推荐文章于 2025-06-19 14:53:13 发布

zhaonhui

最新推荐文章于 2025-06-19 14:53:13 发布

阅读量7.5k

点赞数 4

CC 4.0 BY-SA版权

分类专栏： Android 文章标签： Lifecycle android

本文链接：https://blog.youkuaiyun.com/huideveloper/article/details/108796881

Android 专栏收录该内容

51 篇文章

订阅专栏

本文详细介绍了Android中的Lifecycle机制，包括Lifecycle的基本使用方式及其实现原理。通过具体的代码示例，展示了如何利用LifecycleOwner和LifecycleObserver接口进行Activity和Fragment的生命周期观察。

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

一、Lifecycle的基本使用

Lifecycle是Android中引入的主要用来观察和监听Activity、Fragment生命周期的一套观察者机制。

在这个机制中有两个核心类，一个是LifecycleOwner接口，该接口有一个getLifecycle()方法，实现了这个接口的类就可以作为一个被观察者，AppCompatActivity和Fragment就实现了这个接口，所以它们的生命周期就可以被观察和监听。另一个是LifecycleObserver接口，实现了这个接口的类就可以作为一个观察者。基本使用如下：

1、自定义一个观察者类

class CustomLifecycleObserver : LifecycleObserver {

	//监听onStart生命周期
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun method2() {
        Log.e("znh", "LifecycleObserver_ON_START...")
    }

	//监听onResume生命周期
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun method3() {
        Log.e("znh", "LifecycleObserver_ON_RESUME...")
    }
}

2、创建一个AppCompatActivity作为被观察者

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

		//将自定义的观察者对象添加到观察者集合中
		//通过lifecycle将观察者和被观察者关联起来
        lifecycle.addObserver(CustomLifecycleObserver())
    }

    override fun onStart() {
        super.onStart()
        Log.e("znh", "onStart...")
    }

    override fun onResume() {
        super.onResume()
        Log.e("znh", "onResume...")
    }
}

3、打开MainActivity观察生命周期方法日志打印
在这里插入图片描述
从打印的日志中可以看出，当Activity中的生命周期方法回调时，都会回调LifecycleObserver中对应的监听方法，这样就完成了对Activity生命周期的观察和监听。

二、Lifecycle的原理

LifecycleOwner接口源码如下：

@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
    Lifecycle getLifecycle();
}

AppCompatActivity是ComponentActivity的子类，ComponentActivity直接实现了LifecycleOwner接口，在ComponentActivity中的getLifecycle方法中返回的是LifeCycle的子类LifecycleRegistry类型的mLifecycleRegistry对象，ComponentActivity中相关源码如下：

private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

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

观察者对ComponentActivity的观察是通过在其onCreate方法中添加一个没有界面的ReportFragment来实现的，当ReportFragment的生命周期方法被调用时，就会触发其宿主Activity的Lifecycle的生命周期事件分发方法调用。

ComponentActivity的onCreate方法：

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   mSavedStateRegistryController.performRestore(savedInstanceState);
   
   //将ReportFragment注册到Activity中
   ReportFragment.injectIfNeededIn(this);
   
   if (mContentLayoutId != 0) {
       setContentView(mContentLayoutId);
   }
}

ReportFragment的injectIfNeededIn方法：

 public static void injectIfNeededIn(Activity activity) {
 		//关键代码1 
        if (Build.VERSION.SDK_INT >= 29) {
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
 
 		//关键代码2
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

在关键代码1处可知，API29以上的是通过注册一个LifecycleCallbacks来监听Activity的生命周期变化的。

在关键代码2处，创建了一个ReportFragment添加到Activity的FragmentManager中。

在ReportFragment中的生命周期回调方法中，会去分发生命周期事件，这里以onResume为例：

@Override
public void onResume() {
    super.onResume();
    dispatchResume(mProcessListener);

	//关键代码3
    dispatch(Lifecycle.Event.ON_RESUME);
}

private void dispatch(@NonNull Lifecycle.Event event) {
    if (Build.VERSION.SDK_INT < 29) {
    	//关键代码4
        dispatch(getActivity(), event);
    }
}

在关键代码3处调用了dispatch方法来分发生命周期事件，在dispatch方法中可以看出，如果在API29以上是不需要走这个流程的(因为在关键代码1处，API29以上的注册了LifecycleCallbacks监听，会走监听的流程，在监听到生命周期方法回调后，也会马上调用关键代码4处的dispatch方法)，API29以下的会直接调用关键代码4处的dispatch方法，所以不管是API多少的，最终都会调用到关键代码4处重载的dispatch方法，下面看下这个方法的源码：

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

	//关键代码5
    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

在关键代码5处，Activity实现了LifecycleOwner的接口，getLifecycle()方法返回的是LifecycleRegistry类型的mLifecycleRegistry对象，所以接下来会调用LifecycleRegistry的handleLifecycleEvent方法：

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {

	//关键代码6
    State next = getStateAfter(event);
    
    //关键代码7
    moveToState(next);
}

在关键代码6处的getStateAfter方法，会根据生命周期事件获取到当前的生命周期状态，当生命周期事件是ON_CREATE或者ON_STOP时都是CREATED状态，当生命周期事件是ON_START或者ON_PAUSE时都是STARTED状态，当生命周期事件是ON_RESUME时其状态是RESUMED，当生命周期事件是ON_DESTROY时其状态是DESTROYED状态：

static State getStateAfter(Event event) {
    switch (event) {
        case ON_CREATE:
        case ON_STOP:
            return CREATED;
        case ON_START:
        case ON_PAUSE:
            return STARTED;
        case ON_RESUME:
            return RESUMED;
        case ON_DESTROY:
            return DESTROYED;
        case ON_ANY:
            break;
    }
    throw new IllegalArgumentException("Unexpected event value " + event);
}

在关键代码7处会调用moveToState方法，在moveToState方法中又会调用sync方法，在sync方法中又会去调用backwardPass方法或者forwardPass方法去同步生命周期并将当前生命周期Event事件回调给观察者。

从Lifecycle的使用中可以知道，观察者是通过getLifecycle().addObserver(LifecycleObserver observer)方法被添加到观察者集合中去的。

生命周期事件回调给观察者是通过调用观察者LifecycleObserver的子类LifecycleEventObserver的onStateChanged(owner, event)方法来实现的，在onStateChanged方法中通过反射的手段去调用观察者中有@OnLifecycleEvent注解的并跟当前生命周期相对应的方法，到这里就完成了观察者整个监听过程。