ViewModel 源码解析

ViewModel 概述

ViewModel 类旨在以注重生命周期的方式存储和管理界面的数据，让数据可以在发生屏幕旋转等配置更改后继续保留。它还处理界面与应用其他部分的通信（例如，调用业务逻辑类）。界面应该能够观察ViewModel 中的更改，通常通过LiveData 或者 DataBinding 公开此信息，它决不能拥有界面的引用。

ViewModel 源码解析

public abstract class ViewModel {
    // Can't use ConcurrentHashMap, because it can lose values on old apis (see b/37042460)
    @Nullable
    private final Map<String, Object> mBagOfTags = new HashMap<>();
    private volatile boolean mCleared = false;

    /**
     * ViewModel 被清除是会调用这个方法
     * 我们可以重写这个方法在里面做一些回收工作
     */
    @SuppressWarnings("WeakerAccess")
    protected void onCleared() {
    }

    @MainThread
    final void clear() {
        mCleared = true;
        if (mBagOfTags != null) {
            synchronized (mBagOfTags) {
                for (Object value : mBagOfTags.values()) {
                    // see comment for the similar call in setTagIfAbsent
                    closeWithRuntimeException(value);
                }
            }
        }
        onCleared();
    }

    
    @SuppressWarnings("unchecked")
    <T> T setTagIfAbsent(String key, T newValue) {
        T previous;
        synchronized (mBagOfTags) {
            previous = (T) mBagOfTags.get(key);
            if (previous == null) {
                mBagOfTags.put(key, newValue);
            }
        }
        T result = previous == null ? newValue : previous;
        if (mCleared) {
            closeWithRuntimeException(result);
        }
        return result;
    }

    /**
     * Returns the tag associated with this viewmodel and the specified key.
     */
    @SuppressWarnings({"TypeParameterUnusedInFormals", "unchecked"})
    <T> T getTag(String key) {
        if (mBagOfTags == null) {
            return null;
        }
        synchronized (mBagOfTags) {
            return (T) mBagOfTags.get(key);
        }
    }

    private static void closeWithRuntimeException(Object obj) {
        if (obj instanceof Closeable) {
            try {
                ((Closeable) obj).close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
复制代码

可以看到 ViewModel 的源码其实很简单，就是维护mBagOfTags 这个HashMap和clear() 这个函数。接着我们看下clear() 在哪里被调用

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 的clear() 里面被调用了。可以看到ViewModelStore 这个类就是管理ViewModel。而ViewModelStore 的clear()是在Activity 的构造方法中被调用

    public ComponentActivity() {
        //省略代码...
        getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_DESTROY) {
                    if (!isChangingConfigurations()) {
                        getViewModelStore().clear();
                    }
                }
            }
        });
        //省略代码...
    }

复制代码

当Activity onDistroy 的时候且不是更改配置的情况下就会调用 getViewModelStore().clear() 这样ViewModel 就会被清除。
接着我们看下是谁把ViewModel put 进来的。

public class ViewModelProvider {
    private static final String DEFAULT_KEY =
            "androidx.lifecycle.ViewModelProvider.DefaultKey";
    //省略代码...

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

    @SuppressWarnings("unchecked")
    @NonNull
    @MainThread
    public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        ViewModel viewModel = mViewModelStore.get(key);

        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.
            }
        }
        if (mFactory instanceof KeyedFactory) {
            viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
        } else {
            viewModel = (mFactory).create(modelClass);
        }
        mViewModelStore.put(key, viewModel);
        return (T) viewModel;
    }
    
    //省略代码...

}
复制代码

可以看到get方法大致就是如果存在就直接返回，如果没有就创建有个ViewModel保存并返回。这里用到了mViewModelStore、mFactory 两个对象，这两个对象ViewModelProvider 类在构造方法中实例化的，我们接着看下它的构造方法。

public class ViewModelProvider {
    //省略代码...
    private final Factory mFactory;
    private final ViewModelStore mViewModelStore;
    //构造函数1
    public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
        this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
                ? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
                : NewInstanceFactory.getInstance());
    }
   
    public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull Factory factory) {
        this(owner.getViewModelStore(), factory);
    }
   
    public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
        mFactory = factory;
        mViewModelStore = store;
    }
    //省略代码...
}
复制代码

我们通常用的都是“构造函数1” 需要传入ViewModelStoreOwner 对象，这是一个接口类

@SuppressWarnings("WeakerAccess")
public interface ViewModelStoreOwner {
    /**
     * Returns owned {@link ViewModelStore}
     *
     * @return a {@code ViewModelStore}
     */
    @NonNull
    ViewModelStore getViewModelStore();
}
复制代码

我们使用的时候传入的是Activity/Fragment，所以可知 Activity/Fragment 都实现了这个接口。
可以看到 “owner instanceof HasDefaultViewModelProviderFactory” 说明同时还可能实现了HasDefaultViewModelProviderFactory 这个接口。

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
复制代码

果然是这样的，这里我们就先看下HasDefaultViewModelProviderFactory 这个接口

public interface HasDefaultViewModelProviderFactory {
    /**
     * Returns the default {@link ViewModelProvider.Factory} that should be
     * used when no custom {@code Factory} is provided to the
     * {@link ViewModelProvider} constructors.
     *
     * @return a {@code ViewModelProvider.Factory}
     */
    @NonNull
    ViewModelProvider.Factory getDefaultViewModelProviderFactory();
}
复制代码

接这个我们看下Activity 对ViewModelStoreOwner、HasDefaultViewModelProviderFactory 接口方法的实现

    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) {
                //恢复viewModelStore
                mViewModelStore = nc.viewModelStore;
            }
            if (mViewModelStore == null) {
                mViewModelStore = new ViewModelStore();
            }
        }
        return mViewModelStore;
    }
    
    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) {
            mDefaultFactory = new SavedStateViewModelFactory(
                    getApplication(),
                    this,
                    getIntent() != null ? getIntent().getExtras() : null);
        }
        return mDefaultFactory;
    }

复制代码

我们先看 getViewModelStore() 正常情况下在第一次调用时创建实例，下次调用直接获取。NonConfigurationInstances 这个类主要作用是，在发生屏幕旋转等配置更改会将一些需要保存的实例放在这里面，并传递给下一个Activity(恢复的Activity)，这样就能保证这些实例在这种情况下无需重新创建；比如ViewModelStore

getDefaultViewModelProviderFactory() 第一次调用的时候会创建一个SavedStateViewModelFactory 对象。顾名思义，就是 保存状态的ViewModel工厂，代码就不带大家看了。主要逻辑就是如果不需要 SavedStateHandle 就是通过反射创建一个ViewModel 对象。需要
SavedStateHandle 的情况大家可以看下这篇文章 www.jianshu.com/p/731ca4282…

小结

以上我们从ViewModel 的源码反向推倒知道了 ViewModel 的创建、恢复以及清除的过程。

因此我们也知道了，为什么Activity 在发生屏幕旋转等配置更改时ViewModel 没有重新创建；ViewModel 的生命周期为什么要比Activity 长一点。还不知道的同学可以重新看一遍。