JetPack学习笔记之LifeCycle原理_context must implement viewmodelstoreowner-CSDN博客

本文链接：https://blog.csdn.net/json_it/article/details/107885146

本文详细探讨了Jetpack中的LifeCycle组件，包括LifeCycleOwner和LifecycleObserver的概念。LifeCycleOwner如Activity和Fragment默认实现了接口，而LifecycleObserver则允许自定义组件监听生命周期事件。通过@OnLifecycleEvent注解，可以方便地在组件中响应生命周期变化。LifeCycleService和ProcessLifeCycleOwner分别针对Service和整个应用的生命周期管理。值得注意的是，ProcessLifeCycleOwner不受Activity数量影响，且Lifecycle.Event.ON_DESTROY通常不被调用，ON_PAUSE和ON_STOP有延迟。总结了AppCompatActivity和Fragment如何处理生命周期事件，展示了Lifecycle内部的工作流程。

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

基本概念

LifeCycle的原理

Jetpack为我们提供了两个接口：LifecycleOwner（被观察者）和LifecycleObserver（观察者）。即通过观察者模式，实现对页面生命周期的监听。

- LifeCycleOwner

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

在新版本SDK包中，Activity/Fragment已经默认实现了LifecycleOwner接口。以Activity为例，Activity的基类 - ComponentActivity，实现了LifeCycleOwner接口：

    
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
     ......

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

}
----------------------Fragment----------------------
public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
        ViewModelStoreOwner, SavedStateRegistryOwner{
     ......
}

而mLifecycleRegistry的类型是LifecycleRegistry，LifecycleRegistry是LifeCycle抽象类的子类，如下图所示：

- LifecycleObserver

被观察者的实现，Android已经帮我们做好了，因此我们只需要实现观察者那一部分的代码即可，即让自定义组件实现LifeCycleObserver接口。该接口没有接口方法，无需任何具体的实现。

public interface LifecycleObserver {

}

对于组件中需要在页面生命周期发生变化时得到通知的方法，则需要我们在这些方法上使用 @OnLifecycleEvent注解即可。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}
--------------------
    public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY
    }

示例：

public class MainActivity extends AppCompatActivity {

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

public class MyLifeCycleObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void lifeCycleOnCreate() {
        Log.e("MyLifeCycleObserver", "MyLifeCycleObserver - > ON_CREATE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void lifeCycleOnStart() {
        Log.e("MyLifeCycleObserver", "MyLifeCycleObserver - > ON_START");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void lifeCycleOnResume() {
        Log.e("MyLifeCycleObserver", "MyLifeCycleObserver - > ON_RESUME");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void lifeCycleOnPause() {
        Log.e("MyLifeCycleObserver", "MyLifeCycleObserver - > ON_PAUSE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void lifeCycleOnStop() {
        Log.e("MyLifeCycleObserver", "MyLifeCycleObserver - > ON_STOP");
    }

}


Log:
E/MyLifeCycleObserver: MyLifeCycleObserver - > ON_CREATE
E/MyLifeCycleObserver: MyLifeCycleObserver - > ON_START
E/MyLifeCycleObserver: MyLifeCycleObserver - > ON_RESUME
E/MyLifeCycleObserver: MyLifeCycleObserver - > ON_PAUSE
E/MyLifeCycleObserver: MyLifeCycleObserver - > ON_STOP

LifeCycle完美解决了组件对页面生命周期的依赖问题，使组件能够自己管理其生命周期，而无需在页面中对其进行管理。

针对Service，Android 单独提供了LifeCycleService，而不是像Activity、Fragment默认实现了LifeCycleOwner。

// Service的子类，实现了LifecycleOwner接口
public class LifecycleService extends Service implements LifecycleOwner{
......
}

针对Application，Android 提供了ProcessLifeCycleOwner - 监听整个应用程序的生命周期。

不过LifeCycleService、ProcessLifeCycleOwner，需要在build.gradle中单独添加如下依赖。

implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

有了ProcessLifeCycleOwner，我们就可以轻而易举的应用程序何时进入前台，何时进入后台，进而执行一些业务。

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new MyApplicationLifeCycleObserver());
    }
}

--------------
public class MyApplicationLifeCycleObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void lifeCycleOnCreate() {
        Log.e("AppLifeCycleObserver", "AppLifeCycleObserver - > ON_CREATE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void lifeCycleOnStart() {
        Log.e("AppLifeCycleObserver", "AppLifeCycleObserver - > ON_START");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void lifeCycleOnResume() {
        Log.e("AppLifeCycleObserver", "AppLifeCycleObserver - > ON_RESUME");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void lifeCycleOnPause() {
        Log.e("AppLifeCycleObserver", "AppLifeCycleObserver - > ON_PAUSE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void lifeCycleOnStop() {
        Log.e("AppLifeCycleObserver", "AppLifeCycleObserver - > ON_STOP");
    }

}
-----------
 E/AppLifeCycleObserver: AppLifeCycleObserver - > ON_CREATE
 E/AppLifeCycleObserver: AppLifeCycleObserver - > ON_START
 E/AppLifeCycleObserver: AppLifeCycleObserver - > ON_RESUME
 E/AppLifeCycleObserver: AppLifeCycleObserver - > ON_PAUSE
 E/AppLifeCycleObserver: AppLifeCycleObserver - > ON_STOP

注意点：

ProcessLifeCycleOwner是针对整个应用的监听，与Activity的数量没有关系
Lifecycle.Event.ON_CREATE只会调用一次，而Lifecycle.Event.ON_DESTROY用于不会被调用
需要注意的是，Lifecycle.Event.ON_PAUSE和Lifecycle.Event.ON_STOP这两个方法的调用有一定的延迟。因为系统需要为“旋转屏幕”，由于配置发生改变而导致Activity重新创建的情况预留一定的时间。

如下几条总结的很不错，来源于公众号博文：

我们日常使用的 androidx.appcompat.app.AppCompatActivity 和 androidx.fragment.app.Fragment 都实现了 LifecycleOwner 接口，其 getLifecycle() 方法返回的 Lifecycle 对象均为 LifecycleRegistry
AppCompatActivity 默认挂载了一个无 UI 界面的 ReportFragment，ReportFragment 会根据用户手机的系统版本号高低，用不同的方式获取到 AppCompatActivity 的事件变化通知，最终调用 LifecycleRegistry 的 handleLifecycleEvent(Lifecycle.Event) 方法将 Lifecycle.Event 传递出去。此时，LifecycleRegistry 就拿到了 Lifecycle.Event
androidx.fragment.app.Fragment 会在内部直接调用 LifecycleRegistry 的 handleLifecycleEvent(Lifecycle.Event) 方法完成事件通知，此时，LifecycleRegistry 也拿到了 Lifecycle.Event
LifecycleRegistry 会将外部 addObserver 传进来的 LifecycleObserver 对象都给包装成 ObserverWithState 类内部的 LifecycleEventObserver 对象，屏蔽了外部传进来的 LifecycleObserver 的差异性（可能是接口，也可能是注解）
LifecycleRegistry 通过直接调用 ObserverWithState 类内部的 LifecycleEventObserver 对象的 onStateChanged 方法来完成最终的事件回调。至此整个流程就完成了

可以看到，感知&分发生命周期的方式和Glide的实现有种似曾相识的感觉O(∩_∩)O