JetPack | LiveData 如何安全的观察数据
Posted 涂程
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JetPack | LiveData 如何安全的观察数据相关的知识，希望对你有一定的参考价值。
好文推荐：
作者：JakePrim
LiveData 是什么？LiveData是JetPack组件之一，LiveData是一个可观察的数据持有类，可以感知生命周期。 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。（来自android官方解释）
LiveData的介绍和使用不在累述，直接看官方文档，本篇文章旨在讲解LiveData存在的意义以及实现的原理。 LiveData 为什么会出现？
LiveData 它被设计为仅限于负责 数据在订阅者生命周期内的被分发，除了 setValue / postValue 发送数据，以及 observe订阅数据. 没有多余的方法。
LiveData 只有如下简单的几个类：
LiveData 其实就是为了解决数据分发、统一数据分发一致性、数据在订阅者生命周期内分发感知生命周期。 Google的描述的LiveData的优势如下：
下面我们来一一验证，LiveData的优势。
postValue/setValue
在LiveData只存在两个方法postValue/setValue来进行数据的分发，那么这两个方法有什么区别呢？
postValue: 可以在任意的线程下执行。setValue: 只能在主线程下执行。
//<T> 决定livedata 持有的数据类型
liveData = MutableLiveData<String>()
//设置持有的数据
//postValue 可以在任意的线程下执行
liveData.postValue("1")
thread {
liveData.postValue("3")
}
//setValue 只能在主线程执行
liveData.value = "2"
LiveData中源码的实现如下：实现的方式非常简单，最终都会调用到setValue最终存储在mData
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;//NOT_SET 是一个空对象
mPendingData = value;//存储发送的数据
}
if (!postTask) {//如果mPendingData 不等于 NOT_SET 说明mPostValueRunnable还没有执行完毕
return;
}
//主线程执行mPostValueRunnable
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
//主线程执行Runnable
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;//将mPendingData置为空对象 对应了上述的postTask
}
setValue((T) newValue);//最终还是调用了setValue()方法
}
};
@MainThread //注解 标注了在主线程执行
protected void setValue(T value) {
assertMainThread("setValue"); // 判断是否在主线程
mVersion++;//版本号 后续会用到
mData = value;//mData 真实的数据
dispatchingValue(null);//将数据分发给观察者
}
发布/订阅数据
从上述的postValue/setValue 的方法，我们可以看到最终都会调用到
setValue并且调用了dispatchingValue进行发布数据。
LiveData中订阅数据,通过observe方法实现订阅数据：
//注册订阅者
//LifecycleOwner AppCompatActivity进行了实现
liveData.observe(this, {
Log.e("liveData-1", "onCreate: $it")
})
我们先来看分发数据dispatchingValue是如何实现的：(先关注分发数据的代码)
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {//TODO 这里先不要关注 后面会讲解
considerNotify(initiator);
initiator = null;
} else {
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {//TODO 关注这里 遍历观察者
considerNotify(iterator.next().getValue());//TODO 通知观察者有数据过来了
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
private void considerNotify(ObserverWrapper observer) {
//其他代码先不要关注
....
observer.mObserver.onChanged((T) mData);//将数据通知观察者 将mData传递过去
}
如下图所示：最终setValue 通过considerNotify将数据通知给订阅者。
下面再来看LiveData如何通过observe订阅数据：
@MainThread //看这里这里标注了 observe必须在主线程中调用
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");//判断是否在主线程中
//感知生命周期 先忽略后面讲解
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
//感知生命周期 先忽略后面讲解
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
//TODO 这里将observer存储在mObservers中。这里mObservers，通过dispatchingValue调用分发数据
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
owner.getLifecycle().addObserver(wrapper);
}
注意：observer 必须在主线程中调用。
那么整体下来，LiveData分发数据和订阅数据的流程图如下：
从上述的分析来看，LiveData实现看起来挺简单的，只是简单的遍历分发数据。如果仅仅是这样LiveData是没有必要存在的，也没有体现Google提出来的优势，下面我们来看LiveData的最核心的部分，也是优势所在：生命周期管理以及规避内存泄漏。
生命周期管理
在JetPack组件通过Lifecycle来管理生命周期，关于Lifecycle我会单独出一篇文章讲解。 关于Lifecycle先看AppCompatActivity实现了LifecycleOwner.可以获取getLifecycle,通过getLifecycle.addObserver()来注册生命周期的观察者
如下代码：MyLifeCycle实现了LifecycleEventObserver，生命周期的观察者
class MyLifeCycle : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
Log.e("TAG", "onStateChanged: " + source.lifecycle.currentState+" event:"+event)
}
}
在Activity中注册观察者：
//感知Activity的生命周期 注册生命周期的观察者
lifecycle.addObserver(MyLifeCycle())
那么LiveData是如何感知生命周期的呢？如下代码：其实和上述的原理是一样的
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");//判断是否在主线程中
//获取当前生命周期的状态如果destory状态直接返回
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
//LifecycleBoundObserver 实现了LifecycleEventObserver
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
//判断owner是否是同一个
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
//注册生命周期的观察者 owner: Activity/Fragment
owner.getLifecycle().addObserver(wrapper);
}
那么生命周期感知的关键就是LifecycleBoundObserver类的实现：
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@NonNull
final LifecycleOwner mOwner;
//构造方法存储LifecycleOwner和Observer
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
//判断生命周期是否处于活跃状态
@Override
boolean shouldBeActive() {
//判断是否处于活跃状态 isAtLeast进行状态比较：compareTo(state) >= 0; 处于STARTED RESUMED
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
// onStateChanged感知生命周期
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
//获取当前生命周期的状态
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
//感知到生命周期状态destory移除
if (currentState == DESTROYED) {
removeObserver(mObserver);//从mObservers中移除mObserver 返回
return;
}
//感知到处于非destory状态
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
//判断是否处于生命周期活跃状态
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
//判断是否为同一个LifecycleOwner
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
//移除该生命周期的观察者
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
移除观察者：
@MainThread
public void removeObserver(@NonNull final Observer<? super T> observer) {
assertMainThread("removeObserver");
//移除数据的观察者
ObserverWrapper removed = mObservers.remove(observer);
if (removed == null) {
return;
}
//注销该生命周期的观察者
removed.detachObserver();
//重置状态
removed.activeStateChanged(false);
}
从上述代码中，可以看到，LifecycleBoundObserver类作为生命周期的观察者，主要有两个方法：
shouldBeActive判断是否处于活跃状态也就是处于：STARTED RESUMED状态。onStateChanged感知生命周期，如果感知到处于destory状态，则执行removeObserver(也标注了MainThread也就说必须在主线程中执行)移除数据的观察者以及生命周期的观察者。其他的状态通过activeStateChanged父类的方法处理。
LiveData 有两种观察者：一种是Observer数据的观察者，一种是LifecycleBoundObserver生命周期的观察者。
activeStateChanged的实现在ObserverWrapper父类中：
private abstract class ObserverWrapper {
final Observer<? super T> mObserver;//存储Observer
boolean mActive;//记录是否处于活跃状态 默认FALSE
int mLastVersion = START_VERSION;//最新版本 后续会用到
ObserverWrapper(Observer<? super T> observer) {
mObserver = observer;
}
//子类LifecycleBoundObserver
abstract boolean shouldBeActive();
//默认返回 FALSE 在子类中已经实现 LifecycleBoundObserver
boolean isAttachedTo(LifecycleOwner owner) {
return false;
}
//在子类中已经实现 LifecycleBoundObserver
void detachObserver() {
}
//活跃状态变更逻辑
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
if (mActive) {
//处于活跃状态 STARTED RESUMED 调用dispatchingValue分发数据
dispatchingValue(this);
}
}
}
在上述代码中，activeStateChanged最终判断mActive如果为TRUE 也就是活跃状态，则调用dispatchingValue并且传递了ObserverWrapper，分发数据。我们来验证一下生命周期感知,如下代码：5秒之后在发送数据，我们在5秒之内App进入后台，在进入前台，看是否能观察到数据。
理论的状态下是，App进入后台会进入STOPED状态，不会通知数据观察者，当App进入前台进入RESUMED状态，会通知观察者
//注册观察者
//LifecycleOwner AppCompatActivity进行了实现
liveData.observe(this, {
Log.e("liveData-1", "onCreate: $it")
})
liveData.observe(this, {
Log.e("liveData-2", "onCreate: $it")
})
//延时执行 app进入后台 10S在进入前台 查看数据
Handler(Looper.getMainLooper()).postDelayed({
liveData.postValue("lifecyle")
}, 5000)
结果如下：注册了多个观察者都会在STARTED状态就收到了数据
注意：liveData.observe(…) 每调用一次observe，都会生成一个LifecycleBoundObserver对象，注册生命周期观察者，感知生命周期的变化。
之前看过dispatchingValue 在调用setValue和postValue传递参数都是null，而生命周期感知中传递了ObserverWrapper，来看看有什么不同。
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator);//通知数据观察者
initiator = null;
} else {
//..... setvalue/postvalue 逻辑上述讲过了
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
private void considerNotify(ObserverWrapper observer) {
//如果没有处于活跃状态 则直接return
if (!observer.mActive) {
return;
}
//再一次判断是否处于活跃状态
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
//observer的版本和setValue的版本如果相等或者大于 则返回
if (observer.mLastVersion >= mVersion) {
return;
}
//统一版本号，版本号的作用在文章的后面
observer.mLastVersion = mVersion;
//通知观察者
observer.mObserver.onChanged((T) mData);
}
整体的流程图如下：
粘性事件
通过上述的分析，了解了LiveData的具体的实现，目前还存在一个问题，在网上大部分文章都说LiveData支持粘性事件，那么什么是粘性事件呢?
思考：在下面代码中，先调用postValue在调用观察者，观察数据能监听到数据吗？
liveData.postValue("11111")
//粘性事件 liveData同理 注册生命周期的观察者
liveData.observe(this, {
Log.e("liveData-3", "onCreate: $it")
})
答案是可以的，为什么呢？来看下面的一段代码，通过一个按钮来注册生命周期的观察者，来看会打印什么？
fun setViscous(view: View) {
//再次注册 生命周期的观察者 会打印当前的生命周期状态
lifecycle.addObserver(MyLifeCycle())
//粘性事件 liveData同理 注册生命周期的观察者
liveData.observe(this, {
Log.e("liveData-3", "onCreate: $it")
})
}
看结果：原来如此，再次注册生命周期的观察者，会调用onStateChanged,那么在LiveData的原理是一样的啊，当注册数据观察者，同事也会注册生命周期的观察者，在LifecycleBoundObserver中感知生命周期的变化，调用了activeStateChanged，处于活跃状态，将最新的mData数据会返回给观察者。
LiveData中版本号的作用
在LiveData中持有一个mVersion版本号，在ObserverWrapper中持有一个mLastVersion的版本号，这两个版本号到底有什么作用呢？ 对于mVersion的变化是当调用setValue的时候才会+1
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
对于mLastVersion 的变化,在调用considerNotify去通知数据观察者的时候才会发生改变。
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
//也就是说当mLastVersion==mVersion的时候不会在通知观察者
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
也就是说当mLastVersion>=mVersion的时候不会在通知订阅者,可以这样理解，当setValue发生改变的时候mVersion > mLastVersion才会通知观察者。确保了只有setValue底层数据发生改变，LiveData才会通知订阅者。很有意思的设计，看源码果然可以学到很多优秀的思想
以上是关于JetPack | LiveData 如何安全的观察数据的主要内容，如果未能解决你的问题，请参考以下文章
Android Jetpack架构组件——LiveData原理篇
Android Jetpack架构组件——LiveData原理篇