本文是深入理解「Android Architecture Components」系列文章第三篇 源码基于 android.arch.lifecycle:livedata-core:1.1.1
系列前两篇: juejin.im/post/5cd4ea… juejin.im/post/5cd816…
在之前我们深入研究了 Lifecycle 的实现原理,并在文末提到了LiveData 以及 ViewModel,这次我们来讲讲 LiveData。
LiveData 是 Android Architecture Components 中的一员,先看下官方是如何介绍的:
LiveDatais an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers that are in an active lifecycle state. [见 9.1]
This class is designed to hold individual data fields ofViewModel, but can also be used for sharing data between different modules in your application in a decoupled fashion. [见 9.2]
简单讲 LiveData 是一个能够感知生命周期、可观察的数据持有类
,它被设计成 ViewModel 的一个成员变量;可以以一个 更解耦
的方式来 共享数据 。
实际使用下来发现 LiveData 有几个 特性 :
Active
状态(STARTED/RESUMED)下通知数据改变; 那么 LiveData 上述特性的 原理 是怎么样的呢?
使用 LiveData 又需要注意些什么呢?
本文将围绕此展开。
虽然 LiveData 通常跟 ViewModel 配合使用,不过也可以单独使用,为了简单起见,这里不配合 ViewModel。
以下是一个简单的例子:
MutableLiveData<String> liveString = new MutableLiveData<>(); liveString.observe(this, new Observer<String>() { @Override public void onChanged(@Nullable final String s) { Log.d(TAG, "onChanged() called with: s = [" + s + "]"); } }); liveString.postValue("程序亦非猿"); 复制代码
运行后可以看到日志输出: onChanged() called with: s = [程序亦非猿]
。
释义:
定义一个 MutableLiveData (LiveData 的一个常用子类),通过 observe 方法可以订阅修改数据的通知,通过 postValue()
或者 setValue()
方法可以更新数据,已经订阅的 Observer 能够得到数据更改的通知,也即回调 onChanged()
方法。
这样就算是用上 LiveData 了。
接下来,上干货!
在分析原理前,再明确一下我们的疑问:
同时提前看下我整理的 LiveData UML 图,对 LiveData 有个整体的了解,后续的涉及到的类都在这里了,有助于理解。
(图1.LiveData 类图)
OK, here we go!
LiveData 的使用流程从 observe()
开始,咱们尝试从 observe()
方法 开始分析:
@MainThread public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) { //如果是 DESTROYED 的状态则忽略 if (owner.getLifecycle().getCurrentState() == DESTROYED) { // ignore return; } //把 Observer 用 LifecycleBoundObserver 包装起来 LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer); //缓存起来 ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper); //如果已经 observe 过 并且两次的 owner 不同则报错 if (existing != null && !existing.isAttachedTo(owner)) { throw new IllegalArgumentException("Cannot add the same observer" + " with different lifecycles"); } if (existing != null) { return; } //绑定 owner owner.getLifecycle().addObserver(wrapper); } 复制代码
可以看到 observe 方法里把我们传递的 observer 用 LifecycleBoundObserver
包装了起来,并且存入了 mObservers
,并且跟 owner 进行了关联。
并且做了两个特殊处理:
这里出现了几个新的类 LifecycleBoundObserver 、 ObserverWrapper 来看看。
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver { @NonNull final LifecycleOwner mOwner; LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) { super(observer); mOwner = owner; } @Override boolean shouldBeActive() { // 判断 owner 当前的状态是否是至少 STARTED return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED); } @Override public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) { //生命周期改变,如果是 DESTROYED 就自动解除 if (mOwner.getLifecycle().getCurrentState() == DESTROYED) { removeObserver(mObserver); return; } //ObserverWrapper.activeStateChanged activeStateChanged(shouldBeActive()); } @Override boolean isAttachedTo(LifecycleOwner owner) { return mOwner == owner; } @Override void detachObserver() { mOwner.getLifecycle().removeObserver(this); } } 复制代码
**ObserverWrapper **:
private abstract class ObserverWrapper { final Observer<T> mObserver; boolean mActive; int mLastVersion = START_VERSION; ObserverWrapper(Observer<T> observer) { mObserver = observer; } //是否是 active 状态 abstract boolean shouldBeActive(); boolean isAttachedTo(LifecycleOwner owner) { return false; } 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; boolean wasInactive = LiveData.this.mActiveCount == 0; LiveData.this.mActiveCount += mActive ? 1 : -1; if (wasInactive && mActive) { onActive(); } if (LiveData.this.mActiveCount == 0 && !mActive) { onInactive(); } //如果 active 状态下,则发送数据更新通知 if (mActive) { dispatchingValue(this); } } } 复制代码
仔细看下这两个类其实就能解答疑问了。
到这里 【2.1】、【2.3】的问题已经有了答案:
【2.1】答:LifeData 在 observe 方法中用 LifecycleBoundObserver 包装了 observer ,并且通过它绑定了owner。
【2.3】答:LifecycleBoundObserver 在 onStateChanged() 方法里处理了生命周期改变的事件,当接收到 DESTROYED 的事件会自动解除跟 owner 的绑定。
此时的流程是:
observe-->
onStateChanged-->
activeStateChanged-->
dispatchingValue-->
considerNotify-->
onChanged
可以称之为 生命周期改变触发的流程,另外还有一种流程是 postValue&setValue 触发的流程,共两种。
在 activeStateChanged() 方法里,处理了 onActive() 跟 onInactive() 回调的相关逻辑处理,并且调用了dispatchingValue(this) 。(MediatorLiveData 用到了 onActive() 跟 onInactive() 有兴趣自行了解,这里不展开)
接下去探索 dispatchingValue
。
private void dispatchingValue(@Nullable ObserverWrapper initiator) { //如果正在分发则直接返回 if (mDispatchingValue) { //标记分发失效 mDispatchInvalidated = true; return; } //标记分发开始 mDispatchingValue = true; do { mDispatchInvalidated = false; //生命周期改变调用的方法 initiator 不为 null if (initiator != null) { considerNotify(initiator); initiator = null; } else { //postValue/setValue 方法调用 传递的 initiator 为 null for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator = mObservers.iteratorWithAdditions(); iterator.hasNext(); ) { considerNotify(iterator.next().getValue()); if (mDispatchInvalidated) { break; } } } } while (mDispatchInvalidated); //标记分发结束 mDispatchingValue = false; } 复制代码
considerNotify(ObserverWrapper)
方法:
private void considerNotify(ObserverWrapper observer) { //检查状态 确保不会分发给 inactive 的 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; } //setValue 会增加 version ,初始 version 为-1 if (observer.mLastVersion >= mVersion) { return; } observer.mLastVersion = mVersion; //noinspection unchecked observer.mObserver.onChanged((T) mData); } 复制代码
可以看到 dispatchingValue 正是分发事件逻辑的处理方法,而 considerNotify 方法则确保了 只将最新的数据分发给 active 状态下的 Observer 。
另外也可以看到 LiveData 引入了 版本管理 来管理数据 (mData)以 确保发送的数据总是最新的 。(具体不多讲)
dispatchingValue 这里分两种情况:
需要着重讲一下。
上面提到过,LifecycleBoundObserver.onStateChanged 方法里调用了 activeStateChanged ,而该方法调用dispatchingValue(this);传入了 this ,也就是 LifecycleBoundObserver ,这时候不为 null 。
上面我也提前说了,除了生命周期改变触发的流程外,还有 postValue&setValue 流程,来看下这俩方法。
private final Runnable mPostValueRunnable = new Runnable() { @Override public void run() { Object newValue; synchronized (mDataLock) { newValue = mPendingData; mPendingData = NOT_SET; } //noinspection unchecked //调用 setValue setValue((T) newValue); } }; protected void postValue(T value) { boolean postTask; synchronized (mDataLock) { postTask = mPendingData == NOT_SET; mPendingData = value; } if (!postTask) { return; } ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); } @MainThread protected void setValue(T value) { //必须在主线程调用 否则会 crash assertMainThread("setValue"); mVersion++;//增加版本号 mData = value; //传入了 null dispatchingValue(null); } 复制代码
LiveData 的 postValue 方法其实就是把操作 post 到主线程, 最后调用的还是 setValue 方法 ,注意 setValue 必须是在主线程调用。
并且可以看到** setValue 方法调用了 dispatchingValue 方法,并传入了 null ,这个时候的流程则会通知 active 的mObservers**。
到这里之前的剩下的所有疑问也都可以解答了。
LiveData 的两个流程都会走到 dispatchingValue 处理分发通知逻辑, 并且在分发通知前会判断 owner 的状态,再加上 LiveData 本身内部的版本管理,确保了 只会发送最新的数据给 active 状态下的 Observer 。
**注意:**LiveData 对同时多次修改数据做了处理,如果同时多次修改,只会修改为最新的数据。
再看一遍类图,回顾一下:
(图2.LiveData 类图)
Lifecycle 改变触发流程:
(图3.Lifecycle 改变触发流程图)
Lifecycle postValue/setValue 触发流程:
(图4.setValue 改变触发流程图)
LiveData 还有很多其他相关知识,这里列举一些,更多实践可以看一下【7.6】。
LiveData 被订阅时,如果之前已经更改过数据,并且当前 owner 为 active 的状态,activeStateChanged() 会被调用,也即会立马通知到 Observer ,这样其实就类似 EventBus 的 sticky event 的功能,需要注意的是,很多时候我们并不需要该功能。具体可以看一下【7.6】的处理。
默认情况下,LiveData 会跟 LicycleOwner 绑定,只在 active 状态下更新,如若想要 不管在什么状态下都能接收到数据的更改通知 的话,怎么办?这时候需要使用 AlwaysActiveObserver ,改调用 observe 方法为调用 LiveData.observeForever(Observer) 方法即可。
LiveData 还有一个子类是 MediatorLiveData,它允许我们合并多个 LiveData,任何一个 LiveData 有更新就会发送通知。比如我们的数据来源有两个,一个数据库一个网络,这时候我们会有两个 DataSource,也就是两个 LiveData,这个时候我们可以使用 MediatorLiveData 来 merge 这两个 LiveData。
Transformations 允许我们把一个 LiveData 进行处理,变化成另外一个 LiveData,目前支持 map 跟 switchMap 两个方法,跟 RxJava 的操作类似。
比如,用 map 把一个 String 类型的 LiveData 转换成 Integer 类型:
Transformations.map(liveString, new Function<String, Integer>() { @Override public Integer apply(final String input) { return Integer.valueOf(input); } }).observe(this, new Observer<Integer>() { @Override public void onChanged(@Nullable final Integer integer) { } }); 复制代码
EventBus 基于观察者模式,LiveData 也是,所以 LiveData 可以被用来做成 LiveDataBus,有兴趣可以搜索。
observeForever()
方法; 我们可以使用 LiveData 非常轻松地做到一些非常高效的操作,如仅在 active 的状态下刷新 UI,可以避免不必要的数据刷新。
显而易见 LiveData 本身的优秀特性有着巨大的价值,利用好绝对是架构设计中的一大利器,另外 LiveData 配合 ViewModel 可以发挥更大的价值,机智的你一定已经知道下一篇文章讲什么了。