如果把Activity比喻成一栋大房子，LiveData就好比一个个家丁，那ViewModel就是那个大管家，他管理着房子的大大小小的事务和每个家丁的日常工作。
ViewModel的设计目的可以概况成以下几点：

1.维护Activity的数据不随着Activity的各种生命异常而丢失，比如手机的横竖屏切换的时候；

2.承担起Activity控制层的作用，让Activity的代码不至于太膨胀，便于维护；

3.在作用域可控的情况下管理各种异步请求和数据的生命敏感事件。

这就是谷歌给开发者的一套标准的开发app的指导方案，很权威，很nice，用完你会感叹相见恨晚。
先来看看ViewModel的创建，继承ViewModel即可：

class MainViewModel : ViewModel() {
    // 维护了一个liveData
    private val testLiveData = MutableLiveData(0)
    // get方法只返回liveData，这样就实现了liveData的读写分离，在viewModel里更改，activity里读取
    fun getTestLiveData(): LiveData<Int> {
        return testLiveData
    }
}

怎么实例化呢，官方不推荐直接new出来，而是这样：

class MainActivity : AppCompatActivity() {
    private lateinit var mainViewModel: MainViewModel
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 官方推荐的实例化方式
        mainViewModel = ViewModelProvider(this).get(MainViewModel::class.java)
   
    }
}

那就从ViewModelProvider开始入手，看看ViewModel是基于什么原理设计和维护的，先看看ViewModelProvider的构造方法和get方法：

public class ViewModelProvider {
    // 维护了两个成员变量，实际上也都是他们俩在做事
    private final Factory mFactory; // 创建ViewModel实例的工厂
    private final ViewModelStore mViewModelStore; // 字面意思就是ViewModel存储类
    //
    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);
    } 
    // ViewModelStoreOwner是个接口，字面意思是ViewModelStore拥有者，根据谷歌jetpack代码命名规律也能猜到它的作用是能提供
   //ViewModelStore ，我们在上面的示例传入了自身Activity this，说明父类实现了ViewModelStoreOwner接口。
    public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
        // ComponentActivity也实现了HasDefaultViewModelProviderFactory，下面我们把它相关方法也贴出来
        this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
                ? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
                : NewInstanceFactory.getInstance());
    }
    // 最终给两个成员变量完成了赋值
    public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
        mFactory = factory;
        mViewModelStore = store;
    }


     @NonNull
    @MainThread
    public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
        String canonicalName = modelClass.getCanonicalName();
        // 检查类的合法性
        if (canonicalName == null) {
            throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
        }
        //  key加了DEFAULT_KEY 拼装起来
        return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
    }


    @NonNull
    @MainThread
    public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        // 先从mViewModelStore里取，这里猜测应该是个缓存
        ViewModel viewModel = mViewModelStore.get(key);
        // 如果是ViewModel的子类对象并且mFactory是OnRequeryFactory子类对象
        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.
            }
        }
        // 用相应的工厂创建ViewModel实例
        if (mFactory instanceof KeyedFactory) {
            viewModel = ((KeyedFactory) mFactory).create(key, modelClass);
        } else {
            viewModel = mFactory.create(modelClass);
        }
        // 放入缓存
        mViewModelStore.put(key, viewModel);
        return (T) viewModel;
    }
  ...略
}

ViewModelProvider的两个成员变量mViewModelStore 和mFactory 分别来自ComponentActivity的getViewModelStore()和getDefaultViewModelProviderFactory() 方法：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ...
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory，
        SavedStateRegistryOwner {

    @NonNull
    @Override
    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.");
        }
        // 这个方法就是创建了一个ViewModelStore赋值给了mViewModelStore
        ensureViewModelStore();
        return mViewModelStore;
    }

    @NonNull
    @Override
    public final SavedStateRegistry getSavedStateRegistry() {
        return mSavedStateRegistryController.getSavedStateRegistry();
    }

    @NonNull
    @Override
    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.");
        }
        if (mDefaultFactory == null) {
            // 创建的是SavedStateViewModelFactory，看命名是保存状态的vm工厂，注意这个构造函数穿了些啥
            mDefaultFactory = new SavedStateViewModelFactory(
                    getApplication(),
                    this,
                    getIntent() != null ? getIntent().getExtras() : null);
        }
        return mDefaultFactory;
    }
}

// ViewModelStore 专门用来存储ViewModel
public class ViewModelStore {
    // 熟悉的存储方式，map
    private final HashMap<String, ViewModel> mMap = new HashMap<>();
    // 存储
    final void put(String key, ViewModel viewModel) {
        ViewModel oldViewModel = mMap.put(key, viewModel);
        // 如果之前存储了相同的，执行一下onCleared方法
        if (oldViewModel != null) {
            oldViewModel.onCleared();
        }
    }
    // 取缓存
    final ViewModel get(String key) {
        return mMap.get(key);
    }
    
    Set<String> keys() {
        return new HashSet<>(mMap.keySet());
    }

    /**
     *  清除所有的viewModel
     */
    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.clear();
        }
        // 注意会执行viewModel的clear方法
        mMap.clear();
    }
}

注意：其实到这里你基本应该已经知道了ViewModel是怎么被创建和保存起来的了，以下内容只是探寻ViewModel究竟是怎么被实例化的，提前透露一下就是用类名通过newInstance()实例化的。

现在做个小总结：ViewModel如果通过ViewModelProvider的get方法实例化的话，同一个Activity（ViewModelStoreOwner）里只会实例化一个实例然后缓存到ViewModelStore里，每次获取的时候是会先取缓存，所以保证了同一个ViewModel的唯一性！

