?ViewModel 具備宿主生命后期感知能力的資料存盤組件，使用 ViewModel 保存的資料，在頁面因配置變更導致頁面銷毀重建之后依然也是存在的，其中配置變更主要是指橫豎屏切換、解析度調整、權限變更、系統字體樣式變更，ViewModel 的優勢：
- 頁面更改資料不丟失
?當設備因配置更改導致 Activity/Fragment 重建，ViewModel 中的資料并不會因此而丟失，配合 LiveData 可以在頁面重建后立馬能收到最新保存的資料用以重新渲染頁面，
- 生命周期感應
?在 ViewModel 中難免會做一些網路請求或資料的處理，可以復寫 onCleared() 方法，終止清理一些操作，釋放記憶體，該方法在宿主 onDestroy 時被呼叫，
- 資料共享
?對于單 Activity 對 Fragment 的頁面，可以使用 ViewModel 實作頁面之間的資料共享，實際上不同的 Activity也可以實作資料共享，
1. ViewModel基本使用
（1）首先，在module的build.gradle中添加依賴；
//通常情況下，只需要添加appcompat就可以了
api 'androidx.appcompat:appcompat:1.1.0'
//如果想單獨使用，可引入下面的依賴
api 'androidx.lifecycler:lifecycle-viewmodel:2.0.0'
（2）其次，實作一個與當前Activity/Fragment關聯的ViewModel；
? 通常一個Activity對應一個ViewModel，Activity可以由多個Fragment組成，因此多個Fragment共享這個ViewModel物件存盤的資料(注：實際上是LiveData存盤的資料)，當然，多個Activity也可以共享同一個ViewModel，但是需要在Application中特殊配置；
class SharedViewModel : ViewModel() {
val selected = MutableLiveData<Item>()
fun select(item: Item) {
selected.value = item
}
}
（3）最后，實體化一個ViewModel物件，
?在ViewModel中，我們結合LiveData即可實作一個MVVM架構開發模式，其中，ViewModel將充當VM層，負責從M層獲取資料并通知V層自動更新UI(LiveData實作)，
// 獲取Activity對應的ViewModel
// 該ViewModel的生命周期與Activity一致
val viewModel = ViewModelProvider(activity).get(SharedViewModel::class.java)
// 在Fragment中獲取Activity的ViewModel
// 那么Activity與Fragment共享該ViewModel物件
val viewModel = ViewModelProvider(requestActivity()).get(SharedViewModel::class.java)
// 創建一個Fragment的ViewModel物件
// 該ViewModel的生命周期與Fragment一致
val viewModel = ViewModelProvider(fragment).get(SharedViewModel::class.java)
?當然，我們也可以Kotlin的特性更容易的獲取ViewModel物件，但需要注意的是，這需要在專案中分別依賴activity-ktx和fragment-ktx庫，
// Activity及其兩個Fragment獲得得將是同一個SharedViewModel物件
// 即共享資料
class MyActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
val model: SharedViewModel by viewModels()
model.selected().observe(this, Observer<Item>{ item ->
})
}
}
class MasterFragment : Fragment() {
private lateinit var itemSelector: Selector
private val model: SharedViewModel by activityViewModels()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
itemSelector.setOnClickListener { item ->
// Update the UI
}
}
}
class DetailFragment : Fragment() {
private val model: SharedViewModel by activityViewModels()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
model.selected.observe(viewLifecycleOwner, Observer<Item> { item ->
// Update the UI
})
}
}
2. ViewModel原始碼決議
2.1 ViewModel的生命周期
2.2 ViewModel實作原理
?ViewModel框架UML類圖如下：
具體說明如下：
- ViewModelProvider
?ViewModelProvider是提供創建ViewModel物件的入口，它的構造方法需要傳入一個ViewModelStoreOwner物件和一個Factory物件，其內部將通過工廠模式完成對ViewModel實體的創建，原始碼如下：
public class ViewModelProvider {
private static final String DEFAULT_KEY =
"androidx.lifecycle.ViewModelProvider.DefaultKey";
...
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
mFactory = factory;
mViewModelStore = store;
}
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
// 具體工廠創建ViewModel實體
}
}
- ViewModelStoreOwner
?ViewModelStoreOwner是一個介面，通過實作該介面，用于表明自己是一個ViewModelStore的擁有者(owner)，Activity/Fragment均繼承了這個介面，在Activity/Fragment中，可以通過getViewModelStore()方法獲取與其關聯的ViewModelStore物件，原始碼如下：
public interface ViewModelStoreOwner {
@NonNull
ViewModelStore getViewModelStore();
}
- ViewModelStore
?ViewModelStore是一個ViewModel實體存盤倉庫，它內部維護了一個HashMap集合，實作存盤多個ViewModel實體，在Activity/Fragment中，可以通過呼叫其getViewModelStore()方法來獲取與之關聯的ViewModelStore物件，原始碼如下：
public class ViewModelStore {
private final HashMap<String, ViewModel> mMap = new HashMap<>();
final void put(String key, ViewModel viewModel) {
ViewModel oldViewModel = mMap.put(key, viewModel);
if (oldViewModel != null) {
oldViewModel.onCleared();
}
}
final ViewModel get(String key) {
return mMap.get(key);
}
Set<String> keys() {
return new HashSet<>(mMap.keySet());
}
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
}
- Factory
?在ViewModel框架中，是通過工廠模式實作對ViewModel物件的創建，其中，Factory就是所有具體工廠類的父介面，它提供了一個通用的方法create來創建一個ViewModel物件，但具體的實作是在具體工廠類中，如KeyedFactory、SavedStateViewModelFactory 、NewInstanceFactory、AndroidViewModelFactory，原始碼如下：
public interface Factory {
@NonNull
<T extends ViewModel> T create(@NonNull Class<T> modelClass);
}
2.2.1 創建ViewModel物件程序
?首先，創建一個ViewModelProvider物件，其構建方法中需要傳入一個ViewModelStoreOwner和指定創建ViewModel實體的工廠Factory，這個工廠物件可選，對于Activity和Fragment來說，默認呼叫ViewModelStoreOwner的getDefaultViewModelProviderFactory()方法獲取，因為它們均實作了HasDefaultViewModelProviderFactory介面，代碼如下：
public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
// owner即Activity或Fragment
// 它們均繼承了ViewModelStoreOwner和HasDefaultViewModelProviderFactory
this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance());
}
public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull Factory factory) {
this(owner.getViewModelStore(), factory);
}
// ViewModelStore: ViewModel倉庫，存盤所有ViewModel物件
// factory：創建ViewModel的具體工廠
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
mFactory = factory;
mViewModelStore = store;
}
?其次，通過工廠模式實體化一個ViewModel物件，并回傳，具體程序如下：
- a. 檢查ViewModelStore倉庫中是否快取了要創建的ViewModel物件；
- b. 如果沒有指定工廠，就使用SavedStateViewModelFactory具體工廠來創建ViewModel物件；
- c. 將創建的ViewModel物件快取到ViewModelStore倉庫中，
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
// 1. 首先，檢查是否存在modelClass的快取
// (1)嘗試從ViewModel倉庫中獲取key對應的ViewModel物件
// 其中，mViewModelStore = owner.getViewModelStore()
ViewModel viewModel = mViewModelStore.get(key);
// (2) 核實viewModel是否確實為modelClass的一個實體
// 如果是，直接return即可
if (modelClass.isInstance(viewModel)) {
if (mFactory instanceof OnRequeryFactory) {
((OnRequeryFactory) mFactory).onRequery(viewModel);
}
return (T) viewModel;
} else {
//noinspection StatementWithEmptyBody
if (viewModel != null) {
// TODO: log a warning.
}
}
// 2. 否則，判斷mFactory是哪一個工廠實體
// 并呼叫對應的create方法創建ViewModel物件
if (mFactory instanceof KeyedFactory) {
viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
} else {
viewModel = (mFactory).create(modelClass);
}
// 3. 將創建的ViewModel物件快取到ViewModel倉庫中
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
?根據ViewModelProvider的構造方法可知，假如我們在Activity或Fragment中創建ViewModel物件的話，mFactory將是它們的getDefaultViewModelProviderFactory()方法回傳的具體工廠物件，即均為SavedStateViewModelFactory，代碼如下：
//.../androidx/activity/ComponentActivity.java
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
HasDefaultViewModelProviderFactory,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner
{
...
public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
if (getApplication() == null) {
throw new IllegalStateException("Your activity is not yet attached to the "
+ "Application instance. You can't request ViewModel before onCreate call.");
}
// 創建SavedStateViewModelFactory物件
if (mDefaultFactory == null) {
mDefaultFactory = new SavedStateViewModelFactory(
getApplication(),
this,
getIntent() != null ? getIntent().getExtras() : null);
}
return mDefaultFactory;
}
}
// .../androidx/fragment/app/Fragment.java
public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner
{
...
public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
if (mFragmentManager == null) {
throw new IllegalStateException("Can't access ViewModels from detached fragment");
}
// 創建SavedStateViewModelFactory物件
if (mDefaultFactory == null) {
mDefaultFactory = new SavedStateViewModelFactory(
requireActivity().getApplication(),
this,
getArguments());
}
return mDefaultFactory;
}
}
?接著，我們來看一下SavedStateViewModelFactory#create是如何構建ViewModel物件，具體程序如下：
- a. 檢查要創建的ViewModel是否包含引數
savedStateHandle的構造方法，分實作AndroidViewModel與否； - b. 如果不存在(a)描述的構造方法，則使用AndroidViewModelFactory具體工廠創建ViewModel物件；
- c. 否則，使用(a)回傳的構造方法反射實體化一個ViewModel物件，
public <T extends ViewModel> T create(@NonNull String key, @NonNull Class<T> modelClass) {
// 1. 首先，查找是否存在modelClass的構造方法
// 根據modelClass是否繼承于AndroidViewModel分兩種情況
// 如果是，查找含有(application, savedStateHandle)引數的構造方法；
// 否則，查找含有(savedStateHandle)引數的構造方法；
boolean isAndroidViewModel = AndroidViewModel.class.isAssignableFrom(modelClass);
Constructor<T> constructor;
if (isAndroidViewModel) {
constructor = findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE);
} else {
constructor = findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE);
}
// doesn't need SavedStateHandle
// 2. 其次，如果沒有找到
// 說明要創建的ViewModel不包含對應的構造方法
// 此時也說明，這里不需要SavedStateHandle
if (constructor == null) {
return mFactory.create(modelClass);
}
// 3. 找到對應的構造方法
// 處理需要SavedStateHandle的情況（本文暫時不考慮）
SavedStateHandleController controller = SavedStateHandleController.create(
mSavedStateRegistry, mLifecycle, key, mDefaultArgs);
try {
T viewmodel;
if (isAndroidViewModel) {
viewmodel = constructor.newInstance(mApplication, controller.getHandle());
} else {
viewmodel = constructor.newInstance(controller.getHandle());
}
viewmodel.setTagIfAbsent(TAG_SAVED_STATE_HANDLE_CONTROLLER, controller);
return viewmodel;
} catch (IllegalAccessException e) {
throw new RuntimeException("Failed to access " + modelClass, e);
} catch (InstantiationException e) {
throw new RuntimeException("A " + modelClass + " cannot be instantiated.", e);
} catch (InvocationTargetException e) {
throw new RuntimeException("An exception happened in constructor of "
+ modelClass, e.getCause());
}
}
?由SavedStateViewModelFactory的構造方法可知，上述代碼的mFactory即位AndroidViewModelFactory的一個實體，代碼如下：
public SavedStateViewModelFactory(@NonNull Application application,
@NonNull SavedStateRegistryOwner owner,
@Nullable Bundle defaultArgs) {
mSavedStateRegistry = owner.getSavedStateRegistry();
mLifecycle = owner.getLifecycle();
mDefaultArgs = defaultArgs;
mApplication = application;
// 單利模式創建AndroidViewModelFactory
mFactory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
?AndroidViewModelFactory繼承于NewInstanceFactory，它們均是Factory的具體工廠實作類，需要注意的是，如果我們自定義的ViewModel繼承于AndroidViewModel，那么就使用AndroidViewModelFactory具體工程來實體化該物件，否則，使用NewInstanceFactory具體工程來實體化，代碼如下：
public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
private static AndroidViewModelFactory sInstance;
@NonNull
public static AndroidViewModelFactory getInstance(@NonNull Application application) {
if (sInstance == null) {
sInstance = new AndroidViewModelFactory(application);
}
return sInstance;
}
private Application mApplication;
public AndroidViewModelFactory(@NonNull Application application) {
mApplication = application;
}
@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
// 1. 如果modelClass是AndroidViewModel的子類
// 呼叫其指定的構造方法來實體化一個物件
if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
try {
return modelClass.getConstructor(Application.class).newInstance(mApplication);
} catch (NoSuchMethodException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (IllegalAccessException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (InstantiationException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (InvocationTargetException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
}
}
// 2. 否則，呼叫父類NewInstanceFactory的create方法
// 該方法會使用默認的構造方法實體化一個物件
// modelClass.newInstance()
return super.create(modelClass);
}
}
public static class NewInstanceFactory implements Factory {
private static NewInstanceFactory sInstance;
@NonNull
static NewInstanceFactory getInstance() {
if (sInstance == null) {
sInstance = new NewInstanceFactory();
}
return sInstance;
}
@SuppressWarnings("ClassNewInstance")
@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
try {
// 使用默認構造方法
// 實體化一個物件
return modelClass.newInstance();
} catch (InstantiationException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
} catch (IllegalAccessException e) {
throw new RuntimeException("Cannot create an instance of " + modelClass, e);
}
}
}
2.2.2 ViewModel復用原因分析
?由ViewModelProvider$get方法可知，當ViewModel被實體化完畢后，將會被存盤到ViewModel的倉庫ViewModelStore中(注：Activity可以關聯多個ViewModel物件)，所有Activity與其關聯的ViewModel物件都會快取到這個ViewModelStore的Map集合中，在Activity獲取ViewModelStore物件如下：
public ViewModelStore getViewModelStore() {
if (getApplication() == null) {
throw new IllegalStateException("Your activity is not yet attached to the "
+ "Application instance. You can't request ViewModel before onCreate call.");
}
// 1. 判斷ViewModelStore是否存在，沒有存在則創建一個
if (mViewModelStore == null) {
//(1) 查看NonConfigurationInstances中是否有快取
// 如果有就回傳這個快取
// static final class NonConfigurationInstances {
// Object custom;
// ViewModelStore viewModelStore;
// }
// 注：NonConfigurationInstances為ComponentActivity的靜態內部類
// 被final修飾，即不可被繼承
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
// Restore the ViewModelStore from NonConfigurationInstances
mViewModelStore = nc.viewModelStore;
}
//(2) 否則，直接new一個
if (mViewModelStore == null) {
mViewModelStore = new ViewModelStore();
}
}
// 2. 否則，直接回傳已經存在的ViewModelStore
return mViewModelStore;
}
?由上述代碼可知，getViewModelStore()方法中會首先從NonConfigurationInstances來獲取ViewModelStore實體物件，那么，ViewModelStore何時被存盤到NonConfigurationInstances？答案是：onRetainNonConfigurationInstance，因系統原因頁面被回收時，會觸發該方法，所以 viewModelStore 物件此時會被存盤在NonConfigurationInstance 中，在頁面恢復重建時，會再次把這個 NonConfigurationInstance 物件傳遞到新的Activity 中實作物件復用，onRetainNonConfigurationInstance()原始碼如下：
public final Object onRetainNonConfigurationInstance() {
Object custom = onRetainCustomNonConfigurationInstance();
ViewModelStore viewModelStore = mViewModelStore;
if (viewModelStore == null) {
// 如果NonConfigurationInstance保存了viewModelStore，把它取出來
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
viewModelStore = nc.viewModelStore;
}
}
if (viewModelStore == null && custom == null) {
return null;
}
NonConfigurationInstances nci = new NonConfigurationInstances();
nci.custom = custom;
//把viewModelStore放到NonConfigurationInstances中并回傳
nci.viewModelStore = viewModelStore;
//把viewModelStore放到NonConfigurationInstances中并回傳
return nci;
}
2.2.3 ViewModel#onClear()被呼叫程序
?ViewModel的onClear()方法是在Activity被銷毀被回呼，即通過監聽Activity的Lifecycle實作，當生命周期為onDestory時，會去呼叫ViewModelStore的clear()方法，在該方法中會遍歷集合中的ViewModel物件，并依次呼叫其onClear()方法，最后，再將集合清空，相關原始碼如下：
// .../androidx/activity/ComponentActivity.class
public ComponentActivity() {
Lifecycle lifecycle = getLifecycle();
...
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
}
// .../androidx/lifecycle/ViewModelStore.class
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
// .../androidx/lifecycle/ViewModel.class
protected void onCleared() {
}
@MainThread
final void clear() {
mCleared = true;
if (mBagOfTags != null) {
synchronized (mBagOfTags) {
for (Object value : mBagOfTags.values()) {
// see comment for the similar call in setTagIfAbsent
closeWithRuntimeException(value);
}
}
}
onCleared();
}
?強調一點：ViewModel只是針對于頁配置變更時，ViewModel能夠實作復用，對于因記憶體不足或者因為電量不足導致頁面被回收情況，是無法實作ViewModel復用的，此時就需要ViewModel配合SavedState實作，它將承擔起ViewModel與onSaveIntanceState之間通信的橋梁，其中，onSaveIntanceState在非配置變更導致頁面被回收時被觸發，最后，總結一下ViewModel與onSaveIntanceState方法區別：
- onSaveIntanceState
onSaveIntanceState只能存盤輕量級的 key-value 鍵值對資料，非配置變更導致的頁面被回收時才會觸發，此時資料存盤在 ActivityRecord 中；
- ViewModel
ViewModel可以存放任意 Object 資料，因配置變更導致的頁面被回收才有效，此時存在ActivityThread#ActivityClientRecord 中，
Github原始碼：ExampleJetpack
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/276313.html
標籤：AI