0.前言
關(guān)于livedata的使用詳情見LiveData+ViewModel+RxJava2+autoDisposable解決內(nèi)存泄漏,廢話也在里面古话。
啥嘚，擼起袖子擼代碼吧脱羡。
1. liveData使用
官方文檔可見定页，liveData提供了幾個(gè)方法可使用（日常使用的就四個(gè)）：observer菠秒，observerForever赊瞬，postValue和setValue（省略方法的參數(shù)名），者幾個(gè)方法的區(qū)別主要如下：
- observer用于訂閱觀察者椭岩，實(shí)現(xiàn)在Activity（LifecycleOwner）處于活躍狀態(tài)下執(zhí)行onChange方法
- observerForever：setValue之后立馬回調(diào)onChange茅逮，不管lifeCycleOwner生命周期，需要手動(dòng)移除訂閱
- setValue更新liveData的數(shù)據(jù)判哥，只能在UI線程調(diào)用献雅，否則報(bào)錯(cuò)，liveData訂閱的Observer的onChange方法將在調(diào)用的線程中執(zhí)行
- postValue塌计，liveData訂閱的Observer的onChange方法將在主線程中執(zhí)行挺身，內(nèi)部調(diào)用setValue（所以，這廝就是個(gè)回調(diào)方法運(yùn)行在主線程的setValue而已）
so锌仅，下面就從這幾個(gè)方法切入分析源碼
讓我們一步步揭開liveData的神秘面紗
2. observe
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
//如果owner所在Activity或Fragment處于消亡狀態(tài)下章钾，直接返回
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 內(nèi)部定義的一個(gè)Observer，將owner和observer包裝起來
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
//mObservers是緩存的SafeIterableMap热芹，繼承Iterable接口贱傀，此處判斷Observer是否已經(jīng)存在
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
//如果已經(jīng)存在，且與此owner的Observer不一致伊脓，拋出異常
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
//已經(jīng)存在府寒，返回
if (existing != null) {
return;
}
//否則，將包裝了owner和Observer的wrapper 添加到owner中
//因此报腔，當(dāng)owner的生命周期發(fā)生變化時(shí)株搔，可以調(diào)用LifecycleBoundObserver 的onStateChange方法
owner.getLifecycle().addObserver(wrapper);
}
And Then：
- LifecycleBoundObserver
//LifecycleBoundObserver 繼承于內(nèi)部類ObserverWrapper實(shí)現(xiàn)GenericLifecycleObserver ，實(shí)現(xiàn)onStateChanged方法
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@NonNull final LifecycleOwner mOwner;//緩存?zhèn)鬟f過來的owner
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
super(observer);//將Observer傳給父類ObserverWrapper
mOwner = owner;
}
//判斷是否需要激活纯蛾，當(dāng)生命周期為STARTED/RESUMED狀態(tài)下返回true
//具體源碼查看lifecycle
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
//當(dāng)owner的生命周期變化時(shí)纤房，調(diào)用此方法
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
//如果已經(jīng)消亡，移除掉Observer翻诉，然后返回
//看吧炮姨，所以我們不需要手動(dòng)移除Observer捌刮，內(nèi)部幫我們實(shí)現(xiàn)了
removeObserver(mObserver);
return;
}
//否則調(diào)用shouldBeActive判斷是否要激活狀態(tài)，傳遞給activeStateChanged
activeStateChanged(shouldBeActive());
}
//判斷改Observer是否已經(jīng)添加了
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
//移除Observer
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
然后再調(diào)用activeStateChanged的方法進(jìn)入下一步剑令，實(shí)際上是調(diào)用父類ObserverWrapper 的activeStateChanged方法，按照“因?yàn)槎际且粯拥牟僮髀镏舨椋苑旁诟割愖詈玫牧恕边@樣的設(shè)計(jì)思想實(shí)現(xiàn)
- ObserverWrapper
//剛才說了吁津，LifecycleBoundObserver 會(huì)包裝owner和Observer，就是這廝搞的鬼
private abstract class ObserverWrapper {
final Observer<T> mObserver;
boolean mActive;//記錄是否處于活躍狀態(tài)
int mLastVersion = START_VERSION;//記錄版本號(hào)堕扶，用于判斷數(shù)據(jù)是否需要更新
ObserverWrapper(Observer<T> observer) {
mObserver = observer;
}
//這里不解釋
abstract boolean shouldBeActive();
//別問我碍脏，不解釋
boolean isAttachedTo(LifecycleOwner owner) {
return false;
}
//>_<
void detachObserver() {
}
//更新狀態(tài)（是否激活）
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;//當(dāng)newActive為true，增加計(jì)數(shù)點(diǎn)
//當(dāng)mActiveCount 為1時(shí)調(diào)用onActive
if (wasInactive && mActive) {
onActive();//這廝是個(gè)空方法
}
//當(dāng)mActiveCount 為0時(shí)調(diào)用稍算，所有Observer都被移除之后調(diào)用典尾，所以此方法可用于結(jié)束時(shí)釋放資源
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive();
}
//復(fù)活后更新
//實(shí)際場(chǎng)景就是，使用setValue更新數(shù)據(jù)時(shí)糊探，activity處于瀕死狀態(tài)（onPause或onStop）時(shí)钾埂，
//setValue調(diào)用dispatchingValue（稍后介紹）直接返回，當(dāng)Activity復(fù)活后（到前臺(tái)了）科平，就會(huì)調(diào)用此方法褥紫，從而實(shí)現(xiàn)僅在activity處于活躍狀態(tài)下更新數(shù)據(jù)
if (mActive) {
//處理數(shù)據(jù)
dispatchingValue(this);
}
}
}
如注釋所言，liveData只會(huì)在activity處于活躍狀態(tài)下更新數(shù)據(jù)瞪慧，看起來很神秘髓考，現(xiàn)在你知道為什么了吧，其實(shí)就是這么簡(jiǎn)單弃酌，activity復(fù)活后重新調(diào)用一次LifecycleBoundObserver 的onStateChange氨菇，然后就是activeStateChanged......
接下來是 dispatchingValue：
private void dispatchingValue(@Nullable ObserverWrapper initiator) {
//防止重復(fù)分發(fā)相同的內(nèi)容
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
//當(dāng)initiator != null，只處理當(dāng)前Observer
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
//否則遍歷所有的Observer妓湘，進(jìn)行分發(fā)
for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());//更新數(shù)據(jù)
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
當(dāng)initiator != null查蓉，只處理當(dāng)前Observer，否則遍歷所有的Observer榜贴，進(jìn)行分發(fā)奶是。這里怎么理解呢？怎么會(huì)有多個(gè)呢竣灌？前面也已經(jīng)說了聂沙，這還是因?yàn)閍ctivity瀕死時(shí)調(diào)用setValue多次的原因。
接下來是considerNotify：
private void considerNotify(ObserverWrapper observer) {
//如果不處于活躍狀態(tài)初嘹，就返回
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;
}
//版本號(hào)終于派上用場(chǎng)了及汉，如果數(shù)據(jù)已經(jīng)是最新，就不更新屯烦，直接返回
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
//noinspection unchecked
observer.mObserver.onChanged((T) mData);//Observer的onChanged方法終于調(diào)用了
}
這里最后時(shí)調(diào)用了onChanged方法更新數(shù)據(jù)坷随。初次自制流程圖房铭，圖片太大勿噴
observe.png
3.setValue
@MainThread
protected void setValue(T value) {
//一開頭就要求運(yùn)行在主線程
assertMainThread("setValue");
mVersion++;//版本號(hào)更新
mData = value;//緩存數(shù)據(jù)
dispatchingValue(null);//什么啊，還是調(diào)用dispatchingValue呀
}
然后就調(diào)用了dispatchingValue方法温眉，前面已經(jīng)介紹了缸匪，先介紹observe，沒毛病
setValue.png
4.postValue
protected void postValue(T value) {
boolean postTask;
//進(jìn)程鎖住类溢，因此liveData是線程安全的
synchronized (mDataLock) {
//判斷是否沒有在處理數(shù)據(jù)
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);//到主線程去處理
}
private final Runnable mPostValueRunnable = new Runnable() {
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;//處理完了
}
//noinspection unchecked
setValue((T) newValue);//實(shí)際上調(diào)用的還是setValue方法
}
};
postValue.png
啥嘚啥嘚凌蔬，最后一個(gè)：
5.observeForever
@MainThread
public void observeForever(@NonNull Observer<T> observer) {
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
wrapper.activeStateChanged(true);
}
private class AlwaysActiveObserver extends ObserverWrapper {
AlwaysActiveObserver(Observer<T> observer) {
super(observer);
}
@Override
boolean shouldBeActive() {
return true;
}
}
誒多，跟observe很像闯冷，只不過用來封裝owner和observer的是AlwaysActiveObserver 砂心，而AlwaysActiveObserver 并沒有像LifecycleBoundObserver 那樣繼承于內(nèi)部類ObserverWrapper實(shí)現(xiàn)GenericLifecycleObserver，所以自然不會(huì)根據(jù)Activity的生命周期回調(diào)onStateChange方法蛇耀，當(dāng)然也就不會(huì)自動(dòng)移除observer啦辩诞，必須要手動(dòng)移除。
以上纺涤！
附上總圖：
LiveData源碼解析.jpg
6.總結(jié)
本文通過源碼分析译暂，解決了
- liveData只在activity（lifecycleowner）處于活躍狀態(tài)下更新數(shù)據(jù)的原因
- setValue和postValue更新數(shù)據(jù)時(shí)，activity處于非活躍狀態(tài)撩炊，activity重回前臺(tái)后繼續(xù)更新數(shù)據(jù)的原因
- liveData防止內(nèi)存泄漏的原因以及自動(dòng)移除Observer的原因
原創(chuàng)文章秧秉，轉(zhuǎn)載請(qǐng)附上http://www.reibang.com/p/943770f22470
