前言
在 LiveData 出现之前，一般状态分发我们使用EventBus或者RxJava，这些都很容易出现内存泄漏问题，而且需要我们手动管理生命周期。而 LiveData 则规避了这些问题，LiveData 是一个持有 Activity、Fragment 生命周期的数据容器。当数据源发生变化的时候，通知它的观察者更新 UI 界面。同时它可以只通知处于 Active 状态的观察者更新界面。所以不用担心内存泄漏问题。一般来说，LiveData很少单独使用，它更多的和Android Jetpack的其他组件搭配使用，比如和ViewModel。这篇文章就来介绍LiveData的使用。
1、 什么是LiveData
LiveData 是一个可观察的数据持有者，和常规的observable不同，LiveData 是可以感知生命周期的，也就是说它能够在 Activity、Fragment、Service 中正确的处理生命周期。
LiveData 的数据源一般是 ViewModel，也可以是其它可以更新 LiveData 的组件。当数据更新后，LiveData 就会通知它的所有观察者，比如 Activity。与 RxJava 的方法不同的是，LiveData 可以不通知所有观察者，它可以只通知处于 Active 状态的观察者。这对于Activity 和 Service 特别有用，因为它们可以安全地观察 LiveData 对象而不用担心内存泄漏的问题。还有一点需要注意的是一旦观察者重新恢复到活跃状态，它将会重新收到 LiveData 的最新数据。
2、 LiveData的基本使用
LiveData 是一个抽象类，它的最简单的实现类为 MutableLiveData，使用方法如下所示：
public class MainActivity extends AppCompatActivity {
? MutableLiveData<String> mutableLiveData = new MutableLiveData<>();
? @Override
? protected void onCreate(Bundle savedInstanceState) {
? ? ? super.onCreate(savedInstanceState);
? ? ? setContentView(R.layout.activity_main);
?
? ? ? mutableLiveData.observe(this, new Observer<String>() {
? ? ? ? ? @Override
? ? ? ? ? public void onChanged(@Nullable final String s) {
? ? ? ? ? ? ? Log.d("MainActivity", "onChanged:"+s);
? ? ? ? ? }
? ? ? });
? ? ? mutableLiveData.postValue("LiveData 基本使用");
?
? }
}
MutableLiveData 的 observe 方法有两个参数分别是 LifecycleOwner 和 Observer<T> ，第一个参数就是MainActivity 本身，第二个参数新建了一个Observer<String>，在onChanged方法中得到回调。postValue 方法会在主线程中更新数据，运行结果如下所示：
除了 MutableLiveData 的 postValue 方法，还可以使用 setValue 方法，它们之前的区别是，setValue 方法必须在主线程使用，如果是在子线程线程中更新 LiveData，则可以使用 postValue 方法。
3、 更改LiveData中的数据
如果我们想要在 LiveData 对象分发给观察者之前对其中存储的值进行更改，可以使用 Transformations.map() 和Transformations.switchMap()，下面通过简单的例子来讲解它们。
2.1 Transformations.map()
如果想要在 LiveData 对象分发给观察者之前对其中存储的值进行更改，可以使用Transformations.map()。
public class MainActivity extends AppCompatActivity {
? MutableLiveData<String> mutableLiveData = new MutableLiveData<>();
? @Override
? protected void onCreate(Bundle savedInstanceState) {
? ? ? super.onCreate(savedInstanceState);
? ? ? setContentView(R.layout.activity_main);
?
? ? ? mutableLiveData.observe(this, new Observer<String>() {
? ? ? ? ? @Override
? ? ? ? ? public void onChanged(@Nullable final String s) {
? ? ? ? ? ? ? Log.d("MainActivity", "onChanged:"+s);
? ? ? ? ? }
? ? ? });
? ? ? LiveData transformedLiveData = Transformations.map(mutableLiveData, new Function<String, Object>() {
? ? ? ? ? @Override
? ? ? ? ? public Object apply(String name) {
? ? ? ? ? ? ? return name + " + Transformations.map 的使用";
? ? ? ? ? }
? ? ? });
? ? ? transformedLiveData.observe(this, new Observer() {
? ? ? ? ? @Override
? ? ? ? ? public void onChanged(@Nullable Object o) {
? ? ? ? ? ? ? Log.d("MainActivity", "onChanged2:"+o.toString());
? ? ? ? ? }
? ? ? });
? ? ? mutableLiveData.postValue("LiveData 基本使用");
? }
}
通过Transformations.map()，在mutableLiveData的基础上又加上了字符串" + Transformations.map 的使用"。
运行结果如下所示：
2.2 Transformations.switchMap()
public class MainActivity extends AppCompatActivity {
? private MutableLiveData<String> mutableLiveData1;
? private MutableLiveData<String> mutableLiveData2;
? private MutableLiveData<Boolean> liveDataSwitch;
? private LiveData transformedLiveData;
? @Override
? protected void onCreate(Bundle savedInstanceState) {
? ? ? super.onCreate(savedInstanceState);
? ? ? setContentView(R.layout.activity_main);
? ? ? mutableLiveData1 = new MutableLiveData<>();
? ? ? mutableLiveData2 = new MutableLiveData<>();
? ? ? liveDataSwitch = new MutableLiveData<>();
?
? ? ? ? transformedLiveData= Transformations.switchMap(liveDataSwitch, new Function<Boolean, LiveData<String>>() {
? ? ? ? ? @Override
? ? ? ? ? public LiveData<String> apply(Boolean input) {
? ? ? ? ? ? ? if (input) {
? ? ? ? ? ? ? ? ? return mutableLiveData1;
? ? ? ? ? ? ? } else {
? ? ? ? ? ? ? ? ? return mutableLiveData2;
? ? ? ? ? ? ? }
? ? ? ? ? }
? ? ? });
?
? ? ? transformedLiveData.observe(this, new Observer<String>() {
? ? ? ? ? @Override
? ? ? ? ? public void onChanged(@Nullable final String s) {
? ? ? ? ? ? ? Log.d("MainActivity", "onChanged:" + s);
? ? ? ? ? }
? ? ? });
? ? ? liveDataSwitch.postValue(false);
? ? ? mutableLiveData1.postValue("Transformations.switchMap 用法1");
? ? ? mutableLiveData2.postValue("Transformations.switchMap 用法2");
? }
}
MutableLiveData<Boolean>()用来控制切换，当 liveDataSwitch 的值为true时返回mutableLiveData1，否则返回 mutableLiveData2。
2.3 合并多个LiveData数据源
MediatorLiveData 继承自 mutableLiveData，它可以将多个 LiveData 数据源集合起来，可以达到一个组件监听多个 LiveData 数据变化的目的，用法如下所示：
public class MainActivity extends AppCompatActivity {
? private MutableLiveData<String> mutableLiveData1;
? private MutableLiveData<String> mutableLiveData2;
? private MediatorLiveData mediatorLiveData;
?
? @Override
? protected void onCreate(Bundle savedInstanceState) {
? ? ? super.onCreate(savedInstanceState);
? ? ? setContentView(R.layout.activity_main);
? ? ? mutableLiveData1 = new MutableLiveData<>();
? ? ? mutableLiveData2 = new MutableLiveData<>();
? ? ? mediatorLiveData = new MediatorLiveData<String>();
?
? ? ? mediatorLiveData.addSource(mutableLiveData1, new Observer() {
? ? ? ? ? @Override
? ? ? ? ? public void onChanged(@Nullable Object o) {
? ? ? ? ? ? ? Log.d("MainActivity", "onChanged1:" + o.toString());
? ? ? ? ? }
? ? ? });
?
? ? ? mediatorLiveData.addSource(mutableLiveData2, new Observer() {
? ? ? ? ? @Override
? ? ? ? ? public void onChanged(@Nullable Object o) {
? ? ? ? ? ? ? Log.d("MainActivity", "onChanged2:" + o.toString());
? ? ? ? ? }
? ? ? });
? ? ? mediatorLiveData.observe(this, new Observer() {
? ? ? ? ? @Override
? ? ? ? ? public void onChanged(@Nullable Object o) {
? ? ? ? ? ? ? Log.d("MainActivity", "onChanged:" + o.toString());
? ? ? ? ? }
? ? ? });
? ? ? mutableLiveData1.postValue("mutableLiveData 1");
? ? ? mutableLiveData2.postValue("mutableLiveData 2");
? ? ? mediatorLiveData.postValue("mediatorLiveData 使用");
? }
}
通过 MediatorLiveData 的 addSource 将两个 MutableLiveData 合并到一起，这样当任何一个 MutableLiveData数据发生变化时，MediatorLiveData 都可以感知到，运行结果如下所示：
4、LiveData源码解析
由于 LiveData 是一个 abstract class，我们不能直接生成他的实例。官方有提供他的实现类MutableLiveData，代码如下所示：
public class MutableLiveData<T> extends LiveData<T> {
? ...
? // 可以在子线程中调用
? @Override
? public void postValue(T value) {
? ? ? super.postValue(value);
? }
?
// 必须在主线程中调用
? @Override
? public void setValue(T value) {
? ? ? super.setValue(value);
? }
}
创建了 LiveData 后，需要通过 observe 方法或者 observeForever 方法设置一个观察者，这个观察者接口就是Observer，代码如下：
public interface Observer<T> {
? // 这个回调发生在主线程
? void onChanged(T t);
}
LiveData 的添加观察者的代码如下：
public abstract class LiveData<T> {
...
// 只有onStart之后，onStop之前，对数据的修改才会触发 observer.onChanged()
? public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
? ? }
? ?
? ? // 无论何时，只要数据发生改变，就会触发 observer.onChanged()
? public void observeForever(@NonNull Observer<? super T> observer) {
? ?
? }
...
}
observeForever 的实现跟 observe 是类似的，这里我们重点看一下 observe()的实现过程，代码如下：
// 只能在主线程调用
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
? assertMainThread("observe");
? //如当前UI的状态的是DESTROYED，就不绑定这个回调了
? if (owner.getLifecycle().getCurrentState() == DESTROYED) {
? ? ? // ignore
? ? ? return;
? }
? //创建生命周期感知的观察者包装类(把注册进来的observer包装成一个具有生命周边边界的观察者)
? LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
? //接着会判断该观察是否已经注册过了，如果是则抛异常, 对应观察者只能与一个owner绑定，不允许重复注册
? 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与Activity/Fragment的生命周期,建立关系，
? //当UI的生命周期发生变化的时候，就会去回调wrapper中的onStateChanged方法
? owner.getLifecycle().addObserver(wrapper);
}
4.2 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() {
? /*
? ? ? 观察者是否活跃就等于mOwner的状态是否大于等于STARTED；
? ? ? 如果页面当前不可见，你发送了一条消息，此时是不会被分发的，
? ? ? 可以避免后台任务抢占资源,当页面恢复可见才会分发。
? ? ? */
? ? ? return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
? }
?
// Activity/Fragment的生命周期变化会回调此方法。
? @Override
? public void onStateChanged(@NonNull LifecycleOwner source,
? ? ? ? ? @NonNull Lifecycle.Event event) {
? ? ? Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
? ? ? // 如果当接收到DESTROYED的事件会自动解除跟owner的绑定,避免内存泄露
? ? ? if (currentState == DESTROYED) {
? ? ? ? ? removeObserver(mObserver);
? ? ? ? ? return;
? ? ? }
? ? ? Lifecycle.State prevState = null;
? ? ? while (prevState != currentState) {
? ? ? ? ? prevState = currentState;
? ? ? ? ? //说明宿主的状态发生了变化，此时会判断宿主是否处于活跃状态
? ? ? ? ? activeStateChanged(shouldBeActive());
? ? ? ? ? currentState = mOwner.getLifecycle().getCurrentState();
? ? ? }
? }
?
? @Override
? boolean isAttachedTo(LifecycleOwner owner) {
? ? ? return mOwner == owner;
? }
?
? @Override
? void detachObserver() {
? ? ? mOwner.getLifecycle().removeObserver(this);
? }
}
4.3 ObserverWrapper
状态变更后，如果观察者处于活跃状态会触发数据的分发流程
private abstract class ObserverWrapper {
? final Observer<? super T> mObserver;
? boolean mActive;
? //ObserverWrapper在每次注册的时候都会重新new，所以mLastVersion每次都是-1开始。
? int mLastVersion = START_VERSION;
?
? ObserverWrapper(Observer<? super T> observer) {
? ? ? mObserver = observer;
? }
?
? abstract boolean shouldBeActive();
?
? boolean isAttachedTo(LifecycleOwner owner) {
? ? ? return false;
? }
?
? void detachObserver() {
? }
?
? void activeStateChanged(boolean newActive) {
? //当前的生命周期和上一次的生命周期状态，是否发生变化，没有发生变化，就直接返回。
? ? ? if (newActive == mActive) {
? ? ? ? ? return;
? ? ? }
? ? ? // immediately set active state, so we'd never dispatch anything to inactive
? ? ? // owner
? ? ? mActive = newActive;
? ? ? // 更新活跃值 活跃1 非活跃-1
? ? ? changeActiveCounter(mActive ? 1 : -1);
? ? ? if (mActive) {
? ? ? // 如果是活跃状态，分发值
? ? ? ? ? dispatchingValue(this);
? ? ? }
? }
}
changeActiveCounter 方法代码如下：
@MainThread
void changeActiveCounter(int change) {
// 上一次的活跃数
? int previousActiveCount = mActiveCount;
? // 当前活跃数
? mActiveCount += change;
? if (mChangingActiveState) {
? ? ? return;
? }
? mChangingActiveState = true;
? try {
? ? ? while (previousActiveCount != mActiveCount) {
? ? ? ? ? // 从不活跃变为活跃状态，需要回调 onActive方法
? ? ? ? ? boolean needToCallActive = previousActiveCount == 0 && mActiveCount > 0;
? ? ? ? ? // 从活跃状态变为不活跃状体，需要回调onInactive方法
? ? ? ? ? boolean needToCallInactive = previousActiveCount > 0 && mActiveCount == 0;
? ? ? ? ? previousActiveCount = mActiveCount;
? ? ? ? ? if (needToCallActive) {
? ? ? ? ? ? ? onActive();
? ? ? ? ? } else if (needToCallInactive) {
? ? ? ? ? ? ? onInactive();
? ? ? ? ? }
? ? ? }
? } finally {
? ? ? mChangingActiveState = false;
? }
}
dispatchingValue(this)数据分发流程控制：（内部执行considerNotify(initiator)方法），这个方法我们后面分析。
4.4 setValue 发送数据源码分析
postValue 最终也是调用 setValue 方法，这里就不做分析了，我们主要分析 setValue 方法，代码如下：
@MainThread
? protected void setValue(T value) {
? ? ? assertMainThread("setValue");
? ? ? // 这个mVersion是属于LiveData的,然后只在setValue
? ? ? // (postValue最终也会调用setValue)的时候会自增1
? ? ? mVersion++;
? ? ? // 保存这次变化的数据
? ? ? mData = value;
? ? ? // 分发数据
? ? ? dispatchingValue(null);
? }
接下来我们具体分析 dispatchingValue 方法，代码如下：
@SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchingValue(@Nullable ObserverWrapper initiator) {
? if (mDispatchingValue) {
? ? ? mDispatchInvalidated = true;
? ? ? return;
? }
? //进入while循环前，设置为true，如果此时另外一个数据发生变化，到了此函数中就直接在上面返回了
? mDispatchingValue = true;
? do {
? //开始for循环前，设置为false，for循环完，也会退出while循环
? ? ? mDispatchInvalidated = false;
? ? ? if (initiator != null) {
? ? ? // 如果传递的观察者不为空，则把数据分发给他自己。
? ? ? // 这个流程是Activity/Fragment的生命周期发生变化的时候会被触发
? ? ? ? ? considerNotify(initiator);
? ? ? ? ? initiator = null;
? ? ? } else {
? ? ? // 遍历集合中所有已注册的的观察者，逐个调用considerNotify，分发数据
? ? ? ? ? for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
? ? ? ? ? ? ? ? ? mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
? ? ? ? ? ? ? considerNotify(iterator.next().getValue());
? ? ? ? ? ? ? //这里mDispatchInvalidated 为true，表示在while循环未结束的时候，
? ? ? ? ? ? ? // 有其他数据发生变化，并调用了该函数
? ? ? ? ? ? ? //在上面的if判断中设置了 mDispatchInvalidated = true，
? ? ? ? ? ? ? // 结束本次for循环，没有退出while循环，开始下一次for循环
? ? ? ? ? ? ? if (mDispatchInvalidated) {
? ? ? ? ? ? ? ? ? break;
? ? ? ? ? ? ? }
? ? ? ? ? }
? ? ? }
? } while (mDispatchInvalidated);
? //退出while 后，设置为false，正常处理数据变化
? mDispatchingValue = false;
}
这里有两个变量
-
mDispatchingValue 这个变量用来控制，是否进入while 循环，以及while 循环 是否已经结束
-
mDispatchInvalidated 这个变量用来控制for 循环是否要重新开始
看下considerNotify 的函数，调用了之前 LiveData 设置的 observer 的 onChanged 函数，代码如下：
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.
? // 如果当前的生命周期是非活跃，就不回调onChanged函数，
? // 在LifecycleBoundObserver 中记录状态，当生命周期变为活跃，就回去更新数据
? if (!observer.shouldBeActive()) {
? ? ? observer.activeStateChanged(false);
? ? ? return;
? }
? // 此处判断观察者接收消息的次数是否大于等于 发送消息的次数（observer被创建之初verison=-1 ）
? if (observer.mLastVersion >= mVersion) {
? ? ? return;
? }
? observer.mLastVersion = mVersion;
? // 这里会执行传入的observer的onChanged方法
? observer.mObserver.onChanged((T) mData);
}
综上分析：LiveData的粘性事件：
-
-
通过同一个LiveData 在更改数据的时候调用 setValue(postValue 最终也会调用 setValue) 的时候内部维护的 mVersion 会自增1，mVersion 初始值是-1
-
在监听数据变化的时候，即调用 observer 监听的时候，每次内部都会在通过包装类中new ObserverWrapper，内部维护了一个mLastVersion变量，mLastVersion也是初始值为-1，所以注意了，每执行一次 observer 方法内部维护 mLastVersion 都会新创建而变为 -1 ，如果 mLastVersion 小于 mVersion 的时候就表示有新的变化没有回调 observer 的 onChanged 方法。
-
结论所以只要之前有发射过一次数据，那么后面注册的观察者都会接收到最精一次发射过的数据
-
这种情况被称为LiveData的粘性事件
扫描下方二维码关注公众号，获取更多技术干货。
?