Android_Banner.jpg
简介
- 之前的文章有介绍过LiveData的基本使用，这篇文章主要来讲解一下LiveData的工作原理
- 在我们使用LiveData的时候，会在组件中注册一个观察者来监听我们LiveData数据源的变化，调用了observe()方法！
- 当我们去改变LiveData的数据源的时候我们在UI线程中一般使用的是setValue(),而在非UI线程中我们必须使用postValue()
- 那么综上所述，我们就从如下三个点去看下LiveData的工作流程
- LiveData # observe()方法
- setValue()
- postValue()
源码解析
obseve()
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
//必须运行在主线程中
assertMainThread("observe");
//如果当前组件的状态是DESTROYED就不做任何操作（其实就是不添加这个观察者）
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 将owner和observer传入到LifecycleBoundObserver构建了一个LifecycleBoundObserver对象
// LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver
// LifecycleEventObserver extends LifecycleObserver
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 注释1
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;
}
//注释2
owner.getLifecycle().addObserver(wrapper);
}
- 注释1处：mObservers ----> SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
new SafeIterableMap<>();
- mObservers的putIfAbsent(�)和map的put方法还不一样，如果根据key获取的value不为null，就将当前的value返回，如果为null，就将当前的键值对存储起来，然后返回一个null
- 注释2处：如果注释1返回的值为null ，就会走到注释2处，添加观察者来观察生命周期拥有者的生命周期也就是我们的Activity或者Fragment的，在Lifecycle分析中我们知道 组件的生命周期发生变化的时候会回调Observer#onStateChanged()方法，看下LifecycleBoundObserver的onStateChanged
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
// 当组件的生命周期状态变成DESTROYED
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
// 就将当前添加的观察者移除，这也是为什么处于不可见状态的组件中的观察者收不到 LiveData数据源变换的回调
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
setValue()
@MainThread
protected void setValue(T value) {
//检查是否运行在祝线程中
assertMainThread("setValue");
//版本自增1
mVersion++;
//将当前的value赋值给mData
mData = value;
// 调用了dispatchingValue的方法 传入了null值
dispatchingValue(null);
}
void dispatchingValue(@Nullable ObserverWrapper initiator) {
// 当前正在处于分发数据中
if (mDispatchingValue) {
mDispatchInvalidated = true;
//继续之前的分发数据
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
//注释1
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
//注释2
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
- 在注释1和注释2中，都会调用到considerNotify()方法，区别在于
- 注释1: initiator不为null，并且只调用一次considerNotify()
- 注释2：initiator为null，会遍历mObservers中存储的Observer，然后调用considerNotify(拿到对应的值，传给considerNotify，这个值对应着ObserverWrapper)
private void considerNotify(ObserverWrapper observer) {
// 如果当前的组件不是处于活跃状态，就停止运行
if (!observer.mActive) {
return;
}
// Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
//
// we still first check observer.active to keep it as the entrance for events. So even if
// the observer moved to an active state, if we've not received that event, we better not
// notify for a more predictable notification order.
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
// 注释1
observer.mObserver.onChanged((T) mData);
}
- 在注释1处：如果当前的组件处于活跃状态，之前的条件都满足了，就会拿到添加的观察者，并且回调它的onChanged方法。onChanged方法就是我们监听到数据源发生改变做的处理逻辑了。
postValue()
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
//从工作线程切换到UI线程，同样通过创建一个Handler关联到祝线程的Looper，调用了post方法，提交一个Runnable，切换到祝线程去执行run方法中的逻辑
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
// postValue()最终还是调用了setValue()方法
setValue((T) newValue);
}
};
总结
- LiveData内部是依靠Lifecycle来感知组件的生命周期，从而避免内部泄漏的。
- 当观察到组件处于不可见状态的时候，会移除当前观察者的监听
- 当处于活跃状态的时候，当LiveData的数据源发生变化的会监听到数据变化拿到数据，去更新UI
- 对于set和post这两种更新数据源，其实最终post还是调用了set，只不过在中间用到了Handler关联到了主线程中的Looper，调用了post切换到主线程中。
网友评论