再来看SavedStateViewModelFactory:

public final class SavedStateViewModelFactory extends ViewModelProvider.KeyedFactory {
    private final Application mApplication;
    private final ViewModelProvider.Factory mFactory; // 实际是这个工厂在创建vm实例
    private final Bundle mDefaultArgs;
    private final Lifecycle mLifecycle; // 维护了一个lifecycle
    private final SavedStateRegistry mSavedStateRegistry; // 所谓的保存状态应该跟这个有关

   
    public SavedStateViewModelFactory(@Nullable  Application application,
            @NonNull SavedStateRegistryOwner owner) {
        this(application, owner, null);
    }
    @SuppressLint("LambdaLast")
    public SavedStateViewModelFactory(@Nullable Application application,
            @NonNull SavedStateRegistryOwner owner,
            @Nullable Bundle defaultArgs) {
        mSavedStateRegistry = owner.getSavedStateRegistry();
        mLifecycle = owner.getLifecycle();
        mDefaultArgs = defaultArgs;
        mApplication = application;
        // 前面调用这个构造函数是传下来了application的，所以这里执行的是
        // ViewModelProvider.AndroidViewModelFactory.getInstance(application)
        mFactory = application != null
                ? ViewModelProvider.AndroidViewModelFactory.getInstance(application)
                : ViewModelProvider.NewInstanceFactory.getInstance();
    }
    // 这里是ViewModelProvider里创建viewModel调用的方法
    @NonNull
    @Override
    public <T extends ViewModel> T create(@NonNull String key, @NonNull Class<T> modelClass) {
        // 我们创建一般的ViewModel，不是继承自AndroidViewModel，所以是false
        boolean isAndroidViewModel = AndroidViewModel.class.isAssignableFrom(modelClass);
        Constructor<T> constructor;
        if (isAndroidViewModel && mApplication != null) {
            constructor = findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE);
        } else {
            // 所以会命中这里，去找匹配的构造函数，这个方法在下面
            constructor = findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE);
        }
        // doesn't need SavedStateHandle 
       //不需要SavedStateHandle ，至于需要的情况那是另外的应用场景，可以单独去了解
        if (constructor == null) {
            // 绕了半天，其实还是执行了这个创建方法，我们继续看AndroidViewModelFactory
            return mFactory.create(modelClass);
        }
        // 这里的逻辑是关于SavedStateHandle ，暂不细看
        SavedStateHandleController controller = SavedStateHandleController.create(
                mSavedStateRegistry, mLifecycle, key, mDefaultArgs);
        try {
            T viewmodel;
            if (isAndroidViewModel && mApplication != null) {
                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());
        }
    }
@NonNull
    @Override
    public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
        // ViewModelProvider calls correct create that support same modelClass with different keys
        // If a developer manually calls this method, there is no "key" in picture, so factory
        // simply uses classname internally as as key.
        String canonicalName = modelClass.getCanonicalName();
        if (canonicalName == null) {
            throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
        }
        return create(canonicalName, modelClass);
    }

    private static final Class<?>[] ANDROID_VIEWMODEL_SIGNATURE = new Class[]{Application.class,
            SavedStateHandle.class};
    private static final Class<?>[] VIEWMODEL_SIGNATURE = new Class[]{SavedStateHandle.class};

    @SuppressWarnings("unchecked")
    private static <T> Constructor<T> findMatchingConstructor(Class<T> modelClass,
            Class<?>[] signature) {
        for (Constructor<?> constructor : modelClass.getConstructors()) {
             // 这里会去找入参是SavedStateHandle类型的构造函数，显然我们一般的
            //ViewModel是没有这个构造函数的，这里会返回null，我们继续回到上面
            Class<?>[] parameterTypes = constructor.getParameterTypes();
            if (Arrays.equals(signature, parameterTypes)) {
                return (Constructor<T>) constructor;
            }
        }
        return null;
    }

    @Override
    void onRequery(@NonNull ViewModel viewModel) {
        attachHandleIfNeeded(viewModel, mSavedStateRegistry, mLifecycle);
    }
}

 public open class AndroidViewModelFactory( private val application: Application) : NewInstanceFactory() {
       // 通过上面的分析我们知道是调用了这个方法来创建ViewModel的
        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            // 上面我们也分析过我们的viewModel不是AndroidViewModel的子类
            return if (AndroidViewModel::class.java.isAssignableFrom(modelClass)) {
                try {
                    modelClass.getConstructor(Application::class.java).newInstance(application)
                } catch (e: NoSuchMethodException) {
                    throw RuntimeException("Cannot create an instance of $modelClass", e)
                } catch (e: IllegalAccessException) {
                    throw RuntimeException("Cannot create an instance of $modelClass", e)
                } catch (e: InstantiationException) {
                    throw RuntimeException("Cannot create an instance of $modelClass", e)
                } catch (e: InvocationTargetException) {
                    throw RuntimeException("Cannot create an instance of $modelClass", e)
                }
            // 所以最终是调用了父类的create方法，下面接着看父类NewInstanceFactory
            } else super.create(modelClass)
        }

    }

  public open class NewInstanceFactory : Factory {
        @Suppress("DocumentExceptions")
        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            return try {
                // 好嘛，最后就是简单的反射创建的
                modelClass.newInstance()
            } catch (e: InstantiationException) {
                throw RuntimeException("Cannot create an instance of $modelClass", e)
            } catch (e: IllegalAccessException) {
                throw RuntimeException("Cannot create an instance of $modelClass", e)
            }
        }
    ...略
}