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 extends LiveData {
    @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()
liveData.observe(this, Observer {
   // TODO: do something
})
mediatorLiveData.value = 1
2.2 MediatorLiveData

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

        val liveData1 = MutableLiveData()
        val liveData2 = MutableLiveData()
        val mediatorLiveData =  MediatorLiveData()
        val observer = Observer {
            // 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 LiveData实现消息分发流程图

4.1 分发流程相关方法分析

4.1.1 void observe(LifecycleOwner owner,Observer observer)
  • 向LiveData注册观察者——用于消息分发
  • 向Lifycycle注册观察者——用于感知宿主生命周期
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer 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 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, 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,实现全局的消息分发总线。

你可能感兴趣的:(Jetpack组件之LiveData实现原理)