Jetpack组件之LiveData实现原理
2021-03-10 本文已影响0人
Guxxxd
提纲
- LiveData是什么
- LiveData衍生类及其基本用法
- LiveData核心方法介绍
- LiveData实现消息分发实现原理及相关方法
- LiveData的优势
一、LiveData是什么
LiveData 组件是 Jetpack 推出的基于观察者的消息订阅/分发组件，具有宿主（Activity、Fragment）生命周期感知能力，这种感知能力可确保 LiveData 仅分发消息给处于活跃状态的观察者，即只有处于活跃状态的观察者才能收到消息。
活跃状态：通常情况下等于 Observer 所在宿主处于 STRATED，RESUMED 状态，如果使用
observeForever()注册的，则一直处于活跃状态。
二、LiveData衍生类及其基本用法
2.1 MutableLiveData
使用 LiveData 的做消息分发的时候，需要使用这个子类。之所以这么设计是考虑到单一开闭原则，只有MutableLiveData 对象可以发送消息，LiveData 对象只能接收消息。
@SuppressWarnings("WeakerAccess")
public class MutableLiveData<T> extends LiveData<T> {
@Override
public void postValue(T value) {
super.postValue(value);
// LiveData.postValue()->ArchTaskExecutor.postToMainThread()->DefaultTaskExecutor.postToMainThread()->mMainHandler.post() 将数据发送到主线程处理
}
@Override
public void setValue(T value) {
super.setValue(value);
}
}
val liveData = MutableLiveData<Int>()
liveData.observe(this, Observer {
// TODO: do something
})
mediatorLiveData.value = 1
2.2 MediatorLiveData
可以统一观察多个 LiveData 发射的数据进行统一的处理，同时也可以做为一个 LiveData，被其他 Observer 观察。
val liveData1 = MutableLiveData<Int>()
val liveData2 = MutableLiveData<Int>()
val mediatorLiveData = MediatorLiveData<Int>()
val observer = Observer<Int> {
// TODO: do something
}
// 1.观察多个 LiveData 发射的数据进行统一的处理
mediatorLiveData.addSource(liveData1,observer)
mediatorLiveData.addSource(liveData2,observer)
liveData1.value = 1
liveData2.value = 2
// 2.做为一个 LiveData，被其他 Observer 观察
mediatorLiveData.observe(this, Observer {
// TODO: do something
})
mediatorLiveData.value = 1
三、LiveData核心方法介绍
| 方法名 | 介绍 |
|---|---|
| observe(LifecycleOwner owner,Observer observer) | 注册和宿主生命周期关联的观察者 |
| observeForever(Observer observer) | 注册观察者,不会反注册,需自行维护 |
| setValue(T data) | 发送数据,没有活跃的观察者时不分发，只能在主线程调用！！ |
| postValue(T data) | 发送数据,没有活跃的观察者时不分发，不受线程环境影响 |
| onActive() | 当且仅当有一个活跃的观察者时会触发 |
| onInactive() | 不存在活跃的观察者时会触发 |
四、LiveData实现消息分发实现原理及相关方法
图4.1 LiveData实现消息分发流程图
4.1 分发流程相关方法分析
4.1.1 void observe(LifecycleOwner owner,Observer observer)
- 向LiveData注册观察者——用于消息分发
- 向Lifycycle注册观察者——用于感知宿主生命周期
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
// 保证当前宿主的状态为非DESTROYED
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 将Observer包装成LifecycleBoundObserver
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 向LiveData注册观察者
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;
}
// 向Lifecycle注册观察者
owner.getLifecycle().addObserver(wrapper);
}
// 绑定生命周期的观察者
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@NonNull
final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
@Override
boolean shouldBeActive() {
// 当前宿主的状态是否为活跃状态，即STARTED，RESUMED
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
// 宿主生命周期改变回调的方法
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
// 宿主为DESTROYED状态，移除观察者，即反注册
removeObserver(mObserver);
return;
}
// 活跃状态改变
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
4.1.2 void activeStateChanged(boolean newActive)活跃状态改变，回调对应方法
void activeStateChanged(boolean newActive) {
// 1.屏蔽初始化时非活跃状态的分发
// 2.屏蔽相同活跃状态重复分发
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
boolean wasInactive = LiveData.this.mActiveCount == 0;
LiveData.this.mActiveCount += mActive ? 1 : -1;
// 当且仅当有一个活跃的观察者时会触发
if (wasInactive && mActive) {
onActive();
}
// 不存在活跃的观察者时会触发
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive();
}
// 当前宿主为活跃状态时分发
if (mActive) {
dispatchingValue(this);
}
}
4.1.3 void dispatchingValue(@Nullable ObserverWrapper initiator) 分发，阻断(maybe)，再分发，精准分发，全部分发
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
// 循环的原因， 结束当前分发，重新再分发
// 当正在分发第一次数据时，此时 mDispatchingValue=true mDispatchInvalidated=false
// 这是第二次分发走到当前方法时，mDispatchInvalidated会被置为true，break结束for循环，do while继续执行
do {
mDispatchInvalidated = false;
if (initiator != null) { // 不为null，精准分发
considerNotify(initiator);
initiator = null;
} else { // 为null
// 遍历，向所有观察者分发数据
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
4.1.4 void considerNotify(ObserverWrapper observer)分发最终方法and黏性事件的产生
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;
}
// 黏性消息的始发地，即先发送消息，再注册观察者也会收到此消息（发送的最后一条消息）
// mLastVersion和mVersion的初始值均为-1
// 当发送消息时，mVersion++ = 0
// 再注册观察者时-1 < 0 , 则向observer分发
if (observer.mLastVersion >= mVersion) {
return;
}
// 对齐
observer.mLastVersion = mVersion;
//noinspection unchecked
// 事件分发到此结束
observer.mObserver.onChanged((T) mData);
}
五、LiveData的优势
摘自慕课网
-
确保界面符合数据状态
LiveData遵循观察者模式。当生命周期状态发生变化时，LiveData会根据宿主状态和注册类型通知 [Observer]对象并把最新数据派发给它。观察者可以在收到onChanged事件时更新界面，而不是在每次数据发生更改时立即更新界面。 -
不再需要手动处理生命周期
只需要观察相关数据，不用手动停止或恢复观察。LiveData会自动管理Observer的反注册，因为它能感知宿主生命周期的变化，并在宿主生命周期的onDestory自动进行反注册。因此使用LiveData做消息分发不会发生内存泄漏 -
数据始终保持最新状态
如果宿主的生命周期变为非活跃状态，它会在再次变为活跃状态时接收最新的数据。例如，在后台的Activity会在返回前台后立即接收最新的数据。 -
支持黏性事件的分发
即先发送一条数据，后注册一个观察者，默认是能够收到最后发送的那条数据 -
共享资源
可以使用单例模式拓展LiveData，实现全局的消息分发总线。
