ViewModel和LiveData問題思考與解答

jimuzz發表於2020-11-02

ViewLiveData

嗨，大家好，面試真題系列又來了，今天我們說說MVVM架構裡的兩大元件：ViewModel和LiveData。
還是老樣子，提出問題，做出解答。

ViewModel 是什麼？
ViewModel 為什麼被設計出來，解決了什麼問題？
說說ViewModel原理。
LiveData 是什麼？
LiveData 為什麼被設計出來，解決了什麼問題？
說說LiveData原理。

ViewModel 是什麼，說說你所理解的ViewModel？

如果看過我上一篇文章的小夥伴應該都有所瞭解，ViewModel是MVVM架構的一個層級，用來聯絡View和model之間的關係。而我們今天要說的就是官方出的一個框架——ViewModel。

ViewModel 類旨在以注重生命週期的方式儲存和管理介面相關的資料

官方是這麼介紹的，這裡面有兩個資訊：

注重生命週期的方式。
由於ViewModel的生命週期是作用於整個Activity的，所以就節省了一些關於狀態維護的工作，最明顯的就是對於螢幕旋轉這種情況，以前對資料進行儲存讀取，而ViewModel則不需要，他可以自動保留資料。

其次，由於ViewModel在生命週期內會保持區域性單例，所以可以更方便Activity的多個Fragment之間通訊，因為他們能獲取到同一個ViewModel例項，也就是資料狀態可以共享了。

儲存和管理介面相關的資料。

ViewModel層的根本職責，就是負責維護介面上UI的狀態，其實就是維護對應的資料，因為資料會最終體現到UI介面上。所以ViewModel層其實就是對介面相關的資料進行管理，儲存等操作。

ViewModel 為什麼被設計出來，解決了什麼問題？

在ViewModel元件被設計出來之前，MVVM又是怎麼實現ViewModel這一層級的呢？

其實就是自己編寫類，然後通過介面，內部依賴實現View和資料的雙向繫結。
所以Google出這個ViewModel元件，無非就是為了規範MVVM架構的實現，並儘量讓ViewModel這一層級只觸及到業務程式碼，不去關心VIew層級的引用等。然後配合其他的元件，包括livedata，databindingrang等讓MVVM架構更加完善，規範，健碩。

解決了什麼問題呢？

其實上面已經說過一些了，比如：

1）不會因為螢幕旋轉而銷燬，減少了維護狀態的工作
2）由於在作用域內單一例項的特性，使得多個fragment之間可以方便通訊，並且維護同一個資料狀態。
3）完善了MVVM架構，使得解耦更加純粹。

說說ViewModel原理。

首先說說是怎麼儲存生命週期

ViewModel2.0之前呢，其實原理是在Activity上add一個HolderFragment，然後設定setRetainInstance(true)方法就能讓這個Fragment在Activity重建時存活下來，也就保證了ViewModel的狀態不會隨Activity的狀態所改變。

2.0之後，其實是用到了Activity的onRetainNonConfigurationInstance()和getLastNonConfigurationInstance()這兩個方法，相當於在橫豎屏切的時候會儲存ViewModel的例項，然後恢復，所以也就保證了ViewModel的資料。

再說說怎麼保證作用域內唯一例項

首先，ViewModel的例項是通過反射獲取的，反射的時候帶上application的上下文，這樣就保證了不會持有Activity或者Fragment等View的引用。然後例項建立出來會儲存到一個ViewModelStore容器裡面，其實也就是一個集合類，這個ViewModelStore 類其實就是儲存在介面上的那個例項，而我們的ViewModel就是裡面的一個集合類的子元素。

所以我們每次獲取的時候，首先看看這個集合裡面有無我們的ViewModel，如果沒有就去例項化，如果有就直接拿到例項使用，這樣就保證了唯一例項。最後在介面銷燬的時候，會去執行ViewModelStore的clear方法，去清除集合裡面的ViewModel資料。一小段程式碼說明下：

