一、LiveData簡(jiǎn)介
LiveData是google官方架構(gòu)JetPack系列的一個(gè)響應(yīng)式開(kāi)發(fā)框架，LiveData是一個(gè)可以被觀察的數(shù)據(jù)持有者類(lèi)。說(shuō)到響應(yīng)式開(kāi)發(fā)或者說(shuō)觀察者就不免想到RxJava，RxJava將觀察者模式運(yùn)用的爐火純青。但LiveData和RxJava的定位是不一樣的，LiveData主要用于搭建MVVM架構(gòu)，并在其中作為數(shù)據(jù)持有者，LiveData能監(jiān)聽(tīng)組件的生命周期變化，這樣一來(lái)只會(huì)更新處于活躍狀態(tài)的組件。
LiveData的特點(diǎn)：1）采用觀察者模式自動(dòng)提示UI更新。2）不需要手動(dòng)處理生命周期，不會(huì)因?yàn)锳ctivity的銷(xiāo)毀重建而丟失數(shù)據(jù)。3）不會(huì)出現(xiàn)內(nèi)存泄漏。4）不需要手動(dòng)取消訂閱，Activity在非活躍狀態(tài)下（銷(xiāo)毀、finish之后）不會(huì)收到數(shù)據(jù)更新信息。

二、LiveData用法
1）LiveData往往結(jié)合于ViewModel使用，對(duì)于ViewModel的分析之前已經(jīng)進(jìn)行分析了，這里不再過(guò)多描述。首先在ViewModel中創(chuàng)建LiveData，代碼如下：

class MainViewModel : ViewModel() {

private val repertory: MainRepositoryby lazy { MainRepository()}

    var data: MutableLiveData = MutableLiveData()

fun getDataFromServer(){

repertory.getDataFromServer(data)

}
}

這里采用的是MutableLiveData，它是LiveData的實(shí)現(xiàn)類(lèi)，LiveData是一個(gè)抽象類(lèi)。
2）在Activity中觀察LiveData的數(shù)據(jù)變化。代碼如下：

class MainActivity : AppCompatActivity() {
 private lateinit var mModel: MainViewModel
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initData()
    }
    private fun initData() {
        mModel = ViewModelProviders.of(this)[MainViewModel::class.java]
        mModel.data?.observe(this, Observer {
            val mainAdapter = MainAdapter(this, it)
            val linearLayoutManager = LinearLayoutManager(this)
            rv.layoutManager = linearLayoutManager
            rv.adapter = mainAdapter
        })
        mModel.getDataFromServer()
    }
}

3)對(duì)LiveData進(jìn)行賦值，代碼如下：

fun postData() {
        mModel.data.postValue(JsonBean(ArrayList(), 0, ""))
    }

三、源碼分析
1）首先先從實(shí)例化MutableLiveData入手，MutableLiveData是LiveData的實(shí)現(xiàn)類(lèi)，源碼如下：

public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }
    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

從代碼中可以看到，LiveData是一個(gè)泛型類(lèi)，泛型參數(shù)就是存儲(chǔ)數(shù)據(jù)的實(shí)際類(lèi)型，同時(shí)MutableLiveData提供兩個(gè)賦值方法：postValue和setValue，而這兩個(gè)方法直接調(diào)用父類(lèi)中的方法。所以看一下父類(lèi)中這兩個(gè)方法的具體實(shí)現(xiàn)

  @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

setValue方法必須在主線程調(diào)用，調(diào)用只有LiveData就持有新的數(shù)據(jù)了。

protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

postValue方法同樣是更新LiveData持有的數(shù)據(jù)，但區(qū)別在于postValue方法是單獨(dú)采用Runnable通過(guò)主線程handler發(fā)送給主線程更新數(shù)據(jù)，這樣一來(lái)postValue就可以在異線程更新數(shù)據(jù)了。其實(shí)postValue最終更新數(shù)據(jù)還是走的setValue方法。
2）分析在Activity中訂閱LiveData的方法observe，此方法接收兩個(gè)參數(shù)，一個(gè)LifecycleOwner和Observer<T>，代碼如下：

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        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);
    }

從中我們可以發(fā)現(xiàn)方法首先會(huì)判斷當(dāng)前視圖狀態(tài)是否已經(jīng)是”DESTROYED“狀態(tài)，在分析訂閱方法之前先分析一下LifecycleOwner這個(gè)接口。

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

在這個(gè)接口中只有一個(gè)方法用于返回Lifecycle。查看一下接口的實(shí)現(xiàn)類(lèi)可以發(fā)現(xiàn)v4和v7包下的Acvitity和Fragment都實(shí)現(xiàn)了這個(gè)接口。接下來(lái)看一下Lifecycle這個(gè)抽象類(lèi)。

