一文带你了解 Lifecycle (使用篇) | 开发者说·DTalk

本文原作者: 刘望舒，原文发布于公众号后厂村刘皇叔: https://mp.weixin.qq.com/s/TmI0O4OsvdD6DHkLm9EiiQ   


  前言

  在上一篇文章 (《一文带你相识 Android Jetpack | 开发者说·DTalk》) 中，我们基本相识了什么是 Android Jetpack，这一篇文章来先容 Android Jetpack 架构组件的 Lifecycle，Lifecycle 用于帮助开发者管理 Activity 和 Fragment 的生命周期，由于 Lifecycle 是 LiveData 和 ViewModel 的底子，所以需要先学习它。
  

  1. 为什么需要 Lifecycle

     在应用开发中，处理处罚 Activity 大概 Fragment 组件的生命周期相关代码是必不可免的。      
   官方文档中举了一个例子，这里简化一下，在 Activity 中写一个监听，在 Activity 的差异生命周期方法中调用这个监听。   

1. [/code]  public class MainActivity extends AppCompatActivity {
2.     private MyListener myListener;
4.     @Override
5.     protected void onCreate(Bundle savedInstanceState) {
6.         super.onCreate(savedInstanceState);
7.         setContentView(R.layout.activity_main);
8.         myListener = new MyListener(MainActivity.this);
9.     }
11.     @Override
12.     protected void onStart() {
13.         super.onStart();
14.         myListener.start();
15.     }
17.     @Override
18.     protected void onStop() {
19.         super.onStop();
20.         myListener.stop();
21.     }
22. }
25. class MyListener {
26.     public MyListener(Context context) {
27.     ...
28.     }
29.     void start() {
30.     ...
31.     }
32.     void stop() {
33.     ...
34.     }
35. }
37.   再举个 MVP 中常见的情况，如下所示。
38.   [code]public class MainActivity extends AppCompatActivity {
39.     private MyPresenter myPresenter;
41.     @Override
42.     protected void onCreate(Bundle savedInstanceState) {
43.         super.onCreate(savedInstanceState);
44.         setContentView(R.layout.activity_main);
45.         myPresenter = new MyPresenter();
46.     }
48.     @Override
49.     protected void onResume() {
50.         super.onResume();
51.         myPresenter.onResume();
52.     }
54.     @Override
55.     protected void onPause() {
56.         super.onPause();
57.         myPresenter.onPause();
58.     }
59. }
61. class MyPresenter{
62.     void onResume() {
63.     ...
64.     }
65.     void onPause() {
66.     ...
67.     }
68. }

复制代码

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

  2. 如何使用 Lifecycle

  分别来先容下依赖 Lifecycle 库和 Lifecycle 基本用法。
  


  2.1 依赖 Lifecycle 库

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

1. dependencies {
2.     def lifecycle_version = "2.0.0"
4.     // ViewModel and LiveData
5.     implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
6.     // alternatively - just ViewModel
7.     implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
8.     // alternatively - just LiveData
9.     implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
10.     // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
11.     //     AndroidX libraries use this lightweight import for Lifecycle
12.     implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
14.     annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
15.     // alternately - if using Java8, use the following instead of lifecycle-compiler
16.     implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
18.     // optional - ReactiveStreams support for LiveData
19.     implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // For Kotlin use lifecycle-reactivestreams-ktx
21.     // optional - Test helpers for LiveData
22.     testImplementation "androidx.arch.core:core-testing:$lifecycle_version"
23. }

复制代码

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

1. dependencies {
2.     def lifecycle_version = "1.1.1"
4.     // 包罗ViewModel和LiveData
5.     implementation "android.arch.lifecycle:extensions:$lifecycle_version"
6.     // 仅仅包罗ViewModel
7.     implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // For Kotlin use viewmodel-ktx
8.     // 仅仅包罗LiveData
9.     implementation "android.arch.lifecycle:livedata:$lifecycle_version"
10.     // 仅仅包罗Lifecycles
11.     implementation "android.arch.lifecycle:runtime:$lifecycle_version"
13.     annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
14.     // 如果用Java8, 用于替代compiler
15.     implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
17.     // 可选，ReactiveStreams对LiveData的支持
18.     implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"
20.     // 可选，LiveData的测试
21.     testImplementation "android.arch.core:core-testing:$lifecycle_version"
22. }

复制代码

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

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

复制代码

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

  2.2 Lifecycle 基本用法

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

1. [/code]     public    class MyObserver implements LifecycleObserver {   
2.        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)   
3.        public void connectListener() {   
4.         ...   
5.     }   
6.    
7.        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)   
8.        public void disconnectListener() {   
9.         ...   
10.     }   
11. }   
12.    
13. myLifecycleOwner.getLifecycle().addObserver(   new MyObserver());   //1   
14.     新建一个 MyObserver 类，它实现了 LifecycleObserver 接口，说明 MyObserver 成为了一个 Lifecycle 的观察者。
15.   
16. 然后在注释 1 处将 MyObserver 添加到 LifecycleOwner 中。LifecycleOwner 是一个接口，其内部只有一个方法 getLifecycle()，getLifecycle 方法用于获取 Lifecycle，这样就可以将 MyObserver 添加到 Lifecycle 中，当 Lifecycle 的生命周期发生变化时，MyObserver 就会观察到，大概说是感知到。
17.   
19.   如果使用是 Java8 , 那么可以使用 DefaultLifecycleObserver 来替代 LifecycleObserver: 
20.   [code]

