Android Architecture Components系列之Lifecycle

简介：去年的Google IO大会，除了敲定kotlin为Android的官方开发语言，还退出了Android Architecture Components组件，旨在帮助开发者构建更好的构建app。从前有人问google:有没有一种官方通用而且稳定的app架构方案，开发者只需要遵循这个方案就可以构建出稳定而且易开发维护的app?然而google给的回答是：

可是架构这种东西对于普通的开发者来说逼格实在太高，尤其是对我这种萌新开发者来说。于是google可能是良心发现了，为了Android的生态能良好的发展下去，于是推出了Android Architecture Components一系列组件。其实就是一套帮助Android开发者解决架构设计的方案。好吧，其主要包含以下三个模块：

1. Lifecycler相关
2. ViewModel和LiveData相关
3. Room数据持久化解决方案

本篇先来讲一讲Lifecycle。
Lifecycle，生命周期。众所周知，Activity和Fragment存在着大量的生命周期方法，在实现某一个功能的时候，我们需要在onCreate中做些什么，onStart中做些什么、甚至是onPause和onStop、onDetroy中都需要我们进行一定的操作，比如资源的初始化、资源的释放等等。来看如下场景:

public class MainActivity extends Activity {

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

    @Override
    protected void onStart() {
        super.onStart();
        doSomething();
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        doSomething();
    }

    @Override
    protected void onResume() {
        super.onResume();
        doSomething();
    }

    @Override
    protected void onPause() {
        super.onPause();
        doSomething();
    }

    @Override
    protected void onStop() {
        super.onStop();
        doSomething();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        doSomething();
    }


}

我们常常要在Activity中重写许多生命周期方法去管理我们Activity的生命周期。带来的坏处就是Activity承载了大量的生命周期管理的代码，如果简单还好，如果生命周期方法中的代码比较复杂，维护起来就比较痛苦了，Activity中的代码看起来也不简洁，显的冗余。Lifecycle的出现其实就是把Activity的生命周期管理剥离了出来，放在另外一个类中，便于管理。如何剥离：

Google提供了两个接口和一个类：
1. LifecycleObserver接口。
这是一个接口，我们上文说把生命周期的管理从Activity中剥离到一个新的类中，而这个类就是这个接口的实现类。字面意思是生命周期的观察者，实际上也是这个意思，Activity、Fragment等组件的生命周期方法的执行都能被这个类监听到。

2. LifecycleOwner接口。
生命周期的拥有者，这个再好理解不过了，就是Activity和Fragment这些组件，不信？咱们看下Android的源代码：

3. Lifecycle类。
就是一个持有Activity或Fragment这些组件生命周期状态信息的一个类，并允许其它对象观察这个状态，它是抽象类。它有个子类：LifecycleRegistry

好了，说完这几个接口和类，咱们来说说到底怎么用，怎么把Activity的生命周期代码剥离开来。

1. 创建LifecycleObserver实现类，用来监听组件的生命周期方法。

public class MainActivityLifecycleObserver implements LifecycleObserver {

}

好吧，这是一个空接口，没有必须要实现的方法。那怎么监听Activity的生命周期呢？看代码:

public class MainActivityLifecycleObserver implements LifecycleObserver {
    private final static String TAG = "TAG_MAIN--------";

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

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

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

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

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


}

只需要定义一个个方法，用注解标记其想要监听的生命周期方法即可。我们在生命周期执行的时候打印一句Log。Activity所有的生命周期方法都能够监听到:

 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
    }

除了实现该接口，还可以实现DefaultLifecycleObserver接口，并重写其 方法，效果是一样的，只不过不需要再方法上进行注解了：

public class MainActivityLifecycleObserver implements DefaultLifecycleObserver {
    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "onCreate");
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "onStart");
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "onResume");
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "onPause");
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "onStop");
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "onDestroy");
    }
}

DefaultLifecycleObserver 默认没有，需要在gradle中引入：

 implementation "android.arch.lifecycle:common-java8:1.1.1"

推荐使用第二种方式。

2. 在Activity中获取Lifecycle(包含Activity生命周期状态信息的一个类)

Lifecycle lifecycleRegistry = getLifecycle();

3.在Activity中为包含生命周期状态信息的对象添加观察者。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //获取Lifecycle对象
        Lifecycle lifecycle = getLifecycle();

        //为Lifecycle对象注册观察者，方便别人能够观察到生命周期状态的变化。
        lifecycle.addObserver(new MainActivityLifecycleObserver());
    }

}

26.1.0之后Activity默认实现了LifecycleOwner接口，所以可以直接使用，如果想要在26.1.0之前的版本使用，需要Activtiy手动实现LifecycleOwner接口:

public class MainActivity extends AppCompatActivity implements LifecycleOwner{
    //LifecycleRegistry 实现了Lifecycle 
    private LifecycleRegistry mLifecycleRegistry=new LifecycleRegistry(MainActivity.this);
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mLifecycleRegistry.addObserver(new MainActivityLifecycleObserver());
    }

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

然后运行一下项目，看一下打印的日志:

可以看到，我们想要监听的生命周期方法都监听到了。理论上只要某一个类实现了LifecycleObserver接口，都可以去监听Activity等组件的生命周期方法。比如自定义的TextView、Button、等所有的自定义组件，只要自定义的ui组件实现了该接口，我们能就可以在该组件中取到对应的Activity或Fragment的生命周期状态。

好了，Activity的代码看起来是不是简洁了一丢丢呢~
下一篇：Android Architecture Components系列之LiveData&ViewModel