Jetpack系列之LiveData详解

56 阅读 0 评论 37 点赞

我是靠谱客的博主喜悦鞋子，最近开发中收集的这篇文章主要介绍Jetpack系列之LiveData详解，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

（一）概述

LiveData is a data holder class that can be observed within a given lifecycle. This means that an Observer can be added in a pair with a LifecycleOwner, and this observer will be notified about modifications of the wrapped data only if the paired LifecycleOwner is in active state.

从LiveData源码描述来看，LiveData是一个可以在给定生命周期内观察到的数据持有者类。
这意味着可以将一个观察者添加到一对LifecycleOwner中，并且只有当配对的LifecycleOwner处于活动状态时，才会通知该观察者关于包装数据的修改。
结合上面的ViewModel分析，可以看出LiveData也是一个与LifecycleRegistry（所谓的“感知生命周期”）相关的组件，而且只有当界面的生命周期处于活跃状态时，观察者才能收到数据更新的通知。

（二）源码解析

一般 livedata通过传入LifecycleOwner监听数据变化（或者说订阅消息）：

livedata.observe(getViewLifecycleOwner()) {data->
       // onChanged()
}

那么livedata持有的数据(mData)什么时候发射呢？也就是这个onChanged() 什么时候会触发呢？
先看observe源码：

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore 
            // 如果页面（fragment/activity...）持有的当前的lifecycle处于DESTROYED状态则不处理
            return;
        }
        // 把observer包装成与lifecycle生命周期关联的LifecycleBoundObserver对象
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 然后放入mObservers（map）中返回wrapper本身，如果observer有对应的wrapper则直接返回wrapper。
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        // 如果observer已经添加并且不是同一个owner，则抛异常
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        // 如果observer已经添加则不处理，反之将wrapper添加到lifecycle生命周期中
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

大致逻辑：把observer先包装成LifecycleBoundObserver添加到lifecycle中。
再看liveData里面的几个主要方法：

private final Runnable mPostValueRunnable = new Runnable() {
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                // 待发数据赋给临时变量
                newValue = mPendingData;
                // 重置（说明待发数据已处理）
                mPendingData = NOT_SET;
            }
            // 发射数据
            setValue((T) newValue);
        }
    };
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);// wrapper传null
    }
可以看出postValue最终还是调用setValue,

之后交由dispatchingValue处理，如果wrapper不为空则只分发给它，反之分发给所有的observer (setValue/postValue).

void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } 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;
    }

最终调用considerNotify，触发observer的onChange回调：

private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {// observer不是活跃状态则不处理
            return;
        }
        ...
        if (!observer.shouldBeActive()) {// lifecycle低于STARTED状态，则更新当前observer为不活跃状态
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {// 如果当前observer的发射次数比livedata的发射次数还高，也不处理。
            return;
        }
        observer.mLastVersion = mVersion;// 更新version
        observer.mObserver.onChanged((T) mData);// 触发observer的onChange回调。
    }

通过上面可以知道，我们主动调用setValue/postValue给dispatchingValue方法传的都是null，会遍历发射数据给所有活跃的观察者，那什么时候dispatchingValue传的不为null呢？
代码追溯：LifecycleRegistry.dispatchEvent(LifecycleOwner, Event) —> onStateChanged —> activeStateChanged —> dispatchingValue，最终又又又回到了 LifecycleRegistry（一个可以感知生命周期的家伙），上面分析ViewModel已经分析过了，不再赘述。另外observeForever订阅时，也会主动触发一个 dispatchingValue。

This class is designed to hold individual data fields of ViewModel, but can also be used for sharing data between different modules in your application in a decoupled fashion.
LiveData 设计用于保存ViewModel的各个数据字段，但也可以用于以解耦方式在应用程序中的不同模块之间共享数据

最后：谷歌建议与ViewModel结合使用（即viewmodel持有LiveData对象，如：方便页面数据共享时，各fragment都能订阅到数据变更），也可以用于不同模块间的数据共享。

（三）小结

livedata是一个感知生命周期的“订阅消息”的组件，由于观察者会绑定到Lifecycle对象 wrapper(避免了内存泄露)，并且只有当界面的生命周期处于活跃onActive()状态，观察者才能收到数据更新的通知（除非你直接或间接触发setValue/postValue主动发射操作，比如页面刷新）