Android LiveData 使用详解

时间 2019-12-08

原文原文链接

说在前面

本次推出 Android Architecture Components 系列文章，目前写好了四篇，主要是关于 lifecycle，livedata 的使用和源码分析，其他的 Navigation， Paging library，Room，WorkMannager 等春节结束以后会更新，欢迎关注个人公众号，有更新的话会第一时间会在公众号上面通知。javascript

Android lifecycle 使用详解java

Android LiveData 使用详解android

Android lifecyle 源码解剖git

Android livedata 源码解剖github

github sample 地址： ArchiteComponentsSample网络

Android 技术人，一位不羁的码农。ide

前言

在上一篇博客中，咱们讲解了 lifecycle 的使用及优势。这篇博客让咱们一块儿来了解一下 LiveData 是怎样使用的？函数

为何要引进 LiveData

LiveData 是一个能够被观察的数据持有类，它能够感知 Activity、Fragment或Service 等组件的生命周期。简单来讲，他主要有一下优势。源码分析

它能够作到在组件处于激活状态的时候才会回调相应的方法，从而刷新相应的 UI。
不用担忧发生内存泄漏
当 config 致使 activity 从新建立的时候，不须要手动取处理数据的储存和恢复。它已经帮咱们封装好了。
当 Actiivty 不是处于激活状态的时候，若是你想 livedata setValue 以后当即回调 obsever 的 onChange 方法，而不是等到 Activity 处于激活状态的时候才回调 obsever 的 onChange 方法，你可使用 observeForever 方法，可是你必须在 onDestroy 的时候 removeObserver。

回想一下，在你的项目中，是否是常常会碰到这样的问题，当网络请求结果回来的时候，你常常须要判断 Activity 或者 Fragment 是否已经 Destroy，若是不是 destroy，才更新 UI。而当你若是使用 Livedata 的话，由于它是在 Activity 处于 onStart 或者 onResume 的状态时，他才会进行相应的回调，于是能够很好得处理这个问题，没必要谢一大堆的 activity.isDestroyed()。接下来，让咱们一块儿来看一下 LiveData 的使用post

LiveData 使用

基本使用

引入相关的依赖包

// ViewModel and LiveData
implementation "android.arch.lifecycle:extensions:1.1.0"
// alternatively, just ViewModel
implementation "android.arch.lifecycle:viewmodel:1.1.0"
// alternatively, just LiveData
implementation "android.arch.lifecycle:livedata:1.1.0"
复制代码

在代码中使用

LiveData 是一个抽象类，它的实现子类有 MutableLiveData ，MediatorLiveData。在实际使用中，用得比较多的是 MutableLiveData。他经常结合 ViewModel 一块儿使用。下面，让咱们一块儿来看一下怎样使用它？

首先，咱们先写一个类继承咱们的 ViewModel，里面持有 mNameEvent。

public class TestViewModel extends ViewModel {

    private MutableLiveData<String> mNameEvent = new MutableLiveData<>();

    public MutableLiveData<String> getNameEvent() {
        return mNameEvent;
    }

}
复制代码

接着，咱们在 Activity 中建立 ViewModel，并监听 ViewModel 里面 mNameEvent 数据的变化，当数据改变的时候，咱们打印相应的 log，并设置给 textView，显示在界面上。这样咱们就完成了对 mNameEvent 数据源的观察。

mTestViewModel = ViewModelProviders.of(this).get(TestViewModel.class);
MutableLiveData<String> nameEvent = mTestViewModel.getNameEvent();
nameEvent.observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable String s) {
        Log.i(TAG, "onChanged: s = " + s);
        mTvName.setText(s);
    }
});
复制代码

最后当咱们数据源改变的时候，咱们须要调用 livedata 的 setValue 或者 postvalue 方法。他们之间的区别是，调用 setValue 方法，Observer 的 onChanged 方法会在调用 serValue 方法的线程回调。而 postvalue 方法，Observer 的 onChanged 方法将会在主线程回调。

mTestViewModel.getNameEvent().setValue(name);
复制代码