public abstract class Lifecycle {
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    @MainThread
    @NonNull
    public abstract State getCurrentState();
.....省略部分代碼
}

類(lèi)中定義了添加和移除訂閱者的方法，同時(shí)還包括訂閱者的生命周期狀態(tài)信息。而Lifecycle的唯一實(shí)現(xiàn)類(lèi)是LifecycleRegistry，代碼如下。

public class LifecycleRegistry extends Lifecycle {
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();
  
    private final WeakReference<LifecycleOwner> mLifecycleOwner;
    private int mAddingObserverCounter = 0;

    private boolean mHandlingEvent = false;
    private boolean mNewEventOccurred = false;
    private ArrayList<State> mParentStates = new ArrayList<>();
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }
......省略部分代碼

    private boolean isSynced() {
        if (mObserverMap.size() == 0) {
            return true;
        }
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }

    private State calculateTargetState(LifecycleObserver observer) {
        Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

        State siblingState = previous != null ? previous.getValue().mState : null;
        State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
                : null;
        return min(min(mState, siblingState), parentState);
    }

    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }

    private void popParentState() {
        mParentStates.remove(mParentStates.size() - 1);
    }

    private void pushParentState(State state) {
        mParentStates.add(state);
    }

    @Override
    public void removeObserver(@NonNull LifecycleObserver observer) {
        mObserverMap.remove(observer);
    }
    @NonNull
    @Override
    public State getCurrentState() {
        return mState;
    }

    static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

    private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

    private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }
.....省略部分代碼
}

先來(lái)看一下主要的成員變量mObserverMap和mLifecycleOwner，mObserverMap是一個(gè)Map結(jié)構(gòu)，以觀察者為key存儲(chǔ)觀察者狀態(tài)。mLifecycleOwner是一個(gè)弱引用，持有LifecycleOwner，其實(shí)LifecyleOwner就是Activity或者Fragment。前面說(shuō)到過(guò)Activity中會(huì)實(shí)現(xiàn)LifecycleOwner接口，其實(shí)追蹤到源碼發(fā)現(xiàn)SupportActivity實(shí)現(xiàn)了LifecycleOwner接口，同時(shí)聲明變量LifecycleRegistry，代碼如下：

 private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

由此一來(lái)LifecycleRegistry就持有Activity的弱引用了，這樣一來(lái)既能監(jiān)聽(tīng)Activity的生命周期同時(shí)也不會(huì)造成內(nèi)存泄漏。接下來(lái)看關(guān)鍵的訂閱和取消訂閱方法，取消訂閱很簡(jiǎn)單就是將觀察者移除Map集合，訂閱方法會(huì)先校驗(yàn)觀察者的生命周期狀態(tài)，同時(shí)從軟引用中獲取LifecycleOwner，如果為空的話則說(shuō)明界面已經(jīng)被銷(xiāo)毀了，則不需要進(jìn)行訂閱了。否則進(jìn)行訂閱操作。
現(xiàn)在回到前面繼續(xù)分析LiveData的訂閱操作，訂閱操作會(huì)將owner和observer統(tǒng)一包裝成LifecycleBoundObserver，這是Lifecycle真正的訂閱者。

 class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
            super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

類(lèi)中封裝了對(duì)于Lifecycle的狀態(tài)賦值操作和狀態(tài)改變對(duì)觀察者進(jìn)行取消訂閱操作。最后將LifecycleBoundObserver傳入LifecycleRegistry完成訂閱。整體的訂閱流程就分析完了。
3）Observer響應(yīng)獲取數(shù)據(jù)變化流程分析。
分析完訂閱流程接下來(lái)分析LiveData如何響應(yīng)數(shù)據(jù)變化通知給訂閱者，這里需要從setValue方法入手。

   protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

 private void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

調(diào)用setValue方法后會(huì)調(diào)用dispatchingValue方法循環(huán)通知訂閱者響應(yīng)數(shù)據(jù)變化。

三、LiveData特點(diǎn)原理總結(jié)
1）采用觀察者模式自動(dòng)提示UI更新：
由于采用訂閱方式獲取數(shù)據(jù)變化所以自動(dòng)獲取數(shù)據(jù)更新。
2）不需要手動(dòng)處理生命周期，不會(huì)因?yàn)锳ctivity的銷(xiāo)毀重建而丟失數(shù)據(jù)：
會(huì)自動(dòng)重新訂閱。
3）不會(huì)出現(xiàn)內(nèi)存泄漏：
Lifecycle持有的是Activity（Fragment）的弱引用。
4）不需要手動(dòng)取消訂閱，Activity在非活躍狀態(tài)下（銷(xiāo)毀、finish之后）不會(huì)收到數(shù)據(jù)更新信息：
LifecycleRegistry會(huì)回調(diào)Activity的狀態(tài)，在onDestory之后LiveData自動(dòng)取消訂閱。