Android Jetpack之ViewModel

于 2019-04-21 11:10:14 发布
阅读量796 收藏
点赞数
分类专栏： jetpack
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingyunxiaohai/article/details/89429946
版权
ViewModel概念

ViewModel是用来保存应用UI数据的类，会在配置变更后继续存在（比如旋转屏幕），我们知道当手机旋转的时候，Activity会被销毁重建，里面的数据都会丢失，或导致界面崩溃，以前我们解决这个问题一般重写onSaveInstanceState方法来保存一些关键数据，在onCreate或者onRestoreInstanceState方法中恢复数据，但此方法仅适用于可以序列化然后反序列化的少量数据，而不适用于潜在的大量数据

使用了ViewModel就不用这么麻烦了，在旋转屏幕的时候它不会被销毁,而且ViewMode中也可以保存相对大一点的数据。

另外遵守单一职责的原则，Activity应该只负责显示视图，数据的请求操作部分交给别的管理类去做ViewModel就可以完成这个任务

当然ViewModel并不能完全替代onSaveInstanceState，当进程被关闭的时候，ViewModel会被销毁，而onSaveInstanceState并会。

ViewModel简单使用

比如我们一个请求接口的示例

public class NameViewModel1 extends ViewModel {

    private MutableLiveData<String> currentName;

    public MutableLiveData<String> getCurrentName() {
        if (currentName == null) {
            currentName = new MutableLiveData<String>();
            loadData();
        }
        return currentName;
    }

    private void loadData() {
        OkGo.<String>get("http://gank.io/api/xiandu/categories")
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(Response<String> response) {
                        Gson gson = new Gson();
                        Catefories catefories = gson.fromJson(response.body(), Catefories.class);
                        currentName.postValue(catefories.getResults().get(0).getName());
                    }
                });
    }
}

在ViewModel中请求接口，将返回值赋值给MutableLiveData，然后在Activity中绑定这个LiveData即可，如下


public class NameActivity extends AppCompatActivity {
    private NameViewModel1 mViewModel;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_name);

        final TextView textView = findViewById(R.id.tv_name);
        mViewModel = ViewModelProviders.of(this).get(NameViewModel1.class);

        mViewModel.getCurrentName().observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                textView.setText(s);
            }
        });
    }
}

这样当ViewModel请求完数据之后，Activity中的TextView就会自动被赋值了。当Activity结束后，系统框架层会自动调用ViewModel的onCleared()方法来清理资源。

注意永远不要把Activity，View，Fragment的引用传入ViewModel中。比如前面我们知道当旋转屏幕的时候ctivity会被销毁然后重建，这时候ViewModel没被销毁，但是它还持有者以前被销毁的Activity的引用，这就会造成内存泄露。

如果 ViewModel需要 Application上下文，可以使用ViewModel的子类AndroidViewModel，它里面会有Application的上下文对象

ViewModel的生命周期

ViewModel对象的作用域是在获取ViewModel时传递给ViewModelProvider的生命周期。它会一直存在，直到Lifecycle告诉它该关闭了，比如activity finish了，或者fragment detached了。

通常情况下ViewModel在系统第一次创建一个activity的时候，在其onCreate()方法中创建，在activity的整个活动周期中可能会调用onCreate()方法多次，比如旋转屏幕，ViewModel会一直存在，直到这个activity完全退出和销毁。

在不同的fragment之间共享数据

activity中两个fragment之前互相通信也是比较常见的，使用ViewModel可以很好的共享数据

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 onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {
            model.select(item);
        });
    }
}

public class DetailFragment extends Fragment {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        model.getSelected().observe(this, { item ->
           // Update the UI.
        });
    }
}

可以看到，两个Fragment都是把他们所依赖的activity传入ViewModelProvider中，那么他们所获取到的ViewModel也是同一个。此ViewModel的生命周期也限制在这个activity的范围内。

这样做的好处：

  1. activity不用做任何事情，也不需要了解两个fragment之间的沟通
  2. 两个fragment之间除了它们共享的ViewModel，别的都不需要彼此关心，即使有一个fragment崩溃了，另一个依然会正常工作
  3. 每个fragment都有自己的生命周期，互相不影响。

