android开发学习

Lifecycle的基本使用

2021-11-24  本文已影响0人  我要离开浪浪山

一、前言：

Lifecycle是Google推出的一系列的框架组件的其中一个，主要是用来感知Activity和Fragment的生命周期。

1、Lifecycle组件是在其他组件的生命周期状态发生改变时，产生相应行为的一种组件。
2、Lifecycle能帮助产生更好组织且更轻量级的代码，便于维护。
3、在不使用Lifecycle时，常规的生命周期处理的缺点是什么?

  • 常规方法是在Activity和Fragment的生命周期方法里面去实现独立组件的行为
  • 这种模式会导致代码组织性差
  • 增生更多的错误

4、Lifecycle的好处是什么?

  • 通过使用可感知生命周期的组件，可以将生命周期方法中关于这些组件的代码，移动到组件的内部
  • 通过android.arch.lifecycle提供的内容，可以让组件主动调节自身的行为，根据activity/fragment当前的生命周期状态进行调整。

5、几乎所有app组件都可以和Lifecycle关联起来，这些都是由操作系统或者运行在程序中的FrameWork层代码进行支持的。

使用Lifecycle能减少内存泄漏和系统崩溃的可能性

二、Lifecycle集成

1、Lifecycle的集成只需要在app的build.gradle中配置

    // 引入lifecycle
    def lifecycle_version = "2.0.0"
    // ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"

2、实现LifecycleObserver接口

public class TestLifeCycle implements LifecycleObserver {
    private static final String TAG = "test";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.d(TAG, "onCreate: ");
    }

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

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

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

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

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d(TAG, "onDestroy: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny() {
        Log.d(TAG, "onAny: ");
    }
}

通过实现LifecycleObserver接口，然后在相应的方法上面添加注解@OnLifecycleEvent(Lifecycle.Event.XXX)即可。实际上，这就是一个观察者。当执行到某个生命周期时，会通知观察者执行对应的方法。

3、Activity中添加观察者

public class TestActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);
        getLifecycle().addObserver(new TestLifeCycle());
    }
}

继承AppCompatActivity后，即可通过添加观察者来监听此Activity的生命周期了。相比第2小节的例子，只要一句话就完事，是不是简单多了呢。到这里，Lifecycle的简单使用例子就完成了。

我们先来看下一个完整的生命周期的输出结果：

07-24 23.23:55.892 15728-15728/com.test.start D/test: onCreate: 
07-24 23.23:55.892 15728-15728/com.test.start D/test: onAny: 
07-24 23.23:55.893 15728-15728/com.test.start D/test: onStart: 
07-24 23.23:55.893 15728-15728/com.test.start D/test: onAny: 
07-24 23.23:55.895 15728-15728/com.test.start D/test: onResume: 
07-24 23.23:55.895 15728-15728/com.test.start D/test: onAny: 
07-24 23.23:58.183 15728-15728/com.test.start D/test: onPause: 
07-24 23.23:58.184 15728-15728/com.test.start D/test: onAny: 
07-24 23.23:58.576 15728-15728/com.test.start D/test: onStop: 
07-24 23.23:58.577 15728-15728/com.test.start D/test: onAny: 
07-24 23.23:58.585 15728-15728/com.test.start D/test: onDestroy: 
07-24 23.23:58.586 15728-15728/com.test.start D/test: onAny:

可以看到，onAny是每个生命周期都会调用到一次。其他的话，就是正常调用。

注意，目前只能通过继承AppCompatActivity来实现这种简单的方式，直接继承Activity的话稍复杂，祥见后面的分析，暂且不表。

4、Fragment中添加观察者

public class TestFragment extends Fragment {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new TestLifeCycle());
    }
}

同样，也可以监听到Fragment的生命周期，加一个观察者即可。

二、Lifecycle详解

1、Lifecycle类

Lifecycle类持有Activity 或 Fragment等组件的生命周期信息，并且允许其他对象观察这些信息。
Lifecycle内部使用了两个枚举来跟踪其关联组件的生命周期状态：Event和State。祥见下面分析。

可以通过调用Lifecycle类的 addObserver()方法来添加观察者，如下：

getLifecycle().addObserver(new TestLifeCycle());

2、Lifecycle事件

Lifecycle组件可以感知如下事件：

public abstract class Lifecycle {
    public enum Event {
        ON_CREATE,ON_START,ON_RESUME,ON_PAUSE,ON_STOP,ON_DESTROY,ON_ANY
    }
}

看起来有7种，实际上也就是6种而已。ON_ANY表示所有的事件都会感知。可以看到，像Activity的onRestart()，Fragment的onCreateView()等等其他生命周期是无法感知的。

3、Lifecycle状态

Lifecycle组件内部维护了一个State来标识Activity或Fragment当前的状态。如下：

public abstract class Lifecycle {
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

4、LifecycleOwner接口

  • LifecycleOwner表示它的实现类具有一个 Lifecycle。它有一个 getLifecycle()方法，该方法必须由实现类实现。
  • AppCompatActivity和Fragment都实现了LifecycleOwner接口（Support Library 26.1.0之后的版本），所以可以直接拿来使用。
  • 但是Activity类并没有实现LifecycleOwner接口，所以，如果我们需要去监听自定义Activity的话，需要自己手动去实现LifecycleOwner接口。详见后面分析。

5、 LifecycleObserver接口（观察者）

LifecycleObserver其实现类可以通过感知相应的生命周期来完成特定的操作。可以看前面的例子实现。

6、自定义Activity中实现LifecycleOwner

感知AppCompatActivity和Fragment的子类生命周期都很简单，一行代码就可以完成了。但是感知自定义Activity就稍微复杂了点，需要我们手动去完成以下步骤：

  • 实现LifecycleOwner接口
  • 重写getLifecycle()方法
  • 手动标记生命周期的状态

其代码如下所示：

public class TestActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry;

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

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);
        //创建Lifecycle对象
        mLifecycleRegistry = new LifecycleRegistry(this);
        //标记状态
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        //添加观察者
        getLifecycle().addObserver(new TestLifeCycle());
    }
    
    @Override
    public void onStart() {
        super.onStart();
        //标记状态
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @Override
    protected void onResume() {
        super.onResume();
        //标记状态
        mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //标记状态
        mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
    }
}

三、Lifecycle原理

1、LifecycleOwner的作用?

  • 一个接口
  • 具有方法getLifecycle()，例如Activity就可以通过该方法，获取到Lifecycle
  • getLifecycle()的内部返回的是LifecycleRegistry，通过LifecycleRegistry处理不同的状态。

2、如何监控整个app的生命周期?

  • 使用ProcessLifecycleOwner

3、Fragment、AppCompatActivity都实现了LifecycleOwner接口

4、自定义Application需要自己实现LifecycleOwner接口

————————————————
参考链接1：https://blog.csdn.net/u011810352/article/details/81203095
参考链接2：https://blog.csdn.net/feather_wch/article/details/88630095

上一篇 下一篇

猜你喜欢

热点阅读