【AAC 系列三】深刻理解架构组件：LiveData

时间  2019-11-06
标签 AAC 系列三 深刻 理解 架构 组件 livedata 栏目 系统架构 繁體版
原文   原文链接

0. 前言

本文是深刻理解「Android Architecture Components」系列文章第三篇 源码基于 android.arch.lifecycle:livedata-core:1.1.1html

【AAC 系列一】Android 应用架构新时代来临！java

【AAC 系列二】深刻理解架构组件的基石：Lifecyclereact

【AAC 系列三】深刻理解架构组件：LiveDataandroid

这个连接不要点,千万不要git

在以前咱们深刻研究了 Lifecycle 的实现原理，并在文末提到了LiveData 以及 ViewModel，此次咱们来说讲 LiveData。github

LiveData 是 Android Architecture Components 中的一员，先看下官方是如何介绍的：数据库

LiveData is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers that are in an active lifecycle state. [见 9.1]缓存

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. [见 9.2]网络

简单讲 LiveData 是一个可以感知生命周期、可观察的数据持有类 ，它被设计成 ViewModel 的一个成员变量；能够以一个 更解耦 的方式来共享数据。架构

实际使用下来发现 LiveData 有几个特性：

  1. LiveData 的实现基于观察者模式；
  2. LiveData 跟 LifecycleOwner 绑定，能感知生命周期变化，而且只会在 LifecycleOwner 处于 Active 状态（STARTED/RESUMED）下通知数据改变；
  3. LiveData 会自动在 DESTROYED 的状态下移除 Observer ，取消订阅，因此不用担忧内存泄露；

那么 LiveData 上述特性的原理是怎么样的呢？
使用 LiveData 又须要注意些什么呢？

本文将围绕此展开。

1. LiveData 的基本使用

虽然 LiveData 一般跟 ViewModel 配合使用，不过也能够单独使用，为了简单起见，这里不配合 ViewModel。

如下是一个简单的例子：

MutableLiveData<String> liveString = new MutableLiveData<>();
liveString.observe(this, new Observer<String>() {
  @Override
  public void onChanged(@Nullable final String s) {
    Log.d(TAG, "onChanged() called with: s = [" + s + "]");
  }
});

liveString.postValue("程序亦非猿");
复制代码

运行后能够看到日志输出：onChanged() called with: s = [程序亦非猿] 。

释义：
定义一个 MutableLiveData （LiveData 的一个经常使用子类），经过 observe 方法能够订阅修改数据的通知，经过 postValue()  或者 setValue()  方法能够更新数据，已经订阅的 Observer 可以获得数据更改的通知，也即回调 onChanged() 方法。

这样就算是用上 LiveData 了。

接下来，上干货！

2. LiveData 的原理分析

在分析原理前，再明确一下咱们的疑问：

  1. LiveData 是如何跟 LifecycleOwner 进行绑定，作到感知生命周期的？
  2. LiveData 只在 LifecycleOwner active 状态发送通知，是怎么处理的？
  3. LiveData 会自动在 DESTROY 的状态下取消订阅，是怎么处理的？
  4. 经过 setValue()/postValue() 更新数据的处理流程是如何？
  5. 生命周期变化后数据处理流程是怎么样的？

同时提早看下我整理的 LiveData UML 图，对 LiveData 有个总体的了解，后续的涉及到的类都在这里了，有助于理解。

image.png

(图1.LiveData 类图)

OK， here we go!

2.1 LiveData.observe()

LiveData 的使用流程从 observe() 开始，我们尝试从 observe() 方法 开始分析：

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        //若是是 DESTROYED 的状态则忽略
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //把 Observer 用 LifecycleBoundObserver 包装起来
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //缓存起来
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        //若是已经 observe 过 而且两次的 owner 不一样则报错
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        //绑定 owner
        owner.getLifecycle().addObserver(wrapper);
    }
复制代码

能够看到 observe 方法里把咱们传递的 observer 用 LifecycleBoundObserver  包装了起来，而且存入了 mObservers  ，而且跟 owner 进行了关联。

而且作了两个特殊处理：

  1. 忽视处于 DESTROYED 的 owner 的注册行为；
  2. 将一个 Observer 同时绑定两个 owner 的行为视为非法操做，也即一个 Observer 只能绑定一个 owner，而 owner 能够有多个 Observer；

这里出现了几个新的类 LifecycleBoundObserver 、ObserverWrapper 来看看。

2.2 LifecycleBoundObserver

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
            super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {
            // 判断 owner 当前的状态是不是至少 STARTED
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            //生命周期改变，若是是 DESTROYED 就自动解除
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            //ObserverWrapper.activeStateChanged
            activeStateChanged(shouldBeActive());
        }

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

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }
复制代码

**ObserverWrapper **:

private abstract class ObserverWrapper {
        final Observer<T> mObserver;
        boolean mActive;
        int mLastVersion = START_VERSION;

