什么是LiveData
android开发者官网上对其的定义是：LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。上面这段话概括起来包括下面四个特点：
- 是一个数据持有类
- 能够感知组件的生命周期
- 数据可以被观察者观察
- 只有在组件处于激活状态才会通知观察者有数据更新
如何使用
下面是一个简单的例子：
public class MutableLiveDataActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_mutable_live_data);
ConstraintLayout layout = findViewById(R.id.layout);
// new一个MutableLiveData对象，MutableLiveData是LiveData的子类
final MutableLiveData<String> livedata = new MutableLiveData<>();
// 注册和宿主生命周期关联的观察者
livedata.observe(this, new Observer<String>() {
@Override
public void onChanged(String str) {
// 当数据发生变化时或者宿主生命周期发生变化时回调
Log.e("TAG", String.valueOf(str));
}
});
layout.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 发送数据,没有活跃的观察者时不分发。只能在主线程。
livedata.setValue("测试");
// 发送数据,没有活跃的观察者时不分发。可以在任意线程。
livedata.postValue("测试");
}
});
}
}
源码分析
下面通过分析源码来详细看一看LiveData到底是如何实现上面提到这个点的。
首先点开observe方法，进入到LiveData类看一下observe实现了什么功能，
LiveData.java
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe"); // 判断是否在主线程
// 判断生命周期的宿主(通常就是activity, fragment, service)当前的状态是否已销毁
// 如果是，则直接return，后面的代码不用执行了
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
// 这是一个生命周期与观察者进行绑定的包装类
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
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;
}
owner.getLifecycle().addObserver(wrapper);
}
LifecycleBoundObserver内部类 继承了ObserverWrapper抽象类并实现了GenericLifecycleObserver接口。主要实现宿主生命周期与观察者之间的绑定，比较关键的是onStateChanged方法。
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@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);
}
/**
* LifecycleEventObserver感知生命周期的回调，当宿主生命周期发生变化时回调。
*/
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
// 先判断宿主生命周期状态是否是DESTROYED，如果如果已经销毁，则移除观察者。
// 这里显示出了LiveData不会发生内存泄漏的优势，观察者会绑定到Lifecycle对象，并在其关联的生命周期遭到销毁后进行自我清理
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
// 活动状态发生变化的时候调用，这里shouldBeActive()的返回值是当LifecycleOwner的状态是STARTED或者RESUMED时为true，其他状态为false
activeStateChanged(shouldBeActive());
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
ObserverWrapper内部抽象类，核心方法是dispatchingValue，当宿主处于活跃状态时，调用dispatchingValue()
private abstract class ObserverWrapper {
...
/**
* 宿主状态发生改变
*/
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
boolean wasInactive = LiveData.this.mActiveCount == 0;
LiveData.this.mActiveCount += mActive ? 1 : -1;
if (wasInactive && mActive) {
onActive();
}
if (LiveData.this.mActiveCount == 0 && !mActive) {
onInactive();
}
if (mActive) {
dispatchingValue(this);
}
}
}
dispatchingValue()，核心内容是do while循环中，调用considerNotify()来通知观察者调用onChanged方法
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
// 核心部分是do while中的循环操作
do {
mDispatchInvalidated = false;
// 先判断ObserverWrapper是否为null，从源码中我们可以发现，当宿主生命周期发生变化时，这里ObserverWrapper是传入了值了的，当调用LiveData的setValue()时，传入的是null
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
// mObservers可以看做是一个可迭代的map，其中存放了所有添加进去的观察者
// 这里是遍历所有的观察者，然后调用considerNotify()
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
considerNotify ，这里做了三重判断之后，调用观察者的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.
// 判断宿主生命周期是否处于活跃状态（STARTED或者RESUMED状态）
if (!observer.shouldBeActive()) {
// 如果宿主生命周期处于非活跃的状态，那么调用activeStateChanged()
observer.activeStateChanged(false);
return;
}
// mVersion记录了setValue调用的次数，这里对版本号的比较有效的防止了宿主生命周期发生变化时observer会调用onChanged()的情况。
// 例如屏幕旋转时，activity的生命周期发生了变化，在调用此方法时，由于这里mLastVersion和mVersion值相同，所以直接return，并不会执行observer的onChanged方法
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
// observer调用onChanged()
observer.mObserver.onChanged((T) mData);
}
通过上面的源码分析之后可以看到LiveData在注册了观察者之后做了哪些事情，也凸显了上面一开始介绍的够感知组件的生命周期和只有在组件处于激活状态才会通知观察者有数据更新的特点。下面接着来看一下LiveData在setValue/postValue之后做了什么：
setValue 首先判断了程序是否处在主线程中(与postValue有不同)，之后调用了dispatchingValue()方法并传入了一个null值。之后的流程就是上面分析过的流程了，只不过传入的数据不同。
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
这里开看一下它是怎么持有数据的，setValue需要传入的值value是一个泛型，之后这个值被赋给了mData，mData是一个Object类型的数据，之后在considerNotify方法中调用observer的onChanged方法时将mData传入：
observer.mObserver.onChanged((T) mData);
看完了setValue方法，也顺带着看一下postValue，看看两者之间有什么区别：
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
// 将value赋值给了mPendingData，这里是跟setValue不同点之一
mPendingData = value;
}
if (!postTask) {
return;
}
// 在主线程中去执行，这里是不同点二
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
从上下两段代码可以看出，setValue是必须要到主线程中执行的，而postValue可以在主线程或者子线程中执行，至于为什么在postValue中增加了一个mPendingData变量，而不是用之前的mData变量，我觉得应该是怕在多线程中引起数据错乱的原因，所以在当前线程中将value赋值给mPendingData，然后在主线程中将mPendingData的值再赋给mData。
