Jetpack组件之LiveData实现原理

提纲

1. LiveData是什么
2. LiveData衍生类及其基本用法
3. LiveData核心方法介绍
4. LiveData实现消息分发实现原理及相关方法
5. LiveData的优势

一、LiveData是什么

LiveData 组件是 Jetpack 推出的基于观察者的消息订阅/分发组件，具有宿主（Activity、Fragment）生命周期感知能力，这种感知能力可确保 LiveData 仅分发消息给处于活跃状态的观察者，即只有处于活跃状态的观察者才能收到消息。

活跃状态：通常情况下等于 Observer 所在宿主处于 STRATED，RESUMED 状态，如果使用 observeForever()注册的，则一直处于活跃状态。

二、LiveData衍生类及其基本用法

2.1 MutableLiveData

使用 LiveData 的做消息分发的时候，需要使用这个子类。之所以这么设计是考虑到单一开闭原则，只有MutableLiveData 对象可以发送消息，LiveData 对象只能接收消息。

@SuppressWarnings("WeakerAccess")
public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
        // LiveData.postValue()->ArchTaskExecutor.postToMainThread()->DefaultTaskExecutor.postToMainThread()->mMainHandler.post() 将数据发送到主线程处理
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

val liveData = MutableLiveData<Int>()
liveData.observe(this, Observer {
   // TODO: do something
})
mediatorLiveData.value = 1

2.2 MediatorLiveData

可以统一观察多个 LiveData 发射的数据进行统一的处理，同时也可以做为一个 LiveData，被其他 Observer 观察。

        val liveData1 = MutableLiveData<Int>()
        val liveData2 = MutableLiveData<Int>()
        val mediatorLiveData =  MediatorLiveData<Int>()
        val observer = Observer<Int> {
            // TODO: do something
        }
        // 1.观察多个 LiveData 发射的数据进行统一的处理
        mediatorLiveData.addSource(liveData1,observer)
        mediatorLiveData.addSource(liveData2,observer)
        liveData1.value = 1
        liveData2.value = 2

        // 2.做为一个 LiveData，被其他 Observer 观察
        mediatorLiveData.observe(this, Observer {
            // TODO: do something
        })
        mediatorLiveData.value = 1

三、LiveData核心方法介绍

方法名	介绍
observe(LifecycleOwner owner,Observer observer)	注册和宿主生命周期关联的观察者
observeForever(Observer observer)	注册观察者,不会反注册,需自行维护
setValue(T data)	发送数据,没有活跃的观察者时不分发，只能在主线程调用！！
postValue(T data)	发送数据,没有活跃的观察者时不分发，不受线程环境影响
onActive()	当且仅当有一个活跃的观察者时会触发
onInactive()	不存在活跃的观察者时会触发

四、LiveData实现消息分发实现原理及相关方法

4.1 分发流程相关方法分析

4.1.1 void observe(LifecycleOwner owner,Observer observer)

• 向LiveData注册观察者——用于消息分发
• 向Lifycycle注册观察者——用于感知宿主生命周期

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        // 保证当前宿主的状态为非DESTROYED
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        // 将Observer包装成LifecycleBoundObserver
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 向LiveData注册观察者
        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;
        }
        // 向Lifecycle注册观察者
        owner.getLifecycle().addObserver(wrapper);
    }

    // 绑定生命周期的观察者
    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() {
            // 当前宿主的状态是否为活跃状态，即STARTED，RESUMED
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        // 宿主生命周期改变回调的方法
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                // 宿主为DESTROYED状态，移除观察者，即反注册
                removeObserver(mObserver); 
                return;
            }
            // 活跃状态改变
            activeStateChanged(shouldBeActive());
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

4.1.2 void activeStateChanged(boolean newActive)活跃状态改变，回调对应方法

    void activeStateChanged(boolean newActive) {
        // 1.屏蔽初始化时非活跃状态的分发
        // 2.屏蔽相同活跃状态重复分发
        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);
        }
    }

4.1.3 void dispatchingValue(@Nullable ObserverWrapper initiator) 分发，阻断(maybe)，再分发，精准分发，全部分发

    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        // 循环的原因， 结束当前分发，重新再分发
        // 当正在分发第一次数据时，此时 mDispatchingValue=true  mDispatchInvalidated=false
        // 这是第二次分发走到当前方法时，mDispatchInvalidated会被置为true，break结束for循环，do while继续执行
        do {
            mDispatchInvalidated = false;
            if (initiator != null) { // 不为null，精准分发
                considerNotify(initiator);
                initiator = null;
            } else { // 为null
                // 遍历，向所有观察者分发数据
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                     mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

4.1.4 void considerNotify(ObserverWrapper observer)分发最终方法and黏性事件的产生

   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;
        }
        // 黏性消息的始发地，即先发送消息，再注册观察者也会收到此消息（发送的最后一条消息）
        // mLastVersion和mVersion的初始值均为-1
        // 当发送消息时，mVersion++ = 0
        // 再注册观察者时-1 < 0 , 则向observer分发
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        // 对齐
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        // 事件分发到此结束
        observer.mObserver.onChanged((T) mData);
    }

五、LiveData的优势

摘自慕课网

• 确保界面符合数据状态
  LiveData遵循观察者模式。当生命周期状态发生变化时，LiveData 会根据宿主状态和注册类型通知 [Observer]对象并把最新数据派发给它。观察者可以在收到onChanged事件时更新界面，而不是在每次数据发生更改时立即更新界面。
• 不再需要手动处理生命周期
  只需要观察相关数据，不用手动停止或恢复观察。LiveData 会自动管理Observer的反注册，因为它能感知宿主生命周期的变化，并在宿主生命周期的onDestory自动进行反注册。因此使用LiveData做消息分发不会发生内存泄漏
• 数据始终保持最新状态
  如果宿主的生命周期变为非活跃状态，它会在再次变为活跃状态时接收最新的数据。例如，在后台的 Activity会在返回前台后立即接收最新的数据。
• 支持黏性事件的分发
  即先发送一条数据，后注册一个观察者，默认是能够收到最后发送的那条数据
• 共享资源
  可以使用单例模式拓展 LiveData，实现全局的消息分发总线。