        ObserverWrapper(Observer<T> observer) {
            mObserver = observer;
        }
				//是不是 active 状态
        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 = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                onInactive();
            }
            //若是 active 状态下，则发送数据更新通知
            if (mActive) {
                dispatchingValue(this);
            }
        }
    }
复制代码

仔细看下这两个类其实就能解答疑问了。

LifecycleBoundObserver 是 抽象类 ObserverWrapper 的子类，重写了 shouldBeActive() 方法，在 owner 处于至少是 STARTED 的状态下认为是 active 状态；而且它也实现了 GenericLifecycleObserver 接口，能够监听 lifecycle 回调，而且在 onStateChanged() 方法里处理了生命周期改变的事件，当接收到 DESTROYED 的事件会自动解除跟 owner 的绑定，而且将下个流程交给了 activeStateChanged() 。

到这里 【2.1】、【2.3】的问题已经有了答案：

【2.1】答：LifeData 在 observe 方法中用 LifecycleBoundObserver 包装了 observer ，而且经过它绑定了owner。
【2.3】答：LifecycleBoundObserver 在 onStateChanged() 方法里处理了生命周期改变的事件，当接收到 DESTROYED 的事件会自动解除跟 owner 的绑定。

这里须要注意的是，当咱们调用 observe() 注册后，因为绑定了 owner，因此在 active 的状况下，LiveData 若是有数据，则 Observer 会立马接受到该数据修改的通知。

此时的流程是:

observe-->
  onStateChanged-->
    activeStateChanged-->
     dispatchingValue-->
       considerNotify-->
          onChanged

能够称之为生命周期改变触发的流程，另外还有一种流程是 postValue&setValue 触发的流程，共两种。

2.3 activeStateChanged(boolean)

在 activeStateChanged() 方法里，处理了 onActive() 跟 onInactive() 回调的相关逻辑处理，而且调用了dispatchingValue(this) 。（MediatorLiveData 用到了 onActive() 跟 onInactive() 有兴趣自行了解，这里不展开）

接下去探索 dispatchingValue 。

2.4 dispatchingValue(ObserverWrapper) 分析

private void dispatchingValue(@Nullable ObserverWrapper initiator) {
        //若是正在分发则直接返回
        if (mDispatchingValue) {
            //标记分发失效
            mDispatchInvalidated = true;
            return;
        }
        //标记分发开始
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            //生命周期改变调用的方法 initiator 不为 null
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                //postValue/setValue 方法调用 传递的 initiator 为 null
                for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        //标记分发结束
        mDispatchingValue = false;
    }
复制代码

considerNotify(ObserverWrapper)  方法:

private void considerNotify(ObserverWrapper observer) {
        //检查状态 确保不会分发给 inactive 的 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;
        }
        //setValue 会增长 version ,初始 version 为-1
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        observer.mObserver.onChanged((T) mData);
    }
复制代码

能够看到 dispatchingValue 正是分发事件逻辑的处理方法，而 considerNotify 方法则确保了只将最新的数据分发给 active 状态下的 Observer 。

另外也能够看到 LiveData 引入了版本管理来管理数据 （mData）以确保发送的数据老是最新的。（具体很少讲）

dispatchingValue 这里分两种状况：

  1. ObserverWrapper 不为 null
  2. ObserverWrapper 为 null

须要着重讲一下。

2.4.1 ObserverWrapper 不为 null 的状况

上面提到过，LifecycleBoundObserver.onStateChanged 方法里调用了 activeStateChanged ，而该方法调用dispatchingValue(this);传入了 this ，也就是 LifecycleBoundObserver ，这时候不为 null 。

也就是说生命周期改变触发的流程就是这种状况，这种状况下，只会通知跟该 Owner 绑定的 Observer。

2.4.2 ObserverWrapper 为 null 的状况

上面我也提早说了，除了生命周期改变触发的流程外，还有 postValue&setValue 流程，来看下这俩方法。

private final Runnable mPostValueRunnable = new Runnable() {
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {
            newValue = mPendingData;
            mPendingData = NOT_SET;
        }
        //noinspection unchecked
        //调用 setValue
        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) {
    //必须在主线程调用 不然会 crash
    assertMainThread("setValue");
    mVersion++;//增长版本号
    mData = value;
    //传入了 null
    dispatchingValue(null);
}
复制代码

LiveData 的 postValue 方法其实就是把操做 post 到主线程，最后调用的仍是 setValue 方法，注意 setValue 必须是在主线程调用。

而且能够看到** setValue 方法调用了 dispatchingValue 方法，并传入了 null ，这个时候的流程则会通知 active 的mObservers**。

到这里以前的剩下的全部疑问也均可以解答了。

LiveData 的两个流程都会走到 dispatchingValue 处理分发通知逻辑，而且在分发通知前会判断 owner 的状态，再加上 LiveData 自己内部的版本管理，确保了只会发送最新的数据给 active 状态下的 Observer。

