Jetpack 之 LifeCycle 组件使用详解

程序员文章站 2022-06-07 18:17:57

...

一、LifeCycle 简介

LifeCycle 是一个可以感知宿主生命周期变化的组件。常见的宿主包括 Activity/Fragment、Service 和 Application。LifeCycle 会持有宿主的生命周期状态的信息，当宿主生命周期发生变化时，会通知监听宿主的观察者。

LifeCycle 的出现主要是为了解决： 系统组件的生命周期与普通组件之间的耦合性。

系统组件指：Activity/Fragment、Service 和 Application。
普通组件指：将代码按照功能或者作用封装成的组件。

Jetpack 之 LifeCycle 组件使用详解

哪些情况下，系统组件的生命周期会和普通组件的生命周期耦合在一起呢？

举个栗子：

在 58 部落业务中有视频播放的业务需求。我们需要在 Activity 中对视频播放组件进行初始化，在 onPause() 方法中停止视频的播放，在 onDestroy() 方法中对视频播放组件以及一些资源进行回收。这样的做法非常繁琐，会让页面与组件之间的耦合度变高。

对于这类问题，完全可以使用 LifeCycle 来解决。它不仅降低了模块之间的耦合度，还降低了内存泄露发生的可能性。

二、LifeCycle 的使用

Jetpack 为我们提供了两个接口：

被观察者：LifecycleOwner

观察者：LifecycleObserver

被监听的系统组件需要去实现 LifecycleOwner 接口，观察者需要实现 LifecycleObserver 接口。

（一）使用场景1：使用 LifeCycle 解耦页面与组件

（1）解耦 Activity

第一步：添加依赖

implementation 'androidx.appcompat:appcompat:1.2.0'

在 AndroidX 里面 ComponentActivity 已经默认实现了 LifecycleOwner 接口。如果项目没有迁移到 AndroidX，还是用的 Support 库，新版本的 SDK 也通过 SupportActivity 实现了 LifecycleOwner 接口。

Jetpack 之 LifeCycle 组件使用详解

在 LifecycleOwner 接口中，只有一个 getLifecycle 方法。

第二步：实现观察者

如果是想监听某个 Activity 的生命周期，需要我们做的就是自定义组件，实现 LifecycleObserver 接口即可，该接口没有接口方法，不需要任何具体的实现。

比如以刚刚的视频播放为例：

创建一个 MyVideoPlayListener 类，实现 LifecycleObserver 接口，与视频播放相关的逻辑全在这个类里面完成。对于组件里面需要在 Activity 生命周期变化时得到通知的方法，用 @OnLifecycleEvent(Lifecycle.Event.ON_XXX) 注解进行标记，这样当 Activity 生命周期发生变化时，被标记过的方法便会被自动调用。

public class MyVideoPlayListener implements LifecycleObserver {
    private static String TAG = "MyVideoPlayListener";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void initVideo(){
        Log.d(TAG,"initVideo");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void startPlay(){
        Log.d(TAG,"startPlay");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void pausePlay(){
        Log.d(TAG,"pausePlay");
    }
}

2.在 MainActivity 中对 MyVideoPlayListener 进行引用即可。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MyVideoPlayListener listener = new MyVideoPlayListener();
        getLifecycle().addObserver(listener);
    }
}

（2）解耦 Fragment

在新版的 SDK 中，Fragment 同样也默认实现了 LifecycleOwner 接口，因此，以上的例子同样适合于 Fragment。

（二）使用场景2：使用 LifecycleService 解耦 Service 与组件

（1）LifecycleService 基本介绍

Android 中拥有生命周期的组件除了 Activity/Fragment ，还有一个非常重要的组件就是 Service。LifecycleService 就是用来监听和解耦 Service 组件的。

public class LifecycleService extends Service implements LifecycleOwner {

    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);

    ......

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

（2）具体使用方法

第一步：添加相关依赖

implementation "androidx.lifecycle:lifecycle-service:2.2.0"

第二步：创建 MyServiceObserver 类，实现 LifecycleObserver 接口。使用 @OnLifecycleEvent 标记希望在 Server 生命周期发生变化时得到同步调用的方法。

public class MyServiceObserver implements LifecycleObserver {
    private static String TAG = "MyServiceObserver";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void initVideo(){
        Log.d(TAG,"initVideo");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private void pausePlay(){
        Log.d(TAG,"stopPlay");
    }
}

第三步：创建一个 MyService 的类，继承 LifecycleService。由于 LifecycleService 是 Service 的直接子类，所以使用起来与普通的 Service 没有差别。

public class MyService extends LifecycleService {
    private MyServiceObserver myServiceObserver;
    
