前言

在上一节中，我们学习了ViewModel,我们使用的是接口来完成ViewModel与页面之间的通信，其实这并不是好的方案。这篇博客，就让我们来了解LiveData与ViewModel是如何配合工作的。

LiveData介绍

LivaData是一个可被观察的数据容器类。具体来说，可以将LiveData理解为一个数据的容器，它将数据包装起来，使数据成为观察者，当该数据发生变化时，观察者能够获得通知。与常规的可观察类不同，LiveData可以感知(如Activity、Fragment或Service)的生命周期。

简单来说，LiveData具有如下优势

LiveData 遵循观察者模式。当生命周期状态发生变化时，LiveData 会通知 Observer 对象，可以在这些Observer对象中更新界面
不会发送内存泄露
如果观察者的生周期处于非活跃状态(如返回栈中的Activity),则它不会接收任何LivaData事件，但是，当非活跃状态变成活跃状态时会立刻接收最新的数据（后台的Activity返回前台时）
当config导致Activity/Fragment重建时，不需要再手动的管理数据的存储与恢复。

LiveData和ViewModel的关系

ViewModel用于存放页面所需要的各种数据，对页面来说，它并不关心ViewModel中的业务逻辑，它只关心需要展示的数据是什么，并且希望再数据发送变化时，能及时得到通知并做出更新。LiveData的作用就是，在ViewModel中的数据发生变化时通知页面，用于包装ViewModel中那些需要被外界观察的数据。在这里插入图片描述

LiveData基本使用

在上篇博客中的ViewModel的计时器案例的基础上，我们使用LiveData对接口进行改写

1.LiveData是一个抽象类，不能直接使用。我们通常使用的是它的直接子类MutableLiveData,代码如下

public class LiveDataViewModel extends ViewModel {
   
   
    private MutableLiveData<Integer> currentSecond;
    private Timer timer;
    private  int current;

    @Override
    protected void onCleared() {
   
   
        super.onCleared();
        //释放资源
        timer.cancel();
    }

    public LiveData<Integer> getCurrentSecond(){
   
   
        if(currentSecond == null){
   
   
            currentSecond = new MutableLiveData<>();
        }
        return  currentSecond;
    }

    //开始定时器
    public  void startTiming(){
   
   
        if(timer == null){
   
   
            current = 0;
            timer = new Timer();
            TimerTask timerTask = new TimerTask() {
   
   
                @Override
                public void run() {
   
   
                    if(currentSecond!=null){
   
   
                        currentSecond.postValue(current++);
                    }
                }
            };
            timer.schedule(timerTask,1000,1000);
        }
    }

    //关闭定时器
    public  void stopTiming(){
   
   
        timer.cancel();
    }
}

当开始定时器的时候，也就是我们数据资源发生变化的时候，我们需要调用livedata.postvalue方法，通知页面我们数据源已经发生了改变。至于为什么不用livedata.setValue方法，等下我们会说到。

2.接着我们在Activity中创建ViewModel,并监听ViewModel里面currentSecond数据的变化。

public class LiveDataActivity extends AppCompatActivity {
   
   

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

        iniComponent();
    }

    private void iniComponent() {
   
   
        //通过ViewModelProvider得到ViewModel
        final LiveDataViewModel viewModel = new ViewModelProvider(this).get(LiveDataViewModel.class);

        //得到ViewModel中的LiveData
        final MutableLiveData<Integer> liveData = (MutableLiveData<Integer>) viewModel.getCurrentSecond();

        //通过liveData.observer()观察ViewModel中数据的变化
        liveData.observe(this, new Observer<Integer>() {
   
   
            @Override
            public void onChanged(Integer integer) {
   
   
                //收到回调后更新UI界面
                TextView tv = findViewById(R.id.tv_texts);
                tv.setText("小鑫啊"+integer);
            }
        });

        //关闭定时器
        findViewById(R.id.btnReset).setOnClickListener(new View.OnClickListener() {
   
   
            @Override
            public void onClick(View v) {
   
   
                //通过LiveData.setValue()/LiveData.postValue()
                //完成对ViewModel中数据的更新
                liveData.setValue(0);
                //关闭定时器
                viewModel.stopTiming();
            }
        });

        //计时开始
        viewModel.startTiming();

    }
}

在页面中，通过LiveData.observe()方法对LivaData所包装的数据进行观察。当我们数据源发生变化了(也就是我们想修改LivaData所包装的数据时)，就可以通过LiveData.postValue/LiveData.setValue()来完成，然后onChanged方法就会收到我们修改之后的数据，我们就可以对UI进行更改了.

需要注意的是:postValue()方法用在非UI线程中,而setValue()方法用在UI线程中，这就是为什么我们在开始定时器的时候，需要调用postVaule()发送数据了(因为定时器是运行在非UI线程的).
在这里插入图片描述

运行结果如下:
在这里插入图片描述
LivaData的基本使用就到这里，是不是很简单啊! 接下来，就让我们来探讨下LiveData的原理吧!!!

