Android 架构组件之 LifeCycle详解

时间  2019-12-07
标签 android 架构 组件 lifecycle 详解 栏目 Android 繁體版
原文   原文链接

一、Lifecycle介绍

lifecycle官方文档地址：
https://developer.android.com/topic/libraries/architecture/lifecyclehtml

为何要使用lifecycle？
activity 和fragment 是有声明周期的，有时候，咱们的不少操做须要写在声明周期的方法中，好比，下载，文件操做等，这样不少状况下回致使，咱们在activity中的声明周期方法中写愈来愈多的代码，activity或者fragment 愈来愈臃肿，代码维护愈来愈困难。 使用lifecycle就能够很好的解决这类问题。
lifecycle代码简洁，咱们能够经过实现LifecycleObserver 接口，来监听声明周期，而后咱们在activity和fragment中去注册监听。

二、几个重要的类和接口

  • Lifecycle
    Lifecycle是一个持有组件生命周期状态（如Activity或Fragment）的信息的类，并容许其余对象观察此状态。
  • Event ：从框架和Lifecycle类派发的生命周期事件。这些事件映射到活动和片断中的回调事件。
  • State ：由Lifecycle对象跟踪的组件的当前状态。
  • LifecycleOwner （重要）Lifecycle持有者
  • 实现该接口的类持有生命周期(Lifecycle对象)，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
  • LifecycleObserver（重要）Lifecycle观察者
  • 实现该接口的类，经过注解的方式，能够经过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册,被注册后，LifecycleObserver即可以观察到LifecycleOwner的生命周期事件。

三、LifeCycle中两个重要的接口LifeCycleOwner和LifecycleObserver 的使用

（1）LifecycleOwner（生命周期持有者接口）
官网介绍： LifecycleOwner是一个单一的方法接口，表示该类有一个 Lifecycle。它有一个方法， getLifecycle()这个方法 必须由这个类来实现。若是您试图管理整个应用程序进程的生命周期，请参阅 ProcessLifecycleOwner。该接口从各个类（如Fragment和AppCompatActivity）抽象生命周期的全部权，并容许编写与它们一块儿工做的组件。
任何自定义应用程序类均可以实现LifecycleOwner接口
实现LifecycleObserver的组件与实现LifecycleOwner的组件无缝协做，由于全部者能够提供生命周期，观察者能够注册以观看

简单来讲，LifecycleOwner就是一个接口，谁继承了它，就持有了lifecycle对象。而后就能够调用getLifecycle()方法获取继承了抽象类Lifecycle的LifecycleRegistry，而后调用 addObserver(@NonNull LifecycleObserver observer) 方法来注册监听。
这样，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。java

注意：Support Library 26.1.0 及其之后的版本，Activity 和Fragment 已经实现了LifecycleOwner 接口，因此，咱们能够直接在Activity 和Fragment中使用getLifecycle()方法来获取lifecycle对象，来添加观察者监听。android

（2）LifecycleObserver（生命周期观察者接口）
LifecycleObserver 是一个观察者接口，实现了它，能够经过注解或者继承的方式，来管理声明周期的监听。只要在持有lifecycle的类中注册了它，当声明周期发生变化时，它就能收到，进行咱们自定义的操做。

两种实现方式：编程

  1. 实现DefultLifecyceObserver接口，而后重写里面生命周期方法；
  2. 直接实现LifecycleObserver接口，而后经过注解的方式来接收生命周期的变化；

Lifecycle.java文档中是建议使用第一种方式，由于文档中说明了，随着Java8成为主流，注解的方式会被弃用。DefaultLifecycleObserver是须要另外声明的java8 好比下面
GenericLifecycleObserver，FullLifecycleObserver，DefaultLifecycleObserver 这三个接口都是直接或者间接继承的LifecycleObserverapi

// 若是使用的是java 8要显示声明以下的
def lifecycle_version = "1.1.1"
implementation "android.arch.lifecycle:common-java8:$lifecycle_version"

在这里插入图片描述

三、开始使用Lifecycle

咱们写个测试代码，首先，咱们要测试一下，到底LifecycleObserver到底能不能监听到声明周期的变化。而且实验下上图中的声明周期状态
先写两个简单的Activity，FirstActivity 和SecondActivity, 单纯的一个跳转。网络

public class FirstActivity extends AppCompatActivity {

    private Button firstBtn;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.first_activity_layout);
        initView();
        initListener();
    }

    private void initView() {
        firstBtn = findViewById(R.id.first_btn);
    }

    private void initListener() {
        firstBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });
    }
}

接下来，咱们要作的是要写一个须要拥有声明周期的类，正常咱们自定义控件啊，或者作其余逻辑的类，是没有声明周期的，如今有了LifecycleObserver,咱们可让一个普通的类拥有感知声明周期变化的能力。好比，如今自定义一个，MyObserver类。框架

public class MyObserver implements DefaultLifecycleObserver{
   private static final String TAG = "MyListener";

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        Log.d(TAG,"onCreate()");
        Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.d(TAG,"onStart()");
        Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.d(TAG,"onResume()");
        Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
     
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.d(TAG,"onPause()");
        Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.d(TAG,"onStop()");
        Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.d(TAG,"onDestroy() ");
        Log.d(TAG,"当前生命周期状态="+lifecycle.getCurrentState().name());
    }


}

咱们采起的是，直接继承DefaultLifecycleObserver接口，来实现它全部的方法。咱们在里面作了log,来查看，是否这个类，收到了activity声明周期的变化。
而后，要作的就是注册监听
在Activity 的OnCreate方法中，调用getLifecycle();编程语言

public class FirstActivity extends AppCompatActivity {