public <T extends ViewModel> T get(Class<T> modelClass) {
      // 先從ViewModelStore容器中去找是否存在ViewModel的例項
      ViewModel viewModel = mViewModelStore.get(key);
     
      // 若ViewModel已經存在，就直接返回
      if (modelClass.isInstance(viewModel)) {
            return (T) viewModel;
      }
       
      // 若不存在，再通過反射的方式例項化ViewModel，並儲存進ViewModelStore
      viewModel = modelClass.getConstructor(Application.class).newInstance(mApplication);
      mViewModelStore.put(key, viewModel);
      return (T) viewModel;
 }


public class ViewModelStore {
    private final HashMap<String, ViewModel> mMap = new HashMap<>();

     public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.onCleared();
        }
        mMap.clear();
    }
}



 @Override
protected void onDestroy() {
    super.onDestroy();

   if (mViewModelStore != null && !isChangingConfigurations()) {
        mViewModelStore.clear();
    }

}

LiveData 是什麼？

LiveData 是一種可觀察的資料儲存器類。與常規的可觀察類不同，LiveData 具有生命週期感知能力，意指它遵循其他應用元件（如 Activity、Fragment 或 Service）的生命週期。這種感知能力可確保 LiveData 僅更新處於活躍生命週期狀態的應用元件觀察者。

官方介紹如下，其實說的比較清楚了，主要作用在兩點：

資料儲存器類。也就是一個用來儲存資料的類。
可觀察。這個資料儲存類是可以觀察的，也就是比一般的資料儲存類多了這麼一個功能，對於資料的變動能進行響應。

主要思想就是用到了觀察者模式思想，讓觀察者和被觀察者解耦，同時還能感知到資料的變化，所以一般被用到ViewModel中，ViewModel負責觸發資料的更新，更新會通知到LiveData，然後LiveData再通知活躍狀態的觀察者。

        var liveData = MutableLiveData<String>()

        liveData.observe(this, object : Observer<String> {
            override fun onChanged(t: String?) {
            }
        })

        liveData.setVaile("xixi")
        //子執行緒呼叫
        liveData.postValue("test")

LiveData 為什麼被設計出來，解決了什麼問題？

LiveData作為一種觀察者模式設計思想，常常被和Rxjava一起比較，觀察者模式的最大好處就是事件發射的上游和接收事件的下游互不干涉，大幅降低了互相持有的依賴關係所帶來的強耦合性。

其次，LiveData還能無縫銜接到MVVM架構中，主要體現在其可以感知到Activity等生命週期，這樣就帶來了很多好處：

不會發生記憶體洩漏
觀察者會繫結到 Lifecycle 物件，並在其關聯的生命週期遭到銷燬後進行自我清理。
不會因 Activity 停止而導致崩潰
如果觀察者的生命週期處於非活躍狀態（如返回棧中的 Activity），則它不會接收任何 LiveData 事件。
自動判斷生命週期並回撥方法
如果觀察者的生命週期處於 STARTED 或 RESUMED狀態，則 LiveData 會認為該觀察者處於活躍狀態，就會呼叫onActive方法，否則，如果 LiveData 物件沒有任何活躍觀察者時，會呼叫 onInactive()方法。

說說LiveData原理。

說到原理，其實就是兩個方法：

訂閱方法，也就是observe方法。通過該方法把訂閱者和被觀察者關聯起來，形成觀察者模式。

簡單看看原始碼：

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        //...
        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);
    }

      public V putIfAbsent(@NonNull K key, @NonNull V v) {
        Entry<K, V> entry = get(key);
        if (entry != null) {
            return entry.mValue;
        }
        put(key, v);
        return null;
    }

這裡putIfAbsent方法是講生命週期相關的wrapper和觀察者observer作為key和value存到了mObservers中。

回撥方法，也就是onChanged方法。通過改變儲存值，來通知到觀察者也就是呼叫onChanged方法。從改變儲存值方法setValue看起：

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


private void dispatchingValue(@Nullable ObserverWrapper initiator) {
    //...
    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;
}


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;
    //noinspection unchecked
    observer.mObserver.onChanged((T) mData);
}

這一套下來邏輯還是比較簡單的，遍歷剛才的map——mObservers，然後找到觀察者observer，如果觀察者不在活躍狀態（活躍狀態，也就是可見狀態，處於 STARTED 或 RESUMED狀態），則直接返回，不去通知。否則正常通知到觀察者的onChanged方法。

當然，如果想任何時候都能監聽到，都能獲取回撥，呼叫observeForever方法即可。