可能部分同窗有这样的疑问了，咱们的 ViewModel 是经过 ViewModelProviders.of(this).get(TestViewModel.class); 方法建立出来的，若是咱们要携带参数，怎么办？

其实，官方也替咱们考虑好了，一样是调用 ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) 方法，只不过，须要多传递一个 factory 参数。

Factory 是一个接口，它只有一个 create 方法。

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 接口，重写 create 方法，在create 方法里面调用相应的构造函数，返回相应的实例。

public class TestViewModel extends ViewModel {

    private final String mKey;
    private MutableLiveData<String> mNameEvent = new MutableLiveData<>();

    public MutableLiveData<String> getNameEvent() {
        return mNameEvent;
    }

    public TestViewModel(String key) {
        mKey = key;
    }

    public static class Factory implements ViewModelProvider.Factory {
        private String mKey;

        public Factory(String key) {
            mKey = key;
        }

        @Override
        public <T extends ViewModel> T create(Class<T> modelClass) {
            return (T) new TestViewModel(mKey);
        }
    }

    public String getKey() {
        return mKey;
    }
}
复制代码

ViewModelProviders.of(this, new TestViewModel.Factory(mkey)).get(TestViewModel.class)

自定义 Livedata

Livedata 主要有几个方法

observe
onActive
onInactive
observeForever

void observe (LifecycleOwner owner, Observer observer)

Adds the given observer to the observers list within the lifespan of the given owner. The events are dispatched on the main thread. If LiveData already has data set, it will be delivered to the observer.

void onActive ()

Called when the number of active observers change to 1 from 0. This callback can be used to know that this LiveData is being used thus should be kept up to date.

当回调该方法的时候，表示该 liveData 正在背使用，所以应该保持最新

void onInactive ()

Called when the number of active observers change from 1 to 0. This does not mean that there are no observers left, there may still be observers but their lifecycle states aren't STARTED or RESUMED (like an Activity in the back stack). You can check if there are observers via hasObservers().

当该方法回调时，表示他全部的 obervers 没有一个状态处理 STARTED 或者 RESUMED，注意，这不表明没有 observers。

Void observeForever

跟 observe 方法不太同样的是，它在 Activity 处于 onPause ，onStop， onDestroy 的时候，均可以回调 obsever 的 onChange 方法，可是有一点须要注意的是，咱们必须手动 remove obsever，不然会发生内存泄漏。

这里咱们以观察网络状态变化为例子讲解

首先咱们自定义一个 Class NetworkLiveData，继承 LiveData，重写它的 onActive 方法和 onInactive 方法
在 onActive 方法中，咱们注册监听网络变化的广播，即ConnectivityManager.CONNECTIVITY_ACTION。在 onInactive 方法的时候，咱们注销广播。

public class NetworkLiveData extends LiveData<NetworkInfo> {

    private final Context mContext;
    static NetworkLiveData mNetworkLiveData;
    private NetworkReceiver mNetworkReceiver;
    private final IntentFilter mIntentFilter;

    private static final String TAG = "NetworkLiveData";

    public NetworkLiveData(Context context) {
        mContext = context.getApplicationContext();
        mNetworkReceiver = new NetworkReceiver();
        mIntentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
    }

    public static NetworkLiveData getInstance(Context context) {
        if (mNetworkLiveData == null) {
            mNetworkLiveData = new NetworkLiveData(context);
        }
        return mNetworkLiveData;
    }

    @Override
    protected void onActive() {
        super.onActive();
        Log.d(TAG, "onActive:");
        mContext.registerReceiver(mNetworkReceiver, mIntentFilter);
    }

    @Override
    protected void onInactive() {
        super.onInactive();
        Log.d(TAG, "onInactive: ");
        mContext.unregisterReceiver(mNetworkReceiver);
    }

    private static class NetworkReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            ConnectivityManager manager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo activeNetwork = manager.getActiveNetworkInfo();
            getInstance(context).setValue(activeNetwork);

        }
    }
}
复制代码

这样，当咱们想监听网络变化的时候，咱们只须要调用相应的 observe 方法便可，方便又快捷。

