1、概述
google的jetpack已经出来很久了，最近项目中用接入后，也是遇到了不少坑。于是抽时间好好研究了下lifecycle、livedata、viewModel等源码，本文就来介绍一下lifecycle的用法及原理。
2、设计初衷
先来一句官方解释：android.arch.lifecycle 包提供了可以用于构建生命周期感知（lifecycle-aware）组件的类和接口，这些组件可以根据 Activity 或 Fragment 的当前生命周期自动调整其行为。
我的理解就是你可以用lifecycle使任何一个类具有生命周期。这个生命周期会跟随activity或fragment的生命周期。（其实并不一定要activity，只要实现lifecycleOwner既可，这个后面再说）
掏出一个官方的例子：
class MyLocationListener {
public MyLocationListener(Context context, Callback callback) {
// ...
}
void start() {
// 链接到系统定位服务
}
void stop() {
// 断开系统定位服务
}
}
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
public void onCreate(...) {
myLocationListener = new MyLocationListener(this, (location) -> {
// 更新 UI
});
}
public void onStart() {
super.onStart();
myLocationListener.start();
}
public void onStop() {
super.onStop();
myLocationListener.stop();
}
}
我们以前代码里常常出现类似这样的场景，看似没啥毛病，但很多这样的Listener会导致onstop之类的生命周期看起来臃肿，而且自己写起来也麻烦，于是lifecycle孕育而生。
3、基本使用
使用的话，总结为一句话：需要一个LifecycleOwner，和一个LifecycleObserver，然后观察起来就好了，这样LifecycleObserver就会跟随LifecycleOwner的生命周期了。所以上面的例子里MyActivity就是LifecycleOwner，MyLocationListener就是LifecycleObserver。用代码来表示就像这样：
class MyLocationListener implements LifecycleObserver {
public MyLocationListener(Context context, Callback callback) {
// ...
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void start() {
// 链接到系统定位服务
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
void stop() {
// 断开系统定位服务
}
}
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
myLocationListener = new MyLocationListener(this, (location) -> {
// 更新 UI
});
getLifecycle().addObserver(myLocationListener);
}
@Override
protected void onDestroy() {
super.onDestroy();
getLifecycle().removeObserver(myLocationListener);
}
}
其中AppCompatActivity已经实现了LifecycleOwner，无需我们自己操作。就像我上面说的一样，重点在于这一句：getLifecycle().addObserver(myLocationListener);
而实现LifecycleObserver的需要将自己的生命周期方法加上注释@OnLifecycleEvent。用法很简单，大致就是这样。这个方式主要用于你希望赋予某个类生命周期。比如MVP模式的presenter、MVVM模式的ViewModel，拥有生命周期后就可以在其中做一些释放内存之类的操作。
4、原理解析
注意是原理，而不是源码，受到某些影响，现在不喜欢大段大段贴源码的方式写作，感觉不仅难以理解还无法理解其思想。
lifecycle很明显是基于观察者模式，被观察者为LifecycleOwner，他只有一个方法：getLifecycle(); 具体实现，我们就挑google现成的例子：fragment。
fragment关于lifecycle的代码抽出来很简单：
public class Fragment implements xxx, LifecycleOwner {
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
//...
void performCreate(Bundle savedInstanceState) {
onCreate(savedInstanceState);
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
onStart();
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
onResume();
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
onPause();
}
void performStop() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
onStop();
}
void performDestroy() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
onDestroy();
}
}
很明显，真正作为lifecycle的是LifecycleRegistry，fragment仅仅是将生命周期进行分发。而LifecycleRegistry确实是实现了Lifecycle，看看Lifecycle的设计：
public abstract class Lifecycle {
public abstract void addObserver(@NonNull LifecycleObserver observer);
public abstract void removeObserver(@NonNull LifecycleObserver observer);
public abstract State getCurrentState();
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
看起来也非常简洁，添加观察者、移除观察者、当前状态，以及event和state的设计。LifecycleRegistry实现了该接口，完成了观察者具体实现，这里就不详细解析了，可以自行学习源码。简单来说就是通过添加观察者，当生命周期改变时调用handleLifecycleEvent方法通知LifecycleObserver，并调用相关方法。
LifecycleObserver
接下来聊聊这个LifecycleObserver，google提供的实现方案有两种，在lifecycle类的注释上写的很清楚，
其一是和我们上面的实现方案：实现LifecycleObserver接口，在相关生命周期方法上加上OnLifecycleEvent注释，这种方案适用于JAVA7及以下，会根据注释利用APT编译期自动生成GeneratedAdapter实现类，只有一个方法callMethods，当生命周期改变时会回调该方法，并在该方法内回调我们注释过的相应的生命周期。底层还是利用GenericLifecycleObserver来实现的，这个我们后面再解析。
其二是实现DefaultLifecycleObserver，里面有相关的生命周期方法。适用于JAVA8以上，google推荐使用该类方案，因为当JAVA8成为Android主流后可能第一种方案就会被遗弃。
无论传入的是哪一种Observer，都会被包装成对应的Observer，关键代码在LifecycleRegistry的内部包装类ObserverWithState中
static class ObserverWithState {
State mState;
GenericLifecycleObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//这里包装observer
mLifecycleObserver = Lifecycling.getCallback(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
//包装成GenericLifecycleObserver，生命周期改变时调用
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
}
我们来看看Lifecycling.getCallback(observer)是如何包装的：
@NonNull
static GenericLifecycleObserver getCallback(Object object) {
//第二种方案走这里，DefaultLifecycleObserver继承于FullLifecycleObserver
if (object instanceof FullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
}
//livedata的生命周期走这里，后面详解
if (object instanceof GenericLifecycleObserver) {
return (GenericLifecycleObserver) object;
}
//第一种方案走这里，通过apt方式生成的adapter类
final Class<?> klass = object.getClass();
int type = getObserverConstructorType(klass);
if (type == GENERATED_CALLBACK) {
List<Constructor<? extends GeneratedAdapter>> constructors =
sClassToAdapters.get(klass);
if (constructors.size() == 1) {
GeneratedAdapter generatedAdapter = createGeneratedAdapter(
constructors.get(0), object);
return new SingleGeneratedAdapterObserver(generatedAdapter);
}
GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
for (int i = 0; i < constructors.size(); i++) {
adapters[i] = createGeneratedAdapter(constructors.get(i), object);
}
return new CompositeGeneratedAdaptersObserver(adapters);
}
return new ReflectiveGenericLifecycleObserver(object);
}
无论是哪一种方案，哪一种observer，都会去实现onStateChanged方法，我们拿第二种方案为例，看看FullLifecycleObserverAdapter中的实现：
class FullLifecycleObserverAdapter implements GenericLifecycleObserver {
private final FullLifecycleObserver mObserver;
FullLifecycleObserverAdapter(FullLifecycleObserver observer) {
mObserver = observer;
}
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
switch (event) {
case ON_CREATE:
mObserver.onCreate(source);
break;
case ON_START:
mObserver.onStart(source);
break;
case ON_RESUME:
mObserver.onResume(source);
break;
case ON_PAUSE:
mObserver.onPause(source);
break;
case ON_STOP:
mObserver.onStop(source);
break;
case ON_DESTROY:
mObserver.onDestroy(source);
break;
case ON_ANY:
throw new IllegalArgumentException("ON_ANY must not been send by anybody");
}
}
}
很明显，当onStateChanged被调用时，根据event回调我们实现的DefaultLifecycleObserver里的各种生命周期方法。其他方案类似，就不一一列出了。
理一下思路：
1、在LifecycleOwner中加入各种类型的observer观察者，LifecycleOwner真正实现是LifecycleRegistry。
2、在LifecycleRegistry中利用Lifecycling包装observer为GenericLifecycleObserver
3、调用GenericLifecycleObserver的onStateChanged方法进行event分发，这里有策略模式的影子
5、自定义LifecycleOwner
根据上一节原理以及google对fragment的实现，自定义LifecycleOwner就很简单了。总结为两句话：1、生成一个LifecycleRegistry。2、分发生命周期事件
加入我们要把dialog变成LifecycleOwner，就像这样：
public class baseDialog extends Dialog implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Bundle onSaveInstanceState() {
mLifecycleRegistry.markState(Lifecycle.State.CREATED);
return super.onSaveInstanceState();
}
//...省略了其他生命周期
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
@Override
protected void onStop() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
super.onStop();
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
6、LiveData的生命周期管理
LiveData是jetpack另外一个重要的组件，用于监听数据变更，UI做出相应响应，这里就不详细介绍了，他也是基于观察者模式，自然需要解绑避免内存泄漏。但他内部已经处理好生命周期，我们只管使用无须担心。自然，他就是用lifecycle来实现的。
我们前面提到lifecycle是赋予某个类生命周期才出现的，LiveData虽然无需那么多生命周期，但是可以利用他在LifecycleOwner（Activity...）ondestroy时同步解绑，就完成了LiveData的自动释放。
LiveData自己实现了observer：LifecycleBoundObserver，然后在onStateChanged方法里判断是否需要解绑即可。
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
//判断如果状态是DESTROYED就解绑
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
LiveData的源码也很简单，只有不到500行代码，还有不少一部分是注释，感兴趣可以自行阅读。