    public MyService(){
        myServiceObserver = new MyServiceObserver();
        getLifecycle().addObserver(myServiceObserver);
    }
}

（三）使用场景3：使用 ProcessLifecycleOwner 监听应用程序的生命周期

具有生命周期的组件除了 Activity、Fragment 和 Service 外，还有 Application。ProcessLifecycleOwner 就是用来监听整个应用程序的生命周期情况。

具体使用方法：

第一步：添加依赖项

implementation "androidx.lifecycle:lifecycle-process:2.2.0"

第二步：定义一个 ApplicationObserver，实现 LifecycleObserver 接口。

public class ApplicationObserver implements LifecycleObserver {
    private String TAG = this.getClass().getName();

    /**
     * 在应用程序的整个生命周期中只会被调用一次
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.d(TAG,"Lifecycle.Event.ON_CREATE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.d(TAG,"Lifecycle.Event.ON_START");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.d(TAG,"Lifecycle.Event.ON_RESUME");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.d(TAG,"Lifecycle.Event.ON_PAUSE");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.d(TAG,"Lifecycle.Event.ON_STOP");
    }

    /**
     * 永远不会被调用，系统不会分发调用 ON_DESTROY 事件
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d(TAG,"Lifecycle.Event.ON_DESTROY");
    }
}

第三步：在 Application 中关联 ApplicationObserver。

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());
    }
}

注意事项：

ProcessLifecycleOwner 是针对整个应用程序的监听，与 Activity 的数量无关。
Lifecycle.Event.ON_CREATE 只会被调用一次，而 Lifecycle.Event.ON_DESTROY 永远不会被调用。
Lifecycle.Event.ON_PAUSE 和 Lifecycle.Event.ON_STOP 的调用会有一定的延后，因为系统需要为“屏幕旋转，由于配置发生变化而导致的 Activity 重新创建” 的情况预留一些时间。

三、LifeCycle 的另外两种写法

LifeCycle 有三种实现方法：

LifecycleObserver 配合 @OnLifecycleEvent 注解
DefaultLifecycleObserver 拥有宿主所有生命周期事件
LifecycleEventObserver 将宿主生命周期事件封装成 Lifecycle.Event

在上一节使用介绍中，我们用的是第一种方式：LifecycleObserver 配合 @OnLifecycleEvent 注解。

这种方式使用比较简单，但是注意最好添加 lifecycle-compiler 这个注解处理器，否者在运行时会使用反射的形式回调到对应的方法上：

annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.2.0"

加上这个注解处理器后，用 @OnLifecycleEvent 标记的方法就不能再声明成 private ，否者会报如下的错误：

method marked with OnLifecycleEvent annotation can not be private

下面介绍一下另外两种实现方式：

（一）DefaultLifecycleObserver 拥有宿主所有生命周期事件

使用 DefaultLifecycleObserver 需要用到 Java8，我们首先添加依赖：

implementation "androidx.lifecycle:lifecycle-common-java8:2.2.0"

然后在模块级别的 build.gradle 中添加：

android {
  ...
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

使用 lifecycle-common-java8 依赖后，就可以将 lifecycle-compiler 依赖去掉。

DefaultLifecycleObserver 接口中有 6 个生命周期方法：

public interface DefaultLifecycleObserver extends FullLifecycleObserver {

    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onStart(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onResume(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onPause(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onStop(@NonNull LifecycleOwner owner) {
    }

    @Override
    default void onDestroy(@NonNull LifecycleOwner owner) {
    }
}

该接口继承自 FullLifecycleObserver ，由于权限问题，我们不能直接使用 FullLifecycleObserver 来拥有宿主的所有生命周期事件。

所以，我们需要通过实现 DefaultLifecycleObserver 接口，然后重写自己业务需要监听的生命周期方法。

（二）LifecycleEventObserver 宿主生命周期事件封装成 Lifecycle.Event

//通过实现 LifecycleEventObserver 接口，重写 onStateChanged 方法，在该方法内部
//通过判断 Lifecycle.Event 来实现具体的业务逻辑
public class MyVideoPlayObserver implements LifecycleEventObserver {
    private static String TAG = "MyVideoPlayObserver";

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event){
            case ON_CREATE:
                Log.d(TAG,"initVideo");
                break;
            case ON_START:
                Log.d(TAG,"startPlay");
                break;
            case ON_RESUME:
                Log.d(TAG,"resumePlay");
                break;
            default:
                 break;
        }
    }
}

对于这三种实现方式如何选择呢？

建议使用 DefaultLifecycleObserver 和 LifecycleEventObserver 的方式。

Java8 使用 DefaultLifecycleObserver 来实现 Lifecycle，Java7 使用注解的方式。如果一旦 Java8 成为 Android 的主流后，注解的方式会被弃用。
如果一个类同时实现了 DefaultLifecycleObserver 接口和 LifecycleEventObserver 接口，那么 DefaultLifecycleObserver 中的方法会先触发，然后才执行 LifecycleEventObserver 的 onStateChanged 方法。
如果一个类实现了 DefaultLifecycleObserver 接口，同时使用了 @OnLifecycleEvent 注解，那么注解的方式会被自动忽略掉。

四、总结

LifeCycle 组件存在的主要意义是帮助我们解耦，让自己定义的组件也能够感受到生命周期的变化。

五、补充

截止本文发布时，lifecycle_version 最新版本是 2.2.0，如需获取最新版本请查看官网：

https://developer.android.google.cn/jetpack/androidx/releases/lifecycle

注：lifecycle-extensions 中的 API 已弃用，需要使用到 Lifecycle 下的某个工具时，添加对应的依赖即可：

    dependencies {
        def lifecycle_version = "2.2.0"
        def arch_version = "2.1.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // Annotation processor
        annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"
    }

六、参考资料

Google Jetpack 官方文档

慕课专栏：跟架构师学Jetpack

《Android Jetpack 应用指南》叶坤

上一篇： [愉快学php100天]第三天:不羁的PHP文件操作

下一篇： PHP消息队列用法实例分析

Jetpack 之 LifeCycle 组件使用详解

一、LifeCycle 简介

二、LifeCycle 的使用

（一）使用场景1：使用 LifeCycle 解耦页面与组件

（1）解耦 Activity

第一步：添加依赖

第二步：实现观察者

（2）解耦 Fragment

（二）使用场景2：使用 LifecycleService 解耦 Service 与组件

（1）LifecycleService 基本介绍

（2）具体使用方法

第一步：添加相关依赖

第二步：创建 MyServiceObserver 类，实现 LifecycleObserver 接口。使用 @OnLifecycleEvent 标记希望在 Server 生命周期发生变化时得到同步调用的方法。

第三步：创建一个 MyService 的类，继承 LifecycleService。由于 LifecycleService 是 Service 的直接子类，所以使用起来与普通的 Service 没有差别。

（三）使用场景3：使用 ProcessLifecycleOwner 监听应用程序的生命周期

第一步：添加依赖项

第二步：定义一个 ApplicationObserver，实现 LifecycleObserver 接口。

第三步：在 Application 中关联 ApplicationObserver。

三、LifeCycle 的另外两种写法

（一）DefaultLifecycleObserver 拥有宿主所有生命周期事件

（二）LifecycleEventObserver 宿主生命周期事件封装成 Lifecycle.Event

四、总结

五、补充

六、参考资料

Node.js之readline模块的使用详解

Vue.js 2.x之组件的定义和注册图文详解

微信小程序组件的外部样式externalClasses使用详解

php之Smarty模板使用方法示例详解

通过npm引用的vue组件使用详解

Vue异步组件使用详解

JSP 开发之Spring BeanUtils组件使用

Vuejs第十一篇组件之slot内容分发实例详解

VsCode之使用WebView通信详解

jQuery EasyUI Panel面板组件使用详解

Jetpack 之 LifeCycle 组件使用详解

一、LifeCycle 简介

二、LifeCycle 的使用

（一）使用场景1：使用 LifeCycle 解耦页面与组件

（1）解耦 Activity

第一步：添加依赖

第二步：实现观察者

（2）解耦 Fragment

（二）使用场景2：使用 LifecycleService 解耦 Service 与组件

（1）LifecycleService 基本介绍

（2）具体使用方法

第一步：添加相关依赖

第二步：创建 MyServiceObserver 类，实现 LifecycleObserver 接口。使用 @OnLifecycleEvent 标记希望在 Server 生命周期发生变化时得到同步调用的方法。

第三步：创建一个 MyService 的类，继承 LifecycleService。由于 LifecycleService 是 Service 的直接子类，所以使用起来与普通的 Service 没有差别。

（三）使用场景3：使用 ProcessLifecycleOwner 监听应用程序的生命周期

第一步：添加依赖项

第二步：定义一个 ApplicationObserver，实现 LifecycleObserver 接口。

第三步：在 Application 中关联 ApplicationObserver。

三、LifeCycle 的另外两种写法

（一）DefaultLifecycleObserver 拥有宿主所有生命周期事件

（二）LifecycleEventObserver 宿主生命周期事件封装成 Lifecycle.Event

四、总结

五、补充

六、参考资料

Node.js之readline模块的使用详解

Vue.js 2.x之组件的定义和注册图文详解

微信小程序 组件的外部样式externalClasses使用详解

php之Smarty模板使用方法示例详解

通过npm引用的vue组件使用详解

Vue异步组件使用详解

JSP 开发之Spring BeanUtils组件使用

Vuejs第十一篇组件之slot内容分发实例详解

VsCode之使用WebView通信详解

jQuery EasyUI Panel面板组件使用详解

微信小程序组件的外部样式externalClasses使用详解