NetworkLiveData.getInstance(this).observe(this, new Observer<NetworkInfo>() {
    @Override
    public void onChanged(@Nullable NetworkInfo networkInfo) {
        Log.d(TAG, "onChanged: networkInfo=" +networkInfo);
    }
});

复制代码

www.jianshu.com/p/4b7945475…

共享数据

Fragment Activity 之间共享数据

咱们回过头来再来看一下 ViewModelProvider 的 of 方法，他主要有四个方法，分别是

ViewModelProvider of(@NonNull Fragment fragment)
ViewModelProvider of(@NonNull FragmentActivity activity)
ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory)
ViewModelProvider of(@NonNull FragmentActivity activity, @Nullable Factory factory)

1,2 方法之间的主要区别是传入 Fragment 或者 FragmentActivity。而咱们知道，经过 ViewModel of 方法建立的 ViewModel 实例，对于同一个 fragment 或者 fragmentActivity 实例，ViewModel 实例是相同的，于是咱们能够利用该特色，在 Fragment 中建立 ViewModel 的时候，传入的是 Fragment 所依附的 Activity。于是他们的 ViewModel 实例是相同的，从而能够作到共享数据。

// LiveDataSampleActivity(TestFragment 依赖的 Activity）
mTestViewModel = ViewModelProviders.of(this, new TestViewModel.Factory(mkey)).get(TestViewModel.class);
MutableLiveData<String> nameEvent = mTestViewModel.getNameEvent();
nameEvent.observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable String s) {
        Log.i(TAG, "onChanged: s = " + s);
        mTvName.setText(s);
    }
});


// TestFragment 中
mViewModel = ViewModelProviders.of(mActivity).get(TestViewModel.class);
mViewModel.getNameEvent().observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable String s) {
        Log.d(TAG, "onChanged: s =" + s + " mViewModel.getKey() =" + mViewModel.getKey());
        mTvName.setText(s);
        boolean result = mViewModel == ((LiveDataSampleActivity) mListener).mTestViewModel;
        Log.d(TAG, "onChanged: s result =" + result);
    }
});
复制代码

这样，LiveDataSampleActivity 和 TestFragment 中的 ViewModel 是同一个实例。即 Activity 和 Fragment 共享数据。

全局共享数据

说到全局共享数据，咱们想一下咱们的应用全景，好比说个人帐户数据，这个对于整个 App 来讲，确定是全局共享的。有时候，当咱们的数据变化的时候，咱们须要通知咱们相应的界面，刷新 UI。若是用传统的方式来实现，那么咱们通常才采起观察者的方式来实现，这样，当咱们须要观察数据的时候，咱们须要添加 observer，在界面销毁的时候，咱们须要移除 observer。

可是，若是咱们用 LiveData 来实现的话，它内部逻辑都帮咱们封装好了，咱们只须要保证 AccountLiveData 是单例的就ok，在须要观察的地方调用 observer 方法便可。也不须要手动移除 observer，不会发生内存泄漏，方便快捷。

这里 AccountLiveData 的实现就不贴出来了，能够参考上面的 NetworkLiveData 实现

小结

这里说一点关于 LiveData 与 ViewModel 的应用场景吧，我尽可能说得通俗一点，不要说得那么官方，这样对新手很难理解。以为不错的，请点个赞，让咱们看到大家的欢呼声。大家的支持就是我写做的最大动力。

LiveData 内部已经实现了观察者模式，若是你的数据要同时通知几个界面，能够采起这种方式
咱们知道 LiveData 数据变化的时候，会回调 Observer 的 onChange 方法，可是回调的前提是 lifecycleOwner（即所依附的 Activity 或者 Fragment）处于 started 或者 resumed 状态，它才会回调，不然，必须等到 lifecycleOwner 切换到前台的时候，才回调。所以，这对性能方面确实是一个不小的提高。可是，对于你想作一些相似与在后台工做的（黑科技）， liveData 就不太适合了，你可使用 observeForever 方法，或者本身实现观察者模式去吧。

Lifecycle，LiveData， ViewModel 的基本使用到此已经讲解完毕，想了解他们的实现原理的话能够阅读这两篇文章。

Android lifecyle 源码解剖

Android livedata 源码解剖

github sample 地址： ArchiteComponentsSample