    private Button firstBtn;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.first_activity_layout);
        initView();
        initListener();
        //添加了这一行代码
        getLifecycle().addObserver(new MyObserver());
    }

    private void initView() {
        firstBtn = findViewById(R.id.first_btn);
    }

    private void initListener() {
        firstBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });
    }
}

能够看到，api26,.1之后，Activity中能够直接 getLifecycle().addObserver(new MyObserver()); 这样，就已经注册了声明周期观察者的监听。运行查看log
启动FirstActivity后，MyObserver类已经监听到了Activity的声明周期方法
而且，和图中表示一致，各个声明周期方法对应相应的节点。必定要清楚，后面会用到。好比，onResume()方法执行后，Activity处于RESUME状态，咱们能够经过判断这个状态来作一些事情ide

在这里插入图片描述
点击跳转到SecondActivity
在这里插入图片描述
能够看到，FirstActivity声明周期走了onPause onStop，MyObserver也成功监听到了，继续返回FirstActivity
在这里插入图片描述
最后，点击返回键，退出FirstActivity，
在这里插入图片描述测试

经过这个简单的小例子，咱们看到了 咱们的类，只要实现了 LifecycleObserver接口，而后，在Activity 或者Fragment中 经过getLifecycle().addObserver()方法，把这个类的对象传入，就能够实现声明周期的感应监听。

固然，咱们能够再初始化这个类的时候，把Lifecycle对象传入，那咱们自定义的类就能够本身去管理声明周期，而不依赖activity或者fragment。 这样，activity在使用此类的时候就没必要关系声明周期的问题，由于，在这个类里面咱们已经处理了。好比： 给MyObserver类 添加一个构造方法，传入一个Lifecycle对象。

要注意的是：
生命周期状态为RESUMED时表示，当前activity 是在前台，而且可交互也就是onResume()执行后

生命周期状态为STARTED时，表示当前activity处于可见可是不可交互，也就是onStart()方法刚执行完或者onPause()方法刚执行完的状态

生命周期状态为CREATED,表示onCreate()方法刚刚执行完或者onStop()方法刚刚执行完，也就是当前activity不在前台，可是也没有处于销毁状态。

生命周期状态为DESTORYED,表示当前Activity还不存在，没有被建立或者已经销毁，咱们一般考虑比较多的就是，onDestory()方法执行后，当前Activity已经销毁。

因此，若是咱们要保证在Activity或者Fragment的有效生命周期内进行的操做，必须判断，当前lifecycle的状态是否至少是CREATED状态，避免Activity或者fragment销毁了之后，回调或者网络请求才回来，此时作一些操做会致使异常。

添加如下代码，就是咱们把lifecycle对象传给观察者，让它本身去判断回调后的代码，保证至少是CREATED状态

private Lifecycle lifecycle;
   public MyObserver(Lifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }
//而后再相应的回调方法中使用下面代码判断，保证数据回调回来，当前activity是存在的
    if (lifecycle.getCurrentState().isAtLeast(CREATED)) {
            //这里只是示例，不必定是CREATED
    }

这里用到了Lifecycle类的方法，下面咱们看一下Lifecycle的源码

public abstract class Lifecycle {
    @MainThread  //添加将在LifecycleOwner更改状态时通知的LifecycleObserver。
    public abstract void addObserver(@NonNull LifecycleObserver observer);

    @MainThread //从观察者列表中删除给定的观察者。
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread //返回生命周期的当前状态。
    public abstract State getCurrentState();

    @SuppressWarnings("WeakerAccess")
    public enum Event {

        ON_CREATE,//用于onCreate事件的常量LifecycleOwner。

        ON_START,

        ON_RESUME,

        ON_PAUSE,

        ON_STOP,

        ON_DESTROY,

        ON_ANY //一个Event能够用来匹配全部事件的常数。 
    }

    @SuppressWarnings("WeakerAccess")
    public enum State {

        DESTROYED,
        INITIALIZED, //LifecycleOwner的初始化状态。 
        CREATED, 
        STARTED,
        RESUMED;
                //比较此状态是否大于或等于给定值state。
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

/**
 * Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on
 * {@link OnLifecycleEvent} annotated methods.
 * <p>
 * @see Lifecycle Lifecycle - for samples and usage patterns.
 */
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {

}

就是一个抽象类，注释已经很详细了，应该不用解释了

最后借用下官网的-生命周期感知组件的最佳实战

  1. 尽量保持您的UI控制器（活动和片断）尽量精简。他们不该该试图获取他们本身的数据;相反，使用ViewModel来作到这一点，并观察一个LiveData对象来反映更改回视图。
  2. 尝试编写数据驱动的用户界面，其中您的用户界面控制器的职责是在数据更改时更新视图，或将用户操做通知给ViewModel。
  3. 把你的数据逻辑放在ViewModel类中。ViewModel应做为您的UI控制器和其余应用程序之间的链接器。但要当心，ViewModel不负责提取数据（例如，来自网络）。相反，ViewModel应调用相应的组件来获取数据，而后将结果提供给UI控制器。
  4. 使用dataBinding在视图和UI控制器之间保持干净的界面。这使您可使您的视图更具说明性，并最大限度地减小须要在活动和片断中编写的更新代码。

若是你喜欢用Java编程语言来作到这一点，可使用像Butter Knife这样的库来避免样板代码而且有更好的抽象。

  1. 若是您的UI很复杂，请考虑建立一个演示者类（presenter）来处理UI修改。这多是一项艰巨的任务，但它可使您的UI组件更易于测试。
  2. 避免在ViewModel中引用View或Activity上下文。

若是ViewModel超出活动（在配置更改的状况下），则活动会泄漏而且垃圾收集器没法正确处理。

借用下https://blog.csdn.net/zhuzp_b... 做者的两张图，更清晰，对于相信信息，可到做者博客去查看相关讲解
这里写图片描述

这里写图片描述

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程