本文會基于最新版ViewModel使用方法與源碼進行詳細分析，從注冊到實現ViewModel界面數據如何保存與管理全部涉及。

**

簡介：

**ViewModel是JetPack系列庫之一，它用來對組件的界面數據進行管理，且當組件的狀態發生改變時數據依然留存。

優點：1.當所依賴組件的狀態發生改變時，例如屏幕旋轉等，界面數據不會發生改變
2.實現MVVM架構的基礎，在日常開發中，ViewModel就是MVVM架構的VM層，它相當于MVP架構的present，我們可以將業務邏輯以及數據交互的部分放入ViewModel中。

源碼分析：

版本：viewmodel:1.1.1
此處使用的示例代碼與livedata源碼分析的相同，不影響流程分析

首先構造一個繼承于ViewModel的類

接著創建一個factory 實例傳入ViewModelProvider(this,factory )中去并調用get方法將我們的ViewModel作為參數傳入。
此處需要注意的是在以前的版本中直接通過 ViewModelProviders.of(this).get()方法來完成這個操作的。在最新的版本中已經取消了of方法，并且構造方法必須要傳入2個參數

查看ViewModelProvider的構造方法可看出構造ViewModelProvider時必須傳入2個參數才行，其中第一個參數為ViewModelStore，第二個參數為factory,
ViewModelStore用來存儲和管理ViewModel，factory則用來對ViewModel進行實例化。此時構建ViewModelProvider時傳入的參數為所依賴的組件的ViewModelStore，也就是說，我們通過組件的ViewModelStore來對ViewModel進行存儲和管理。

其中factory需要我們在構造的時候進行傳入，ViewModelProvider給我們提供了3種實例化的方法，分別是簡單工廠模式構造，通過反射構造實例，以及我們自己實現factory構造實例。

當我們使用ViewModelProvider.NewInstanceFactory()構造實例時，查看源碼可看出，它實現了Factory 接口，并且在其內部的create方法中會調用我們在之前get方法中傳入的viewmodel的newInstance方法。這個方法需我們自己在viewmodel中去實現，用來返回viewmodel實例，如果實例化出錯則會拋出異常

   public static class NewInstanceFactory implements Factory {

        @SuppressWarnings("ClassNewInstance")
        @NonNull
        @Override
        public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
            //noinspection TryWithIdenticalCatches
            try {
            //返回modelClass實例對象
                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);
            }
        }
    }

使用AndroidViewModelFactory 方式反射生成ViewModel，該Factory使用單例模式進行構建 ，所以它的生命周期等同于應用程序的生命周期，且只有一個實例，推薦使用此模式來獲取factory，當它的create方法被調用時，會通過application利用反射創建一個ViewModel實例并返回。

  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) {
            if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
                //noinspection TryWithIdenticalCatches
                try {
                //通過反射創建viewmodel
                    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);
                }
            }
            return super.create(modelClass);
        }
    }

第三種方式就是直接實現Factory接口，并自己實現create方法，我們需要在該create方法內，返回viewmodel的實例

  /**
     * Implementations of {@code Factory} interface are responsible to instantiate ViewModels.
     */
    public interface Factory {
        /**
         * Creates a new instance of the given {@code Class}.
         * <p>
         *
         * @param modelClass a {@code Class} whose instance is requested
         * @param <T>        The type parameter for the ViewModel.
         * @return a newly created ViewModel
         */
        @NonNull
        <T extends ViewModel> T create(@NonNull Class<T> modelClass);
    }

當我們在構造ViewModelProvider時，會將我們傳入的這2個參數進行保存,

   public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
        mFactory = factory;
        mViewModelStore = store;
    }

當我們調用get方法時

    public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
    //獲取到ViewModel的類名
        String canonicalName = modelClass.getCanonicalName();
        if (canonicalName == null) {
            throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
        }
        //再次進行回調
        return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
    }

在該方法內首先會從ViewModelStore中通過key去獲取ViewModel ，這個key就是上面的DEFAULT_KEY +類名。如果找到則直接返回，否則調用factory的create方法創建ViewModel實例放入ViewModelStore進行管理和保存并返回該實例

    public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
    //從ViewModelStore中獲取viewModel 
        ViewModel viewModel = mViewModelStore.get(key);
	//如果找到則直接返回
        if (modelClass.isInstance(viewModel)) {
            //noinspection unchecked
            return (T) viewModel;
        } else {
            //noinspection StatementWithEmptyBody
            if (viewModel != null) {
                // TODO: log a warning.
            }
        }
      
        if (mFactory instanceof KeyedFactory) {
            viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
        } else {
            viewModel = (mFactory).create(modelClass);
        }
        mViewModelStore.put(key, viewModel);
        //noinspection unchecked
        return (T) viewModel;
    }