**注意：**LiveData 对同时屡次修改数据作了处理，若是同时屡次修改，只会修改成最新的数据。

3. 图解 LiveData

3.1 LiveData 类图

再看一遍类图，回顾一下：

image.png

(图2.LiveData 类图)

3.2 LiveData 流程图

Lifecycle 改变触发流程：

livedata-lifecycle-changes.png

(图3.Lifecycle 改变触发流程图)

Lifecycle postValue/setValue 触发流程：

livedata-postvalue.png

(图4.setValue 改变触发流程图)

4. LiveData tips and recipes


LiveData 还有不少其余相关知识，这里列举一些，更多实践能够看一下【7.6】。

4.1 Sticky Event

LiveData 被订阅时，若是以前已经更改过数据，而且当前 owner 为 active 的状态，activeStateChanged() 会被调用，也即会立马通知到 Observer ，这样其实就相似 EventBus 的 sticky event 的功能，须要注意的是，不少时候咱们并不须要该功能。具体能够看一下【7.6】的处理。

4.2 AlwaysActiveObserver

默认状况下，LiveData 会跟 LicycleOwner 绑定，只在 active 状态下更新，如若想要无论在什么状态下都能接收到数据的更改通知的话，怎么办？这时候须要使用 AlwaysActiveObserver ，改调用 observe 方法为调用 LiveData.observeForever(Observer) 方法便可。

4.3 MediatorLiveData

LiveData 还有一个子类是 MediatorLiveData，它容许咱们合并多个 LiveData，任何一个 LiveData 有更新就会发送通知。好比咱们的数据来源有两个，一个数据库一个网络，这时候咱们会有两个 DataSource，也就是两个 LiveData，这个时候咱们可使用 MediatorLiveData 来 merge 这两个 LiveData。

4.4 Transformations

Transformations 容许咱们把一个 LiveData 进行处理，变化成另一个 LiveData，目前支持 map 跟 switchMap 两个方法，跟 RxJava 的操做相似。

好比，用 map 把一个 String 类型的 LiveData 转换成 Integer 类型：

Transformations.map(liveString, new Function<String, Integer>() {
  @Override
  public Integer apply(final String input) {
    return Integer.valueOf(input);
  }
}).observe(this, new Observer<Integer>() {
  @Override
  public void onChanged(@Nullable final Integer integer) {

  }
});
复制代码

4.4 LiveDataBus

EventBus 基于观察者模式，LiveData 也是，因此 LiveData 能够被用来作成 LiveDataBus，有兴趣能够搜索。

5. 知识点汇总

  1. LiveData 的实现基于观察者模式（reactive patterns）；
  2. LiveData 跟 LifecycleOwner 绑定，能感知生命周期变化，而且只会在 LifecycleOwner 处于 Active 状态（STARTED/RESUMED）下通知数据改变；若是数据改变发生在非 active 状态，数据会变化，可是不发送通知，等 owner 回到 active 的状态下，再发送通知；
  3. 若是想要一直收到通知，则须要用 observeForever() 方法；
  4. LiveData 会自动在 DESTROYED 的状态下移除 Observer ，取消订阅，因此不用担忧内存泄露；
  5. 在 LifecycleOwner 处于 DESTROYED 的状态下，不能订阅；
  6. postValue 方法其实最后调用了 setValue 只不过把操做放到主线程，适合在异步线程里调用，setValue 必须在主线程里调用；
  7. 若是同时屡次调用 postValue 或 setValue 修改数据，只会修改为最新的那个数据，也即只会收到一次通知（set post混合调用则不必定）；
  8. 若是 LiveData 有数据，而且 owner 在 active 状态下，那么在订阅的时候，会立马收到一次通知；
  9. 一个 Observer 实例，只能绑定一个 LifecycleOwner，而一个 owner 能够绑定多个 Observer 实例；
  10. LiveData 利用版本管理、绑定 Lifecycle 确保了只会发送最新的数据给 active 状态下的 Observer；

6. 总结

LiveData 基于观察者模式，而且能够感知生命周期，这使得咱们使用 LiveData 既能够享受观察者模式带来的隔离数据与 UI 等强大的解耦能力，还能够享受感知生命周期带来的巨大便利。而且还无需担忧内存泄露这个使人头疼的问题。

咱们可使用 LiveData 很是轻松地作到一些很是高效的操做，如仅在 active 的状态下刷新 UI，能够避免没必要要的数据刷新。

显而易见 LiveData 自己的优秀特性有着巨大的价值，利用好绝对是架构设计中的一大利器，另外 LiveData 配合 ViewModel 能够发挥更大的价值，机智的你必定已经知道下一篇文章讲什么了。

7. 参考与推荐

  1. LiveData Overview : developer.android.com/topic/libra…
  2. LiveData doc : developer.android.com/reference/a…
  3. developer.android.com/reference/a…
  4. developer.android.com/reference/a…
  5. github.com/googlesampl…
  6. github.com/googlesampl…

公众号：程序亦非猿
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程