复制代码

    class MyObserver implements DefaultLifecycleObserver {   
        @Override   
        public void onCreate(LifecycleOwner owner) {   
         ...   
     }   
 }   
    除此之外，不要忘了在 build.gradle 添加"androidx.lifecycle:common-java8:"
  


  3. Lifecycle 应用举例

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

  3.1 Activity 中使用

1. [/code]  package com.example.lifecycledemo1;
3. import android.arch.lifecycle.Lifecycle;
4. import android.arch.lifecycle.LifecycleObserver;
5. import android.arch.lifecycle.OnLifecycleEvent;
6. import android.support.v7.app.AppCompatActivity;
7. import android.os.Bundle;
8. import android.util.Log;
10. public class MainActivity extends AppCompatActivity {
12.     private static final String TAG = "MainActivity";
14.     @Override
15.     protected void onCreate(Bundle savedInstanceState) {
16.         super.onCreate(savedInstanceState);
17.         setContentView(R.layout.activity_main);
18.         getLifecycle().addObserver(new MyObserver());//1
19.     }
21.     public class MyObserver implements LifecycleObserver{
23.         @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
24.         void onResume(){
25.             Log.d(TAG, "Lifecycle call onResume");
26.         }
27.         @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
28.         void onPause(){
29.             Log.d(TAG, "Lifecycle call onPause");
30.         }
31.     }
33.     @Override
34.     protected void onResume() {
35.         super.onResume();
36.         Log.d(TAG, "onResume");
37.     }
39.     @Override
40.     protected void onPause() {
41.         super.onPause();
42.         Log.d(TAG, "onPause");
44.     }
45. }
47.   先实现 MyObserver，对 ON_CREATE 和 ON_RESUME 事件举行监听。因为在 Android Support Library 26.1.0 及其之后的版本，Activity 和 Fragment 已经默认实现了LifecycleOwner 接口，所以在注释 1 处可以直接使用 getLifecycle 方法获取 Lifecycle 对象，这样 MyObserver 就可以观察 MainActivity 的生命周期变化了，LifecycleOwner 可以明确为被观察者，MainActivity 默认实现了 LifecycleOwner 接口，也就是说 MainActivity 是被观察者。
48.   
49. 运行程序，打印的 log 如下所示。
50.   [code]

复制代码

    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，如下所示。

1. [/code]     public    class MyPresenter implements IPresenter {   
2.        private    static    final String TAG =    "test";   
3.    
4.        @Override   
5.        public void onResume() {   
6.         Log.d(TAG,    "Lifecycle call onResume");   
7.     }   
8.    
9.        @Override   
10.        public void onPause() {   
11.         Log.d(TAG,    "Lifecycle call onPause");   
12.     }   
13. }   
14.    
15.    interface IPresenter extends LifecycleObserver {   
16.    
17.        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)   
18.        void onResume();   
19.    
20.        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)   
21.        void onPause();   
22. }   
23.     IPresenter 接口继承自 LifecycleObserver 接口，MyPresenter 又实现了 IPresenter 接口，这样 MyPresenter 成为了一个观察者。
24.   
25. 接着在 MainActivity 中参加 MyPresenter: 
26.   [code]

复制代码

    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 的方法了。
  
打印的日志如下:

1. [/code]     D/test: onResume   
2. D/test: Lifecycle call onResume   
3. D/test: Lifecycle call onPause   
4. D/test: onPause   
5.     [size=4][b]4. 自界说 LifecycleOwner[/b][/size]
7.   如果想实现自界说 LifecycleOwner，可以使用 LifecycleRegistry，它是 Lifecycle 的实现类。Android Support Library 26.1.0及其之后的版本，Activity 和 Fragment 已经默认实现了 LifecycleOwner 接口，因此我们可以这么写:
8.   [code]

复制代码

    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 的原理，下一篇我们就来学习 Lifecycle 的原理。
  

   

                                             "开发者说·DTalk" 面向中国开发者们征集 Google 

移动应用 (apps & games) 相关的产物/技能内容。欢迎各人前来分享您对移动应用的行业洞察或见解、移动开发过程中的心得或新发现、以及应用出海的实战履历总结和相关产物的使用反馈等。我们由衷地希望可以给这些出众的中国开发者们提供更好展现自己、充实发挥自己特长的平台。我们将通过各人的技能内容着重选出优秀案例举行谷歌开发技能专家 (GDE) 的推荐。

                                       

  

 点击屏末 | 阅读原文 | 相识更多 "开发者说·DTalk" 运动详情与参与方式
  

                                   长按右侧二维码
        报名参与
                                                

   

  

来源：https://blog.csdn.net/jILRvRTrc/article/details/100972612
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！