架构设计原则

要遵循的最重要的原则是
分离关注点，也就是解藕，遵循单一职责原则。一种常见的错误是在一个 Activity 或 Fragment 中编写所有代码。这些基于界面的类应仅包含处理界面和操作系统互动的逻辑。应尽可能使这些类保持精简，这样可以避免许多与生命周期相关的问题。

请注意，并不拥有 Activity 和 Fragment 的实现；这些只是表示 Android 操作系统与应用之间关系的粘合类。操作系统可能会根据用户互动或因内存不足等系统条件随时销毁它们。为了提供令人满意的用户体验和更易于管理的应用维护体验，最好尽量减少对它们的依赖。

通过模型驱动界面（最好是持久性模型）。模型是负责处理应用数据的组件。它们独立于应用中的 View 对象和应用组件，因此不受应用的生命周期以及相关的关注点的影响。
持久性是理想之选，原因如下：

• 如果 Android 操作系统销毁应用以释放资源，您的用户就不会丢失数据。
• 当网络连接不稳定或不可用时，应用会继续工作。
  应用所基于的模型类应明确定义数据管理职责，这样将使应用更可测试且更一致。
  整体架构设计 可直接查看：https://developer.android.com/jetpack/docs/guide
  MVVM.png

基于这样几个原因，所以MVVM模型完全符合，通过Model和View以及Controller的分离，来进行职责划分，直接映射到代码边界的划分和约束；那么Model和View的连接通信，则是通过事件进行驱动，也就是通过观察者模式监控数据的变更来驱动View视图的刷新。

Google ViewModel

ViewModel中主要定义了资源的释放的方法，使用者可以重写onClean()方法，在里面进行资源的释放；

public abstract class ViewModel {
    private final Map<String, Object> mBagOfTags = new HashMap<>();
    private volatile boolean mCleared = false;
    protected void onCleared() {
    }
    @MainThread
    final void clear() {
        mCleared = true;
        if (mBagOfTags != null) {
            synchronized (mBagOfTags) {
                for (Object value : mBagOfTags.values()) {
                    closeWithRuntimeException(value);
                }
            }
        }
        onCleared();
    }
  private static void closeWithRuntimeException(Object obj) {
        if (obj instanceof Closeable) {
            try {
                ((Closeable) obj).close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class AndroidViewModel extends ViewModel {
    private Application mApplication;
    public AndroidViewModel(@NonNull Application application) {
        mApplication = application;
    }
    @NonNull
    public <T extends Application> T getApplication() {
        return (T) mApplication;
    }
}

ViewModel 的创建

ViewModel的职责是进行业务数据的处理，而fragment、activity作为Controller，所以VM中尽量不要包含Activity或者Fragment的Context，而VM是可以复用并聚焦于数据处理，如果VM中引用了上下文，既降低了复用的性，又需要维护Context的生命周期，以防内存泄漏。
以下代码基于androidx

public class UserModel extends ViewModel {
  private final MutableLiveData<User> userLiveData = new MutableLiveData<>();
  public LiveData<User> getUser() {
      return userLiveData;
  }
  public UserModel() {
      // trigger user load.
  }
  void doAction() {
      // depending on the action, do necessary business logic calls and update the
      // userLiveData.
  }

1. 通过构造创建ViewModel，new UserModel(applicationContext);
   • 对象实例化不可控；
   • VM不易做缓存，VM需要重建时都要创建新的对象，并且要重新填充VM中之前的数据状态；
   • VM需要自己做生命周期联动；
2. 通过ViewModelProvider工厂模式创建，new ViewModelProvider.AndroidViewModelFactory(applicationContext).create(UserModel.class);
   创建VM规范化，工厂化，方便管理和扩展；
   但是无法持久化VM和生命周期联动；
3. 通过ViewModelProvider创建，new ViewModelProvider(componentActivity, new ViewModelProvider.AndroidViewModelFactory(applicationContext)).get(UserModel.class);
   工厂模式创建，Provider中通过 ComponentActivity来获取ViewModelStore，ViewModelStore中使用HashMap默认以Class.getCanonicalName为key，存储VM实例，以此来达到和传入的Activity或者Fragment进行VM的关联持久化；
   但是没有实现生命周期联动；
4. 通过ViewModelProviders创建，ViewModelProviders.of(componentActivity).get(UserModel.class);
ViewModelProviders内部维护了VM和Activity或者Fragment的生命周期联动，并用工厂模式创建；下面会分析下VM的持久化和生命联动。

ViewModel创建详解 ViewModelProviders.of(componentActivity).get(UserModel.class);

//获取VMProvider 
public static ViewModelProvider of(@NonNull FragmentActivity activity, @Nullable Factory factory) {
        //检查Activity或者Fragment有效性
        Application application = checkApplication(activity);
        //如果没有指定VM工厂，则创建默认的AndroidViewModel工厂，只能生产继承自AndroidViewModel的VM
        if (factory == null) { 
            factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
        }
        //创建VMProvider，并从Activity或者Fragment中获取VMStore，VMStore就是用来持久化的
        return new ViewModelProvider(activity.getViewModelStore(), factory);
}
//检查Activity或者Fragment有效性，是否是应用正常创建的视图
private static Application checkApplication(Activity activity) {
        Application application = activity.getApplication();
        if (application == null) {
            throw new IllegalStateException("Your activity/fragment is not yet attached to Application. You can't request ViewModel before onCreate call.");
        }
        return application;
}
//获取Activity绑定的VMStore
public ViewModelStore getViewModelStore() {
        //和checkApplication作用相同
        if (getApplication() == null) {
            throw new IllegalStateException("Your activity is not yet attached to the  Application instance. You can't request ViewModel before onCreate call.");
        }
        //判断当前Activity或者Fragment是不是重建的，如果是，则从上次保存的配置中进行恢复
        if (mViewModelStore == null) {
            NonConfigurationInstances nc =  (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                // Restore the ViewModelStore from NonConfigurationInstances
                mViewModelStore = nc.viewModelStore;
            }
            if (mViewModelStore == null) {
                mViewModelStore = new ViewModelStore();
            }
        }
        return mViewModelStore;
}
//The function will be called between {@link #onStop} and {@link #onDestroy}
//源码太多就不贴了，写个调用链
//onRetainNonConfigurationInstance()-->Activity.retainNonConfigurationInstances()
//-->ActivityThread.performDestroyActivity()-->LocalActivityManager.performDestroy()
public final Object onRetainNonConfigurationInstance() {
        Object custom = onRetainCustomNonConfigurationInstance();
        ViewModelStore viewModelStore = mViewModelStore;
        if (viewModelStore == null) {
            // No one called getViewModelStore(), so see if there was an existing
            // ViewModelStore from our last NonConfigurationInstance
            NonConfigurationInstances nc =  (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                viewModelStore = nc.viewModelStore;
            }
        }
        if (viewModelStore == null && custom == null) {
            return null;
        }
        NonConfigurationInstances nci = new NonConfigurationInstances();
        nci.custom = custom;
        nci.viewModelStore = viewModelStore;
        return nci;
}

ViewModel 的持久化

ViewModelStore中用Map集合默认以ViewModel的类名为key存储ViewModel，并且根据上面的分析，在activity的stop或者destroy时会保存ViewModelStore，这种调用比较特殊，例如Activity不是正常关闭的，或者relaunchActivity时，也就是会保存ViewModel，并在恢复时重建ViewModel；

ViewModel 的生命周期联动

在Activity或者Fragment的Destroy时，会调用ViewModel的clear()；防止内存泄漏；