Jetpack核心組件，ViewModel的使用及原理解析

時間  2019-11-07
標籤 jetpack 核心 組件 viewmodel 使用 原理 解析 简体版
原文   原文鏈接

前言

ViewModel旨在以生命週期意識的方式存儲和管理用戶界面相關的數據，它能夠用來管理Activity和Fragment中的數據。還能夠拿來處理Fragment與Fragment之間的通訊等等。android

當Activity或者Fragment建立了關聯的ViewModel，那麼該Activity或Fragment只要處於活動狀態，那麼該ViewModel就不會被銷燬，即便是該Activity屏幕旋轉時重建了。因此也能夠拿來作數據的暫存。面試

ViewModel主要是拿來獲取或者保留Activity/Fragment所須要的數據的，開發者能夠在Activity/Fragment中觀察ViewModel中的數據更改(這裏須要配合LiveData食用)。小程序

ViewModel只是用來管理UI的數據的,千萬不要讓它持有View、Activity或者Fragment的引用(當心內存泄露)。緩存

本文以由淺入深的方式學習ViewModel。性能優化

ViewModel的使用

引入ViewModel

//引入AndroidX吧,替換掉support包
implementation 'androidx.appcompat:appcompat:1.0.2'

def lifecycle_version = "2.0.0"
// ViewModel and LiveData
implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
複製代碼

簡單使用起來bash

定義一個User數據類。網絡

class User implements Serializable {

    public int age;
    public String name;

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' + '}'; } } 複製代碼

而後引出咱們今天的主角ViewModel。架構

public class UserModel extends ViewModel {

    public final MutableLiveData<User> mUserLiveData = new MutableLiveData<>();

    public UserModel() {
        //模擬從網絡加載用戶信息
        mUserLiveData.postValue(new User(1, "name1"));
    }

    //模擬 進行一些數據騷操做
    public void doSomething() {
        User user = mUserLiveData.getValue();
        if (user != null) {
            user.age = 15;
            user.name = "name15";
            mUserLiveData.setValue(user);
        }
    }

}
複製代碼

這時候在Activity中就可使用ViewModel了。其實就是一句代碼簡單實例化，而後就可使用ViewModel了。app

//這些東西我是引入的androidx下面的
import androidx.fragment.app.FragmentActivity;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProviders;

public class MainActivity extends FragmentActivity {

    private TextView mContentTv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mContentTv = findViewById(R.id.tv_content);

        //構建ViewModel實例
        final UserModel userModel = ViewModelProviders.of(this).get(UserModel.class);

        //讓TextView觀察ViewModel中數據的變化,並實時展現
        userModel.mUserLiveData.observe(this, new Observer<User>() {
            @Override
            public void onChanged(User user) {
                mContentTv.setText(user.toString());
            }
        });

        findViewById(R.id.btn_test).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //點擊按鈕  更新User數據  觀察TextView變化
                userModel.doSomething();
            }
        });
    }
}
複製代碼

這個時候，咱們點擊一下按鈕(user中的age變爲15)，咱們能夠旋轉手機屏幕(這個時候其實Activity是從新建立了，也就是onCreate()方法被再次調用，可是ViewModel實際上是沒有從新建立的，仍是以前那個ViewModel)，可是當咱們旋轉以後,發現TextView上顯示的age竟然仍是15，這就是ViewModel的魔性所在。這個就不得不提ViewModel的生命週期了，它只有在Activity銷燬以後，它纔會自動銷燬(因此別讓ViewModel持有Activity引用啊，會內存泄露的)。 下面引用一下谷歌官方的圖片，將ViewModel的生命週期展現的淋漓盡致。 框架

ViewModel妙用1: Activity與Fragment"通訊"

有了ViewModel,Activity與Fragment能夠共享一個ViewModel，由於Fragment是依附在Activity上的，在實例化ViewModel時將該Activity傳入ViewModelProviders，它會給你一個該Activity已建立好了的ViewModel，這個Fragment能夠方便的訪問該ViewModel中的數據。在Activity中修改userModel數據後,該Fragment就能拿到更新後的數。

ViewModel妙用2: Fragment與Fragment"通訊"

下面咱們來看一個例子(Google官方例子)

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.
        });
    }
}
複製代碼
  1. 首先定義一個ViewModel，在裏面放點數據。

二、而後在MasterFragment和DetailFragment均可以拿到該ViewModel，拿到了該ViewModel就能夠拿到裏面的數據了，至關於間接經過ViewModel通訊了。so easy…

ViewModel源碼解析

咱們從下面這句代碼start.