ViewModelStore 內部通過hashmap來對viewmodel進行管理，

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());
    }

    /**
     *  Clears internal storage and notifies ViewModels that they are no longer used.
     */
    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.clear();
        }
        mMap.clear();
    }
}

到此處為止源碼部分分析完畢，如何觸發viewmodel對組件界面的狀態保存繼續分析

上面說過在構建ViewModelProvider時傳入的ViewModelStore來自于構建它所傳入的this,也就是當前組件，我們知道ViewModelStore起到了對viewmodel的管理作用，viewmodel的獲取和存儲都是通過它來完成。

    public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull Factory factory) {
    在這里調用了組件的owner.getViewModelStore()方法
        this(owner.getViewModelStore(), factory);
    }

追蹤getViewModelStore方法，發現它是一個ViewModelStoreOwner 接口中的一個方法

public interface ViewModelStoreOwner {
    /**
     * Returns owned {@link ViewModelStore}
     *
     * @return a {@code ViewModelStore}
     */
    @NonNull
    ViewModelStore getViewModelStore();
}

這里發現它的實現類有很多個，我們一般在ViewModelProvider中傳入的是fragment或者activity，而fragment其實最終也是調用的activity的getViewModelStore方法這里查看activity如何處理。

發現在activity的父類ComponentActivity中有這個方法的實現，通過getViewModelStore去獲取一個ViewModelStore ，當ViewModelStore 獲取為空時，會調用getLastNonConfigurationInstance方法去恢復狀態改變前的NonConfigurationInstances，和這個方法對應的是onRetainNonConfigurationInstance，該方法會在組件狀態改變時去保存數據信息，由系統調用。

   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.");
        }
        //如果當前組件的mViewModelStore 為空，則從NonConfigurationInstances 中去獲取
        if (mViewModelStore == null) {
        //返回之前
            NonConfigurationInstances nc =
                    (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                // Restore the ViewModelStore from NonConfigurationInstances
                mViewModelStore = nc.viewModelStore;
            }
            //如果在NonConfigurationInstances 中沒有找到，則創建一個新的ViewModelStore并保存起來
            if (mViewModelStore == null) {
                mViewModelStore = new ViewModelStore();
            }
        }
        return mViewModelStore;
    }

在代碼中ViewModelStore會從NonConfigurationInstances 中去嘗試獲取，我們查看viewModelStore的賦值時機即可

  static final class NonConfigurationInstances {
        Object custom;
        ViewModelStore viewModelStore;
    }

查看發現它的賦值時機就是在onRetainNonConfigurationInstance中完成的，也就是說在組件的狀態發生改變時，會去嘗試獲取viewModelStore，并將viewModelStore保存在NonConfigurationInstances 中并返回。
也就是在onRetainNonConfigurationInstance中會對viewModelStore進行保存，在getLastNonConfigurationInstance中會對viewModelStore進行恢復

具體流程：
當我們在activity中去實例化ViewModelProvider時，所依賴的activity在其內部會調用getViewModelStore方法去獲取一個ViewModelStore，如果沒有則創建一個，并保存起來，然后調用ViewModelProvider.get方法將我們的viewmodel實例通過ViewModelStore進行保存管理，當我們的activity的狀態發生改變，如旋轉屏幕，此時系統會調用onRetainNonConfigurationInstance方法，在這個方法內會將我們的ViewModelStore進行保存。

我們一般會搭配livedata來使用viewmodel，livedata常用來存儲與界面相關的數據元素，當我們的activity狀態改變后，界面再次從livedata中獲取界面數據時，由于livedata實例由viewmodel保管，而viewmodel存儲在ViewModelStore中，當前activity去獲取ViewModelStore時會通過getLastNonConfigurationInstance方法恢復之前的ViewModelStore，所以狀態改變前后的ViewModelStore是同一個，所以數據沒有發生任何改變，從而界面相關數據不會發生丟失。