ViewModel可以结合LiveData和Room,可以让UI和数据中数据同步，这可以替换以前的CursorLoader。

OK，上面大部分都是官方文档的翻译，看完就知道ViewModel的简单使用了，下面来看看其源码看看内部实现

前面我们知道ViweModel的初始化方法是这样：ViewModelProviders.of(this).get(NameViewModel1.class)，下面从of开始。

   public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        return of(activity, null);
    }
    public static ViewModelProvider of(@NonNull FragmentActivity activity,
            @Nullable Factory factory) {
        Application application = checkApplication(activity);
        if (factory == null) {
            factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
        }
        return new ViewModelProvider(activity.getViewModelStore(), factory);
    }

fragment也有类似的上面两个方法，这里是从activity中调用的。

  • 调用of方法，传入当前的activity或者fragment，
  • 然后调用了两个参数的重载方法，传入的第二个参数Factory为null
  • 因为为null,所以通过activity获取到当前的Application对象，然后创建出当前的工厂（factory）
  • 最后创建一个ViewModelProvider对象，两个参数，当前activity相关联的ViewModelStore和factory。

这俩参数是干啥的，一个一个来，先看第一个参数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.");
        }
        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;
    }

看看Activity中的NonConfigurationInstances对象是不是空，如果不是给mViewModelStore赋值，如果mViewModelStore还未null，创建一个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());
    }

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

ViewModelStore里面有个HashMap对象用来存储ViewModel。

在看这个工厂AndroidViewModelFactory

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

AndroidViewModelFactory，是ViewModelProvider的静态内部类，getInstance获取它的单例。create中，可以看到，通过反射创建出一个Class对象。其实就是我们自己写的ViewModel类

OK到这里of方法就看完了，其实就是创建了一个ViewModelProvider对象，创建这个对象需要传入一个保存ViewModel的ViewModelStore类和一个工厂类，这个工厂有个create方法可以通过反射创建相应的Class对象。

下面来看get方法

    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");
        }
        return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
    }

找到全类名，然后拼接上一个默认的key，之后调用get的两个参数重载方法

    public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        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;
    }

通过key到mViewModelStore中寻找ViewModel，如果找到了并且是ViewModel类型的，就返回，如果没找到，调用工厂的create方法创建一个，并保存到ViewModelStore中，最后返回这个viewModel

OK到这里ViewModel的源码就看完啦，总结一下ViewModel是通过ViewModelprovider中的AndroidViewModelFactory这个工厂创建的，创建完成后完成后保存在ViewModelStore中。

前面看文档我们知道，当手机屏幕旋转的时候，activity重建，但是ViewModel中的数据不丢失，这是怎么实现的呢？

搜了一些博客都是是说创建了一个HolderFragment ，创建的时候调用了setRetainInstance(true)方法，这个方法可以保证activity销毁的时候这个HolderFragment不会重建，从而保证数据不会丢失。

应该是版本不同的原因，我现在看的是androidx中的源码，并没有发现这个HolderFragment，那它是怎么保证数据不丢失的呢

现在回到getViewModelStore()方法中，看到在那ViewModelStore的实例的时候，先去NonConfigurationInstances中那，拿不到才创建。

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

可以看到它是Activity的静态内部类，在activity创建时执行attach方法的时候被赋值，那么它的生命周期就跟这个Activity就没有关系了，Activity销毁了它也可能存在当Activity重新创建的时候,在FragmentActivity的onCreate中可以看到下面

 protected void onCreate(@Nullable Bundle savedInstanceState) {
        mFragments.attachHost(null /*parent*/);

        super.onCreate(savedInstanceState);

        NonConfigurationInstances nc =
                (NonConfigurationInstances) getLastNonConfigurationInstance();
        if (nc != null && nc.viewModelStore != null && mViewModelStore == null) {
            mViewModelStore = nc.viewModelStore;
        }
     ......
 }

如果NonConfigurationInstances不为null，并且它中的viewModelStore也不为null,activity中的mViewModelStore为null的时候，会把NonConfigurationInstances中的viewModelStore的值赋值给mViewModelStore，所以数据也就没丢失了。

chsmy2018
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值