final UserModel userModel = ViewModelProviders.of(this).get(UserModel.class);
複製代碼

咱們跟着ViewModelProviders.of(this)打開新世界的大門。

ViewModelProviders.of(this) 方法

/**
 * 用於構建一個ViewModelProvider,當Activity是alive時它會保留全部的該Activity對應的ViewModels.
 */
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
    return of(activity, null);
}

@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity,
        @Nullable Factory factory) {
    //檢查application是否爲空,不爲空則接收
    Application application = checkApplication(activity);
    if (factory == null) {
        //構建一個ViewModelProvider.AndroidViewModelFactory
        factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
    }
    return new ViewModelProvider(activity.getViewModelStore(), factory);
}
複製代碼

ViewModelProviders裏面的of()函數實際上是爲了方便咱們構建一個ViewModelProvider。而ViewModelProvider，一看名字就知道幹啥的了，就是提供ViewModel的。

Factory是ViewModelProvider的一個內部接口，它的實現類是拿來構建ViewModel實例的。它裏面只有一個方法,就是建立一個ViewModel。

/**
 * Implementations of {@code Factory} interface are responsible to instantiate ViewModels.
 */
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);
}
複製代碼

Factory有2個實現類：一個是NewInstanceFactory，一個是AndroidViewModelFactory。

NewInstanceFactory源碼

public static class NewInstanceFactory implements Factory {

        @SuppressWarnings("ClassNewInstance")
        @NonNull
        @Override
        public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
            //noinspection TryWithIdenticalCatches
            try {
                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);
            }
        }
    }
複製代碼

NewInstanceFactory專門用來實例化那種構造方法裏面沒有參數的class，而且ViewModel裏面是不帶Context的，而後它是經過newInstance()去實例化的。

AndroidViewModelFactory 源碼

public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {

    private static AndroidViewModelFactory sInstance;

    /**
     * Retrieve a singleton instance of AndroidViewModelFactory.
     *
     * @param application an application to pass in {@link AndroidViewModel}
     * @return A valid {@link AndroidViewModelFactory}
     */
    @NonNull
    public static AndroidViewModelFactory getInstance(@NonNull Application application) {
        if (sInstance == null) {
            sInstance = new AndroidViewModelFactory(application);
        }
        return sInstance;
    }

    private Application mApplication;

    /**
     * Creates a {@code AndroidViewModelFactory}
     *
     * @param application an application to pass in {@link AndroidViewModel}
     */
    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專門用來實例化那種構造方法裏面有參數的class，而且ViewModel裏面多是帶Context的。

它是經過newInstance(application)去實例化的。若是有帶application參數則是這樣實例化。

若是沒有帶application參數的話，則仍是會走newInstance()方法去構建實例。

AndroidViewModelFactory經過構造方法給ViewModel帶入Application，就能夠在ViewModel裏面拿到Context，由於Application是APP全局的，那麼不存在內存泄露的問題，完美解決了有些ViewModel裏面須要Context引用，可是又擔憂內存泄露的問題。

下面咱們繼續ViewModelProviders.of(this)方法繼續分析吧，注意最後一句new ViewModelProvider(activity.getViewModelStore()， factory);第一個參數會調用activity的getViewModelStore()方法(這個方法會返回ViewModelStore，這個類是拿來存儲ViewModel的,下面會說到),這裏的activity是androidx.fragment.app.FragmentActivity，看一下這個getViewModelStore()方法。

/**
 * 獲取這個Activity相關聯的ViewModelStore
 */
@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.");
    }
    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在橫豎屏切換時悄悄保存了viewModelStore
//注意,這是FragmentActivity中的NonConfigurationInstances(其實Activity中還定義了一個NonConfigurationInstances,內容要比這個多一些,可是因爲沒有關係到它,這裏就不說起了)
static final class NonConfigurationInstances {
    Object custom;
    ViewModelStore viewModelStore;
    FragmentManagerNonConfig fragments;
}
複製代碼

Android橫豎屏切換時會觸發onSaveInstanceState()，而還原時會調用onRestoreInstanceState()，可是Android的Activity類還有2個方法名爲onRetainNonConfigurationInstance()和getLastNonConfigurationInstance()這兩個方法。

來具體看看這2個素未謀面的方法。

/**
 保留全部fragment的狀態。你不能本身覆寫它！若是要保留本身的狀態，請使用onRetainCustomNonConfigurationInstance（）
 這個方法在FragmentActivity裏面
 */
