深入了解Android Jetpack架构组件 - Lifecycle

一、前言

随着Android开发模式的成熟，组件化已经成为解耦复杂Activity的一个简单实用的方式，因为通过组件化可以大大降低一个Activity的代码复杂度，并且抽离成独立组件，实现代码分离，避免造成内存泄漏和应用崩溃。

那么如何实现组件生命周期同步Activity的生命周期？下面是一个BaseComponent实现和MainActivity生命周期同步的简单实现，相信很多人第一时间都会想到这么做或者类似的实现：

这样做看起来是没有问题，但是随着组件增加，在Activity每个生命周期里面都会放置大量代码，使得Activity维护变得艰难，在这种背景下，Google官方推出了Lifecycle组件以帮助开发者更加简洁地实现组件化。

二、使用

在我们升级androidx之后，里面已经包含了lifecycle组件，如下图所示。

我们只需要使用到其中的LifecycleObserver和LifecycleOwner即可实现组件化监听Activity的生命周期，代码如下所示。

public class MainActivity extends AppCompatActivity {

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

        getLifecycle().addObserver(new BaseComponent());
    }
}


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

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

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

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

三、底层实现

如果大家只满足了解如何使用Lifecycle的层面，那么本篇文章就到此为止，下面主要是手把手带领大家了解它的底层实现，一探究竟。

在窥探源码之前，其实我们也能猜测到它的实现方式，就是利用非常常用的观察者者模式来实现，只不过它通过反射来实现注解调用。

首先我们了解一下LifeOwner和LifecycleObserver两个接口，LifeOwner的意思就是生命周期的持有者，即被观察者，对应于Activity和Fragment，LifecycleObserver就是生命周期观察者，对应于我们自定义的组件，它们都是接口，实现非常简单：

LifecycleObserver、LifecycleOwner

public interface LifecycleObserver {

}

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

Lifecycle

由于我们的Activity/Fragment是被观察者，所以在androidx里面，它们都实现了LifecycleOwner接口，所以它们要实现LifecycleOwner的接口getLifecycle()，返回一个Lifecycle实例，那么Lifecycle是什么呢？如下代码所示，它是一个抽象类，需要实现addObserver、removeObserver、getCurrentState三个抽象方法，其实非常好理解，它就是一个桥接观察者和被观察者的桥梁，负责处理两者关联的逻辑，而Lifecycle的唯一实现类就是LifecycleRegistry，我们下面再说。

public abstract class Lifecycle {
  
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

      @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    @NonNull
    public abstract State getCurrentState();

    @SuppressWarnings("WeakerAccess")
    public enum Event {

        ON_CREATE,
  
        ON_START,
     
        ON_RESUME,
      
        ON_PAUSE,
      
        ON_STOP,
      
        ON_DESTROY,
       
        ON_ANY
    }

       @SuppressWarnings("WeakerAccess")
    public enum State {
   
        DESTROYED,

        INITIALIZED,

        CREATED,

        STARTED,

        RESUMED;

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

LifecycleRegistry

作为一个桥接者，LifecycleRegistry内部维护了一个状态值mState，它是枚举类型State，即Lifecycle里面定义的State，它具有DESTROYED、INITIALIZED、CREATED、STARTED、RESUMED五个状态。

    public class LifecycleRegistry extends Lifecycle {
        /**
         * Current state
         */
        private State mState;
    }

设计者认为被观察者的生命周期就是从这五个状态循环执行，这五个状态转换过程就响应到观察者的Event的状态变化，即Lifecycle里面定义的ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY、ON_ANY，也是我们比较容易理解的状态。怎么理解State和Event之间的转换关系呢？如下图所示，例如当LifecycleRegistry从CREATED变化到STARTED时，观察者就出发了ON_START事件。

这个图在LifecycleRegistry里面的代码也得到证实：

public class LifecycleRegistry extends Lifecycle {
    static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

    private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }
    }

EVENT变化

那么什么情况下会触发Event变化，响应到观察者呢？就是handleLifecycleEvent方法，被观察者通过调用handleLifecycleEvent，从而触发Event的变化。

public class LifecycleRegistry extends Lifecycle {
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }
}

那么是哪里调用handleLifecycleEvent的呢？就是来自于一个ReportFragment的dispatch方法，在ReportFragment的每个生命周期方法都会触发dispatch方法的调用，从而触发LifecycleRegistry的handleLifecycleEvent方法。

public class ReportFragment extends Fragment {
  
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatch(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
    }

    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

相信你一定知道，这个ReportFragment肯定被Activity持有，没错，就是ComponentActivity会在创建的时候创建一个ReportFragment：

public class ComponentActivity extends Activity
        implements LifecycleOwner, KeyEventDispatcher.Component {
   
    @Override
    @SuppressWarnings("RestrictedApi")
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }
}

而我们开发者使用的AppCompatActivity就是通过继承ComponentActivity实现的：

AppCompatActivity -> FragmentActivity -> ComponentActivity -> Activity

四、总结

我们自定义的组件需要实现LifecycleObserver作为观察者，Activity/Fragment作为被观察者，它需要实现LifecycleOwner接口，并且需要实现一个Lifecycle子类LifecycleRegistry作为桥接观察者和被观察者的桥梁，并且在Activity里面实现了一个无界面的ReportFragment（生命周期与Activity同步）触发LifecycleRegistry里面的Event变化，从而通知到被观察者相应事件。