定义
- LiveData是一个可观察者的数据存储类，它与其它的观察者不一样的是可以感知activity/fragment的生命周期，确保LiveData仅更新处于活跃状态生命周期的应用组件观察者。
特点
- 可以注册与实现lifecycleowner接口的对象配对的观察者。有了这种关系，当对应的lifecycle对象的状态变为destory时，可以动态移除观察者，无需我们手动处理，可以很好的避免内存泄漏问题。
优点
-
不会发生内存泄漏，无需手动移除观察者
观察者会绑定到lifecycle对象，并在其关联的生命周期遭到销毁后进行自我清理 -
不会因activity/fragment停止而导致崩溃
若观察者处于非活跃状态，则不会接受任何livedata事件 -
数据始终保持最新状态
若生命周期从非活跃状态变为活跃状态，那么将会接收最新数据
那么我们看看LiveData内部到底有什么？
@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);
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);
}
@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
assertMainThread("observeForever");
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && existing instanceof LifecycleBoundObserver) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
wrapper.activeStateChanged(true);
}
说明
-
1.通过observer()方法，我们可以向livedata注册具有生命周期管理的observer，它会将observer和lifecycleowner封装到LifecycleBoundObserver中，LifecycleBoundObserver会判断当前组件的生命周期状态，当livedata设置了数据，只有处于激活状态观察者才会接收到数据；而处于非激活状态的观察者不会接收到数据。
-
2.通过observeForever()方法，我们可以向livedata注册不进行命周期管理的observer，它会将observer封装到AlwaysActiveObserver中，AlwaysActiveObserver不会管当前组件处于何种状态，只要livedata设置了数据就会通知观察者。因此若livedata若有数据，在通过observeForever()添加观察者的时候会调用wrapper.activeStateChanged(true)马上经livedata的数据发送给观察者
-
3.observer()和observeForever()都会将观察者以及观察者的包装类存储到SafeIterableMap中，用于当有新的数据时可以通知所有的观察者
@MainThread public void removeObserver(@NonNull final Observer<? super T> observer) { assertMainThread("removeObserver"); ObserverWrapper removed = mObservers.remove(observer); if (removed == null) { return; } removed.detachObserver(); removed.activeStateChanged(false); } @SuppressWarnings("WeakerAccess") @MainThread public void removeObservers(@NonNull final LifecycleOwner owner) { assertMainThread("removeObservers"); for (Map.Entry<Observer<? super T>, ObserverWrapper> entry : mObservers) { if (entry.getValue().isAttachedTo(owner)) { removeObserver(entry.getKey()); } } }
说明
-
1.调用removeObserver()从map中移除指定的observer
-
2.调用removeObservers()遍历集合中的所有的观察者所对应的LifecycleOwner是不是要移除的owner，若是的话，则调用removeObserver()移除对应的observer
protected void postValue(T value) { boolean postTask; synchronized (mDataLock) { postTask = mPendingData == NOT_SET; mPendingData = value; } if (!postTask) { return; } ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); } @MainThread protected void setValue(T value) { assertMainThread("setValue"); mVersion++; mData = value; dispatchingValue(null); } private final Runnable mPostValueRunnable = new Runnable() { @Override public void run() { Object newValue; synchronized (mDataLock) { newValue = mPendingData; mPendingData = NOT_SET; } //noinspection unchecked setValue((T) newValue); } }; void dispatchingValue(@Nullable ObserverWrapper initiator) { //若正在分发 退出 if (mDispatchingValue) { mDispatchInvalidated = true; return; } mDispatchingValue = true; do { mDispatchInvalidated = false; //若ObserverWrapper不为空 则调用considerNotify() if (initiator != null) { considerNotify(initiator); initiator = null; //若ObserverWrapper为空，则遍历mObservers中所有的ObserverWrapper } 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; } 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. if (!observer.shouldBeActive()) { observer.activeStateChanged(false); return; } if (observer.mLastVersion >= mVersion) { return; } observer.mLastVersion = mVersion; //noinspection unchecked observer.mObserver.onChanged((T) mData); }
说明
-
1.setvalue()主要用于主线程向观察者发送数据。
-
2.postvalue()主要用于异步线程向观察者发送数据，通过synchronized先将数据同步到mPendingData上，然后向主线程抛一个runnable，再调用setvalue()将mPendingData的数据给data，最后将data发送给观察者。
-
3.dispatchingValue():首先会判断当前是否正在将数据发送给观察者，若是的话，则直接退出；若不是的话，先判断传入的观察者ObserverWrapper是否为空，若ObserverWrapper不为空，表示只是向指定的观察者发送数据；若ObserverWrapper为空，则遍历所有的观察者，将数据发送给所有的观察者，最终都会调用considerNotify()
-
4.considerNotify():真正的数据派发操作，会判断观察者是否处于激活状态以及版本是否低于当前版本，只有处于激活状态的观察者才会接收到数据。
private abstract class ObserverWrapper { //持有观察者的引用 final Observer<? super T> mObserver; //是否处于激活状态 boolean mActive; //当前版本 int mLastVersion = START_VERSION; //在构造函数中获取observer 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; //是否活跃 根据处于激活状态时的观察者的数量来决定 boolean wasInactive = this.mActiveCount == 0; //若当前时激活状态 激活观察者的数量+1 否则激活观察者的数量-1 this.mActiveCount += mActive ? 1 : -1; //若当前是第一个处于激活状态的 调用onActive() if (wasInactive && mActive) { onActive(); } //若处于非激活状态且数量为0，调用onInactive() if (this.mActiveCount == 0 && !mActive) { onInactive(); } //若现在处于激活状态 将value分发给所有的处于激活状态的观察者 if (mActive) { dispatchingValue(this); } } }
说明
-
ObserverWrapper是一个抽象类，它是AlwaysActiveObserver和LifecycleBoundObserver的父类
-
封装了观察者observer的引用以及版本，是否处于激活状态
-
shouldBeActive():抽象方法，需要子类去实现，主要用于控制当前观察者是否处于激活状态
-
isAttachedTo():判断传入的LifecycleOwner和当前观察者关联的LifecycleOwner是否是同一个
-
detachObserver():用于移除观察者
-
activeStateChanged():用于修改当前观察者的激活状态，根据激活状态来计算当前处于激活状态的观察者的个数；同时当前要是处于激活状态将会调用dispatchingValue()将数据发送给当前的观察者
-
onActive():当前livedata没有处于激活状态的观察者而当前观察者正处于激活状态时调用
-
onInactive():当前livedata没有了处于激活状态的观察者而当前观察者正处于非激活状态时调用
private class AlwaysActiveObserver extends ObserverWrapper { AlwaysActiveObserver(Observer<? super T> observer) { super(observer); } @Override boolean shouldBeActive() { return true; } } private static void assertMainThread(String methodName) { if (!ArchTaskExecutor.getInstance().isMainThread()) { throw new IllegalStateException("Cannot invoke " + methodName + " on a background" + " thread"); } }
说明
-
1.AlwaysActiveObserver是ObserverWrapper的子类
-
2.这个类封装了observer，但是不进行生命周期管理，可以在组件的任何时期向观察者发送数据
-
3.若需要使用调用observeForever()进行注册
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); } @Override public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) { if (mOwner.getLifecycle().getCurrentState() == DESTROYED) { removeObserver(mObserver); return; } activeStateChanged(shouldBeActive()); } @Override boolean isAttachedTo(LifecycleOwner owner) { return mOwner == owner; } @Override void detachObserver() { mOwner.getLifecycle().removeObserver(this); } }
说明
-
1.LifecycleBoundObserver是ObserverWrapper的子类，同时实现了GenericLifecycleObserver（LifecycleObserver的子类）
-
2.LifecycleBoundObserver持有observer和LifecycleOwner的引用
-
3.shouldBeActive():LifecycleOwner会根据当前生命周期的状态判断当前观察者是否处于激活状态
-
4.LifecycleOwner会在observer()中添加LifecycleBoundObserver，然后在detachObserver（）移除LifecycleBoundObserver
-
5.当LifecycleOwner的生命周期发生改变时会触发onStateChanged(),判断当前组件是否是处于激活状态，从而在组件从非激活状态切换到激活状态时，能够将最新数据更新给观察者。
public T getValue() { Object data = mData; if (data != NOT_SET) { //noinspection unchecked return (T) data; } return null; } int getVersion() { return mVersion; } protected void onActive() { } protected void onInactive() { } @SuppressWarnings("WeakerAccess") public boolean hasObservers() { return mObservers.size() > 0; } @SuppressWarnings("WeakerAccess") public boolean hasActiveObservers() { return mActiveCount > 0; }
说明
-
getValue():获取最新值mData
-
getVersion():获取最新版本
-
onActive():当前livedata没有处于激活状态的观察者而当前观察者正处于激活状态时调用
-
onInactive():当前livedata没有了处于激活状态的观察者而当前观察者正处于非激活状态时调用
-
hasObservers(): 获取观察者的数量
-
hasActiveObservers():获取处于激活状态的观察者的数量
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); } }
说明
- MutableLiveData是LiveData的子类，若需要使用LiveData时可以直接使用当前类
630
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