@Override
public final Object onRetainNonConfigurationInstance() {
    Object custom = onRetainCustomNonConfigurationInstance();

    FragmentManagerNonConfig fragments = mFragments.retainNestedNonConfig();

    if (fragments == null && mViewModelStore == null && custom == null) {
        return null;
    }

    NonConfigurationInstances nci = new NonConfigurationInstances();
    nci.custom = custom;
    nci.viewModelStore = mViewModelStore;
    nci.fragments = fragments;
    return nci;
}


//這個方法在Activity裏面,而mLastNonConfigurationInstances.activity實際就是就是上面方法中年的nci
public Object getLastNonConfigurationInstance() {
    return mLastNonConfigurationInstances != null
            ? mLastNonConfigurationInstances.activity : null;
}
複製代碼

咱們來看看getLastNonConfigurationInstance()的調用時機,

protected void onCreate(@Nullable Bundle savedInstanceState) {
    ......
    super.onCreate(savedInstanceState);

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

沒想到吧,Activity在橫豎屏切換時悄悄保存了viewModelStore，放到了NonConfigurationInstances實例裏面，橫豎屏切換時保存了又恢復了回來，至關於ViewModel實例就還在啊，也就避免了橫豎屏切換時的數據丟失。

viewModelProvider.get(UserModel.class)

下面咱們來到那句構建ViewModel代碼的後半段，它是ViewModelProvider的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);
}

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.
        }
    }

    //無緩存  則從新經過mFactory構建
    viewModel = mFactory.create(modelClass);
    //緩存起來
    mViewModelStore.put(key, viewModel);
    //noinspection unchecked
    return (T) viewModel;
}
複製代碼

大致思路是利用一個key來緩存ViewModel，有緩存則用緩存的,沒有則從新構建。構建時使用的factory是上面of()方法的那個factory。

ViewModelStore

上面多個地方用到了ViewModelStore，它其實就是一個普普統統的保存ViewModel的類。

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

    /**
     *  Clears internal storage and notifies ViewModels that they are no longer used.
     */
    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.onCleared();
        }
        mMap.clear();
    }
}
複製代碼

ViewModelStore有一個HashMap專門用於存儲,普通吧。

下面看看什麼時候調用的clear()。

ViewModel.onCleared() 資源回收

既然ViewModel是生命週期感知的，那麼什麼時候應該清理ViewModel呢？

咱們來到FragmentActivity的onDestroy()方法，發現它是在這裏清理的。

/**
 * Destroy all fragments.
 */
@Override
protected void onDestroy() {
    super.onDestroy();

    if (mViewModelStore != null && !isChangingConfigurations()) {
        mViewModelStore.clear();
    }

    mFragments.dispatchDestroy();
}
複製代碼

再看 ViewModel

不少朋友可能就要問了,ViewModel究竟是什麼?

public abstract class ViewModel {
    /**
     * 這個方法會在ViewModel即將被銷燬時調用,能夠在這裏清理垃圾
     */
    @SuppressWarnings("WeakerAccess")
    protected void onCleared() {
    }
}
複製代碼

其實很簡單,就一個抽象類,裏面就一個空方法??? 我擦,搞了半天,原來ViewModel不是主角…

AndroidViewModel

ViewModel有一個子類,是AndroidViewModel.它裏面有一個Application的屬性,僅此而已,爲了方便在ViewModel裏面使用Context。

public class AndroidViewModel extends ViewModel {
    @SuppressLint("StaticFieldLeak")
    private Application mApplication;

    public AndroidViewModel(@NonNull Application application) {
        mApplication = application;
    }

    /**
     * Return the application.
     */
    @SuppressWarnings("TypeParameterUnusedInFormals")
    @NonNull
    public <T extends Application> T getApplication() {
        //noinspection unchecked
        return (T) mApplication;
    }
}
複製代碼

小結

ViewModel 的源碼其實很少，理解起來比較容易，主要是官方FragmentActivity提供了技術實現，onRetainNonConfigurationInstance（）保存狀態，getLastNonConfigurationInstance()恢復。

原來Activity還有這麼2個玩意兒，以前我還只是知道onSaveInstanceState()和onRestoreInstanceState()，漲姿式了。

想學習更多Android知識，或者獲取相關資料請加入Android開發交流羣：1018342383。 有面試資源系統整理分享，Java語言進階和Kotlin語言與Android相關技術內核，APP開發框架知識， 360°Android App全方位性能優化。Android前沿技術，高級UI、Gradle、RxJava、小程序、Hybrid、 移動架構師專題項目實戰環節、React Native、等技術教程！架構師課程、NDK模塊開發、 Flutter等全方面的 Android高級實踐技術講解。還有在線答疑

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程