依赖引用：
def lifecycle_version = "2.2.0"
// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
// ViewModel
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
ViewModel是google提供的jetpack 架构中的用于管理activity、fragment界面相关数据的，同时也可以用于activity和fragment、fragment和fragment之间的数据通信。
ViewModel的使用比较简单，创建一个类继承自 ViewModel，在需要使用的activity或fragment进行实例化就可以了。
public class MyViewModel extends ViewModel {
public int number=0;
public MyViewModel(){
}
@Override
protected void onCleared() {
super.onCleared();
//当不再使用ViewModel时，会调用该方法
}
}
注意：如果ViewModel需要构造函数时，需要将其权限修饰符设置为public，否则在初始化时会报错；如果在ViewModel中涉及到需要使用上下文时，可以继承AndroidViewModel类，在起构造方法中需要传入一个Application实例，
public class MyApplicationViewModel extends AndroidViewModel {
public MyApplicationViewModel(@NonNull Application application) {
super(application);
}
}
在activity中的使用：
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//实例化对应的viewModel
MyViewModel viewModel = new ViewModelProvider(this).get(MyViewModel.class);
//设置value
viewModel.number = 1;
//获取value
int mun = viewModel.number;
}
}
注意：ViewModel的实例方式有两种方式，不过最终调用的都是一种；
//实例化对应的viewModel
//方式一：
MyViewModel viewModel = new ViewModelProvider(this).get(MyViewModel.class);
//方式二：
MyViewModel viewModel=ViewModelProviders.of(this).get(MyViewModel.class);
不过第二种方式在使用的时候发现已经过时了，使用起来是不是感觉比较简单，使用完了，就去看看ViewModel的生命周期还有源码吧。
生命周期
viewmodel-lifecycle.png
ViewModel 对象存在的时间范围是获取 ViewModel 时传递给 ViewModelProvider 的 Lifecycle。ViewModel 将一直留在内存中，直到限定其存在时间范围的 Lifecycle 永久消失：对于 Activity，是在 Activity 完成时；而对于 Fragment，是在 Fragment 分离时；从图中可以看到，即使在activity发生横竖屏切换，activity重新创建后，数据依然可以保存在ViewModel中，并且ViewModel中可保存任意类型的数据，且不受大小限制，这比activity onSaveInstanceState 回调中Bundle要方便很多，在onCleared方法可以可以清除一些资源的引用，释放内存。
注意：ViewModel 绝不能引用视图、Lifecycle 或可能存储对 Activity 上下文的引用的任何类
activity、fragment之间的参数传递
public class SharedViewModel extends ViewModel {
private final MutableLiveData<Item> selected = new MutableLiveData<Item>();
public void select(Item item) {
selected.setValue(item);
}
public LiveData<Item> getSelected() {
return selected;
}
}
public class MasterFragment extends Fragment {
private SharedViewModel model;
public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
itemSelector.setOnClickListener(item -> {
model.select(item);
});
}
}
public class DetailFragment extends Fragment {
public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
SharedViewModel model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
model.getSelected().observe(getViewLifecycleOwner(), { item ->
// Update the UI.
});
}
}
保持ViewModel实例化是传入的activity或者说上下文一致时，就可以实现activity和fragment、fragment和fragment之间的数据共享了
源码分析：
上面说了下ViewModel的简单使用、生命周期及activity、fragment之间的数据共享，接下来就看看ViewModel的源码吧。
在activity中使用时，是通过创建ViewModelProvider实例并调用其get方法就可以获取到要使用的ViewModel实例，ViewModelProvider就是一个提供ViewModel的工具类。
MyViewModel myViewModel = new ViewModelProvider(this).get(MyViewModel.class);
public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
//第一个参数会获取一个ViewModerStore实例
//第二个参数获取一个Factory实现类的实例 如果系统存在默认的就使用默认的Factory 没有就使用创建好的NewInstanceFactory实例
this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance());
}
ViewModelStore是用来存储创建好的ViewModel实例，Factory实现类实例则是用来创建ViewModel实例的，这时这两个对象实例都已经创建好了，然后调用get方法，传入的是当前ViewModel的Class字节码。
@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");
}
//DEFAULT_KEY 系统统一的key
return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}
private static final String DEFAULT_KEY =
"androidx.lifecycle.ViewModelProvider.DefaultKey";
创建好的ViewModel实例会存储在ViewModelStore实例中的HashMap中的，
@NonNull
@MainThread
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
//从ViewModelStore实例中的HashMap中获取ViewModel实例 第一次获取到的肯定是null的
ViewModel viewModel = mViewModelStore.get(key);
if (modelClass.isInstance(viewModel)) {
if (mFactory instanceof OnRequeryFactory) {
((OnRequeryFactory) mFactory).onRequery(viewModel);
}
//非第一次后 直接从ViewModelStore 中的HashMap中直接获取到ViewModel实例
return (T) viewModel;
} else {
//noinspection StatementWithEmptyBody
if (viewModel != null) {
// TODO: log a warning.
}
}
//通过Factory实现类对象根据对应的Class字节码创建ViewModel实例对象
if (mFactory instanceof KeyedFactory) {
viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
} else {
viewModel = (mFactory).create(modelClass);
}
//将创建好的ViewModel实例添加到HashMap中
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
ViewModelStore中对ViewModel的存储就是通过HashMap来实现的，
public class ViewModelStore {
private final HashMap<String, ViewModel> mMap = new HashMap<>();
final void put(String key, ViewModel viewModel) {
//存储最新的ViewModel
ViewModel oldViewModel = mMap.put(key, viewModel);
if (oldViewModel != null) {
//会将之前ViewModel中的内存释放掉
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的创建则是通过对应的Class字节码的newInstance来创建的，
public static class NewInstanceFactory implements Factory {
private static NewInstanceFactory sInstance;
/**
* Retrieve a singleton instance of NewInstanceFactory.
*
* @return A valid {@link NewInstanceFactory}
*/
@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) {
//noinspection TryWithIdenticalCatches
try {
//创建ViewModel实例
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);
}
}
}
到这里ViewModel的创建和存储就完成了，通过google的描述ViewModel是有生命周期的，并且在Activity销毁时，会清除掉缓存的ViewModel实例。
生命周期：
在activity中使用ViewModel时，创建ViewModelProvider实例要求传入一个ViewModelStoreOwner实现类对象，发现传入this就可以了，说明activity中有实现ViewModelStoreOwner接口，一找发现ComponentActivity实现了ViewModelStoreOwner接口，并在构造方法中对生命周期进行了监听。
public ComponentActivity() {
Lifecycle lifecycle = getLifecycle();
//noinspection ConstantConditions
if (lifecycle == null) {
throw new IllegalStateException("getLifecycle() returned null in ComponentActivity's "
+ "constructor. Please make sure you are lazily constructing your Lifecycle "
+ "in the first call to getLifecycle() rather than relying on field "
+ "initialization.");
}
if (Build.VERSION.SDK_INT >= 19) {
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_STOP) {
Window window = getWindow();
final View decor = window != null ? window.peekDecorView() : null;
if (decor != null) {
decor.cancelPendingInputEvents();
}
}
}
});
}
getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
if (!isChangingConfigurations()) {
//如果不是因为配置改变导致的onDestory 会调用ViewModelStore中的clear方法，清除掉缓存的ViewModel实例
getViewModelStore().clear();
}
}
}
});
if (19 <= SDK_INT && SDK_INT <= 23) {
getLifecycle().addObserver(new ImmLeaksCleaner(this));
}
}
这样就保证了Activity销毁时，释放掉对应ViewModel中缓存的数据，保证内存的释放。