LiveData的原理

我们知道LiveData是通过观察者模式实现的。当数据发送改变的时候,会回调Observer的onChanged(),接下来就让我们深入Observer方法的源码一探究竟

observe源码

 @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
   
   
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
   
   
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //判断当前wapper已经添加过，如果添加过就直接返回，否则返回null
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) {
   
   
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        //如果已经添加过，就直接返回
        if (existing != null) {
   
   
            return;
        }
        //没有添加过，则添加wrapper
        owner.getLifecycle().addObserver(wrapper);
    }

从源码可以看出，Observer()方法接收的第一个参数是一个LifecleOwner对象，我们传入的是this，因为this的祖父类实现了这个接口，也正是LifecleOwner对象，LiveData才会具体生命周期感知能力。

首先, 通过owner.getLifecycle().getCurrentState()获取当前页面的状态，如果当前页面被销毁了，就直接返回，也就是说LiveData会自动清除与页面的关联。

LifecycleBoundObserver 源码

 class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
   
   
        @NonNull
        final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
   
   
            super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {
   
   
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
   
   
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
   
   
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

当调用 LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer),本质是通过 ObserverWrapper将observer包装起来，得以LiveData能对生命周期状态得以进行监听，是通过onStateChanged和shouldBeActive方法

shouldBeActive 这里调用LiftCycle的方法，表达如果当前生命周期的状态为onStart,onResume,onPause时返回true，也就是说只有这三个状态可以接收数据更新。
onStateChanged 是LifecycleEventObserver接口的方法，当生命周期发送变化的时候会回调它，如果当前生命周期状态是destory,就会直接移除观察者，否则就会调用activeStateChanged(shouldBeActive());方法激活观察者.

方法中的最后一行代码将observer与Activity的生命周期关联在一起。因此，LivaData能够感知页面的生命周期。

observer方法小结

判断是否已经销毁，如果当前页面销毁，LiveData自动清除与页面的关联
用LifecycleBoundObserver 对observer进行一个包装
判断当前observer是否已经添加过，添加过就直接返回
将observer方法与Activity的生命周期进行关联

setValue方法

 @MainThread
    protected void setValue(T value) {
   
   
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

setValue()中，首先断言是主线程，这里的关键是dispatchingValue(null)方法

void dispatchingValue(@Nullable ObserverWrapper initiator) {
   
   
        if (mDispatchingValue) {
   
   
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
   
   
            mDispatchInvalidated = false;
            if (initiator != null) {
   
   
                considerNotify(initiator);
                initiator = null;
            } else {
   
   
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
   
   
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
   
   
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

只有处于active(激活)状态的观察者，这个方法就会把数据发送给它们。由于每次dispathchingValue传入的null,所以会走else这一部分代码, 这时候就会遍历所有的observer，最后通过调用considerNotify()将数据进行分发给所有的observer

private void considerNotify(ObserverWrapper observer) {
   
   
        if (!observer.mActive) {
   
   
            return;
        }
        // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
        //
        // we still first check observer.active to keep it as the entrance for events. So even if
        // the observer moved to an active state, if we've not received that event, we better not
        // notify for a more predictable notification order.
        //如果当前observer不是激活状态，也就是当前页面被destory,直接return.
        if (!observer.shouldBeActive()) {
   
   
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
   
   
            return;
        }
        observer.mLastVersion = mVersion;
        observer.mObserver.onChanged((T) mData);
    }

只有出于活跃状态且数据是数据是最新的，才会去分发数据，最后回调到我们熟悉的onChanged()方法。

postValue方法

 protected void postValue(T value) {
   
   
        boolean postTask;
        synchronized (mDataLock) {
   
   
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
   
   
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

postValue方法是可以在子线程(非UI线程)发送数据的，但是onChanged()方法始终是在主线程？答案就在postToMainThread(mPostValueRunnable)方法中;

private final Runnable mPostValueRunnable = new Runnable() {
   
   
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
   
   
            Object newValue;
            synchronized (mDataLock) {
   
   
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            setValue((T) newValue);
        }
    };

创建一个Handler将子线程中的任务发送到主线程去执行，其本质还是调用了setValue()方法

LiveData.observeForever()方法

如果你想无论页面处于何种生命周期，setValue/postValue之后立刻回到数据。那么可以使用observerForever()方法，使用起来与observer()没有太大差别. 因为AlwaysActiveObserver没有实现GenericLifecycleObserver 接口，不能感应生命周期。

但是需要注意的是，在用完之后，一定要记得在onDestroy()方法中调用removeObserver()方法来停止对LiveData的观察，否则LiveData会一直处于激活状态，Activity则永远不会被系统自动回收，会造成内存泄露。

ViewModel+LiveData实现Fragment间的通信

我们已经知道，ViewModel能够将数据从Activity中剥离出来。只要Activity不被销毁，ViewModel会一直存储，并且独立于Activity的配置变化。

Fragment可以被看作Activty的子页面，即一个Activity中可以包含多个Fragment.这些Fragment彼此独立，但是又都属于同一个Activity.

基于ViewModel和Fragment组件的这些特性，我们可以利用LiveData,实现同一个Activity中的不同Fragment间的通信，因为不同的Fragment得到的都是同一个LiveData；

在这里插入图片描述

定义ViewModel和LiveData

public class SharedViewModel extends ViewModel {
   
   
    private MutableLiveData<String> content;

    @Override
    protected void onCleared() {
   
   
        super.onCleared();
        //释放资源
        content=  null;
    }

    public LiveData<String> getContent(){
   
   
        if(content == null){
   
   
            content = new MutableLiveData<>();
        }
        return  content;
    }
}

初始化Fragment

Fragment之间的跳转我们使用导航图来进行跳转

share_graph.xml

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/share_graph"
    app:startDestination="@id/masterFragment">

    <fragment
        android:id="@+id/masterFragment"
        android:name="com.example.jetpack.MasterFragment"
        android:label="fragment_master"
        tools:layout="@layout/fragment_master" >
        <action
            android:id="@+id/action_masterFragment_to_detailFragment"
            app:destination="@id/detailFragment" />
    </fragment>
    <fragment
        android:id="@+id/detailFragment"
        android:name="com.example.jetpack.DetailFragment"
        android:label="fragment_detail"
        tools:layout="@layout/fragment_detail" />
</navigation>

MasterFragment 布局

我们使用EditText输入框，输入内容后，点击跳转到DetailFragment后，DetailFragment获取到输入框的内容，并显示在TextView上

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MasterFragment"
    android:gravity="center"
    android:orientation="vertical">

    <EditText
        android:id="@+id/edit_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="输入内容"
        android:textSize="20sp"/>
    <Button
        android:id="@+id/toDetail"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="toDetailFragment"/>

</LinearLayout>

MasterFragment 代码

  private SharedViewModel model;
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
   
   
        View view =  inflater.inflate(R.layout.fragment_master, container, false);
        //设置数据
        model = new ViewModelProvider(getActivity()).get(SharedViewModel.class);
        final MutableLiveData<String> mutableLiveData = (MutableLiveData<String>) model.getContent();

        final EditText editText = view.findViewById(R.id.edit_text);
        view.findViewById(R.id.toDetail).setOnClickListener(new View.OnClickListener() {
   
   
            @Override
            public void onClick(View v) {
   
   

                //获取EditText中的数据,并通知livaData进行更新
                String text = editText.getText().toString().trim();
                mutableLiveData.setValue(text);
                Navigation.findNavController(v).navigate(R.id.action_masterFragment_to_detailFragment);
            }
        });
        return view;
    }

detailFragment布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".DetailFragment"
    android:gravity="center">

    <TextView
        android:id="@+id/tv_text1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="哈哈哈"
        android:textSize="30sp"
        android:textStyle="bold"/>

</LinearLayout>

detailFragment代码

@Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
   
   
        View view =inflater.inflate(R.layout.fragment_detail, container, false);
        final TextView textView = view.findViewById(R.id.tv_text1);
        SharedViewModel model = new ViewModelProvider(getActivity()).get(SharedViewModel.class);
        MutableLiveData<String> mutableLiveData = (MutableLiveData<String>) model.getContent();
        //对LiveData进行监听
        mutableLiveData.observe(getActivity(), new Observer<String>() {
   
   
            @Override
            public void onChanged(String s) {
   
   
                //显示在UI上
                textView.setText(s);
            }
        });

        return view;
    }

Activity布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".viewmodel.ShareActivity"
    android:gravity="center">
  <fragment
      android:id="@+id/nav_host_fragment"
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:name="androidx.navigation.fragment.NavHostFragment"
      app:defaultNavHost= "true"
      app:navGraph="@navigation/share_graph"/>
  </LinearLayout>

只是定义一个Fragment来显示两个Fragment而已，代码文件没有进行任何的更改

运行程序：请添加图片描述

事实证明，两个Fragment获取到的是同一个LiveData, 在MasterFragment对LiveData数据进行更改，在DetailFragment对LiveData进行监听，并将监听到的数据显示在TextView上面。是不是也非常简单啦

总结

本节中，我们学习了LiveData+ViewModel的基本使用。
并对LiveData源码，进行了一个大概的分析。知道了LiveData为什么能感知组件的生命周期
LiveData的本质是观察者模式，可以感知页面的生命周期，当然你也可以使用observeForver()方法让LiveData忽略页面的生命周期，但是需要注意，用完之后要在onDestroy()方法用removeObserver()方法移除监听，否则会造成内存泄露。
LiveData大部分是在ViewModel中使用的，但是它的作用不止于此，下节，我们就来说，LiveData如果搭配Room数据库组件进行使用.

好了，LiveData到这里就结束了，不足之处，望大家指出来，谢谢。

参考:

来源：oschina

链接：https://my.oschina.net/u/4344814/blog/4710799

标签

Observer

Android架构之LiveData组件

前言