LiveData详细分析

时间 2020-03-07

标签 livedata 详细分析繁體版

原文原文链接

目录介绍

01.LiveData是什么东西
02.使用LiveData的优点
03.使用LiveData的步骤
04.简单使用LiveData
05.observe()和observerForever()
06.LiveData原理介绍
07.observe订阅源码分析
08.setValue发送源码分析
09.observeForever源码
10.LiveData源码总结

00.使用LiveData实现bus事件总线

利用LiveData实现事件总线，替代EventBus。充分利用了生命周期感知功能，能够在activities, fragments, 或者 services生命周期是活跃状态时更新这些组件。支持发送普通事件，也能够发送粘性事件；还能够发送延迟消息，以及轮训延迟消息等等。
github.com/yangchong21…

01.LiveData是什么东西

基于观察者模式
- LiveData是一种持有可被观察数据的类。LiveData须要一个观察者对象，通常是Observer类的具体实现。当观察者的生命周期处于STARTED或RESUMED状态时，LiveData会通知观察者数据变化。
感知生命周期
- 和其余可被观察的类不一样的是，LiveData是有生命周期感知能力的，这意味着它能够在activities, fragments, 或者 services生命周期是活跃状态时更新这些组件。那么什么是活跃状态呢？就是STARTED和RESUMED就是活跃状态，只有在这两个状态下LiveData是会通知数据变化的。
自动解除数据订阅
- 要想使用LiveData（或者这种有可被观察数据能力的类）就必须配合实现了LifecycleOwner的对象使用。在这种状况下，当对应的生命周期对象DESTORY时，才能移除观察者。这对Activity或者Fragment来讲显得尤其重要，由于他们能够在生命周期结束的时候马上解除对数据的订阅，从而避免内存泄漏等问题。

02.使用LiveData的优点

2.1 具备很明显的优势

UI和实时数据保持一致
- 由于LiveData采用的是观察者模式，这样一来就能够在数据发生改变时得到通知，更新UI。
不会发生内存泄露
- 观察者被绑定到组件的生命周期上，当被绑定的组件销毁（onDestroy）时，观察者会马上自动清理自身的数据。
不会再产生因为Activity处于stop状态而引发的崩溃
- 例如：当Activity处于后台状态时，是不会收到LiveData的任何事件的。
不须要再解决生命周期带来的问题
- LiveData能够感知被绑定的组件的生命周期，只有在活跃状态才会通知数据变化。
实时数据刷新
- 当组件处于活跃状态或者从不活跃状态到活跃状态时老是能收到最新的数据
解决Configuration Change问题
- 在屏幕发生旋转或者被回收再次启动，马上就能收到最新的数据。
数据共享
- 若是对应的LiveData是单例的话，就能在app的组件间分享数据。这部分详细的信息能够参考继承LiveData

2.2 细节点补充

组件和数据相关的内容能实时更新,组件在前台的时候可以实时收到数据改变的通知，当组件从后台到前台来时，LiveData可以将最新的数据通知组件，所以保证了组件中和数据相关的内容可以实时更新。
若是横竖屏切换（configuration change）时，不须要额外的处理来保存数据,当屏幕方向变化时，组件会被recreate，然而系统并不能保证你的数据可以被恢复的。当咱们采用LiveData保存数据时，由于数据和组件分离了。当组件被recreate，数据仍是存在LiveData中，并不会被销毁。

03.使用LiveData的步骤

建立一个持有某种数据类型的LiveData (一般是在ViewModel中)
建立一个定义了onChange()方法的观察者。这个方法是控制LiveData中数据发生变化时，采起什么措施 (好比更新界面)。一般是在UI Controller (Activity/Fragment) 中建立这个观察者。
经过 observe()方法链接观察者和LiveData。observe()方法须要携带一个LifecycleOwner类。这样就可让观察者订阅LiveData中的数据，实现实时更新。

04.简单使用LiveData

4.1 单独使用LiveData

举一个最简单的案例代码：

liveData = new MutableLiveData<>();
liveData.observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable final String newText) {
        // 更新数据
        tv3.setText(newText);
    }
});
liveData.setValue("小杨真的是一个逗比么");
复制代码

那么上面这一段代码大概是什么意思呢？
- 首先建立一个 MutableLiveData（LiveData是抽象类）对象，经过 observe 方法能够订阅修改数据的通知，经过 postValue()或者 setValue() 方法发送事件更新数据，已经订阅的 Observer 可以获得数据更改的通知，就会回调 onChanged() 方法。

4.2 使用LiveData配合ViewModel

LiveData是一个数据的包装。具体的包装对象能够是任何数据，包括集合。它是一个抽象类，首先先建立一个类实现LiveData。代码以下所示：

public class TextViewModel extends ViewModel {

    /**
     * LiveData是抽象类，MutableLiveData是具体实现类
     */
    private MutableLiveData<String> mCurrentText;

    public MutableLiveData<String> getCurrentText() {
        if (mCurrentText == null) {
            mCurrentText = new MutableLiveData<>();
        }
        return mCurrentText;
    }

}
复制代码

建立一个观察的对象，观察LiveData中的数据。目前在组件的onCreate()方法中开始观察数据，代码以下所示：

思考下，能够在onResume()中调用么，我的以为不太好。由于系统会屡次调用onResume()方法。

private void initLiveData() {
    // 建立一个持有某种数据类型的LiveData (一般是在ViewModel中)
    model = ViewModelProviders.of(this).get(TextViewModel.class);
    // 建立一个定义了onChange()方法的观察者
    // 开始订阅
    final Observer<String> nameObserver = new Observer<String>() {
        @Override
        public void onChanged(@Nullable final String newText) {
            // 更新数据
            tvText.setText(newText);
        }
    };
    // 经过 observe()方法链接观察者和LiveData，注意：observe()方法须要携带一个LifecycleOwner类
    model.getCurrentText().observe(this, nameObserver);
}
复制代码

而后去建立更新对象数据内容的对象。如何去更新那个文本中的数据呢？代码以下所示：

想要在UI Controller中改变LiveData中的值呢？（好比点击某个Button设置文本内容的更改）。
LiveData并无提供这样的功能，可是Architecture Component提供了MutableLiveData这样一个类，能够经过setValue(T)和postValue(T)方法来修改存储在LiveData中的数据。MutableLiveData是LiveData的一个子类，从名称上也能看出这个类的做用。
调用setValue()方法就能够把LiveData中的值改成 "小杨真的是一个逗比么" 。一样，经过这种方法修改LiveData中的值一样会触发全部对这个数据感兴趣的类。那么setValue()和postValue()有什么不一样呢？区别就是setValue()只能在主线程中调用，而postValue()能够在子线程中调用。

findViewById(R.id.tv_click).setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        count++;
        String text;
        switch (count%5){
            case 1:
                text = "小杨真的是一个逗比么";
                break;
            case 2:
                text = "逗比赶忙来star吧";
                break;
            case 3:
                text = "小杨想成为大神";
                break;
            case 4:
                text = "开始刷新数据啦";
                break;
            default:
                text = "变化成默认的数据";
                break;
        }
        model.getCurrentText().setValue(text);
    }
});
复制代码

05.observe()和observerForever()

通常咱们使用 LiveData 的 observe()，当数据更新后，LiveData 会通知它的全部活跃的观察者。
- 与 RxJava 不一样的，LiveData 只会通知活跃的观察者，例如 Activity 位于 Destroyed 状态时是不活跃的，所以不会收到通知。
固然咱们也可使用 LiveData 的 observerForever() 方法进行订阅，区别是 observerForever() 不会受到 Activity 等组件的生命周期的影响，只要数据更新就会收到通知。

06.LiveData原理介绍

6.1 简单的原理介绍

LiveData可对数据进行观测, 并具备生命周期感知能力, 这就意味着当liveData只会在生命周期处于活跃(inActive)的状态下才会去执行观测动做, 而他的能力赋予不能脱离LifeCycle的范围。
须要注意的是，LiveData内维护的mVersion表示的是发送信息的版本,每次发送一次信息, 它都会+1, 而ObserverWrapper内维护的mLastVersion为订阅触发的版本号, 当订阅动做生效的时候, 它的版本号会和发送信息的版本号同步.他们初始值都为-1。

6.2 而后思考一些问题

a.liveData如何实现订阅者模式，如何处理发送事件？
b.如何作到感知生命周期的，怎么跟 LifecycleOwner 进行绑定的？
c.LiveData 只在 LifecycleOwner active 状态发送通知，是怎么处理的？
d.LiveData 会自动在 DESTROY 的状态下取消订阅，是怎么处理的？
e.生命周期变化后数据处理流程是怎么样的？
f.为何观察者只能与一个LifecycleOwner绑定，而不是多个？

07.observe订阅源码分析

7.1 首先看看observe方法源码

直接查看源代码，以下所示：

当前绑定的组件(activity或者fragment)状态为DESTROYED的时候, 则会忽视当前的订阅请求，也就是忽略owner的注册；
若是须要与生命周期绑定, 则须要传入LifecycleOwner对象, 将咱们的LiveData数据观测者(Observer)包装注册到生命周期的观测者中, 就是源码中建立wrapper对象过程；
须要注意的问题是，不能添加具备不一样生命周期的相同观察者，不然就会抛出IllegalArgumentException异常，可是owner能够add多个Observer；
最后添加一个LifecycleObserver，它将在LifecycleOwner更改状态时获得通知，并作出及时的对应更新活动。

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
    //当前绑定的组件(activity或者fragment)状态为DESTROYED的时候, 则会忽视当前的订阅请求
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    //建立生命周期感知的观察者包装类
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    //若是指定的键还没有与某个值关联，则将其与给定的值关联
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    //对应观察者只能与一个owner绑定
    if (existing != null && !existing.isAttachedTo(owner)) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        return;
    }
    //lifecycle注册
    //添加一个LifecycleObserver，它将在LifecycleOwner更改状态时获得通知
    owner.getLifecycle().addObserver(wrapper);
}
复制代码

7.2 看看LifecycleBoundObserver源码

而后看一下观察者类LifecycleBoundObserver的源代码

LifecycleBoundObserver对象, 它继承于ObserverWrapper, 并最终实现了GenericLifecycleObserver接口；
在发生状态转换事件时，会调用onStateChanged方法，在这个方法中，若是是DESTROYED状态，则先要移除观察者，而后在取到生命周期状态变动事件

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

    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<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) {
            // 当接收到 DESTROYED 的事件会自动解除跟 owner 的绑定
            removeObserver(mObserver);
            return;
        }
        activeStateChanged(shouldBeActive());
    }

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

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

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

        ObserverWrapper(Observer<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 = 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); } } } //接口 public interface GenericLifecycleObserver extends LifecycleObserver { /** * Called when a state transition event happens. * * @param source The source of the event * @param event The event */ void onStateChanged(LifecycleOwner source, Lifecycle.Event event); } 复制代码

经过上面的代码能够发现什么？
- GenericLifecycleObserver是一个接口，ObserverWrapper是一个抽象类，而LifecycleBoundObserver则是ObserverWrapper的子类，而且重写了其中几个方法；
- 在LifecycleBoundObserver的shouldBeActive()方法，在 owner 处于至少是 STARTED 的状态下认为是 active 状态；
- 并且它也实现了 GenericLifecycleObserver 接口，能够监听 lifecycle 回调。在 onStateChanged() 方法里处理了生命周期改变的事件，在这个方法中，当接收到 DESTROYED 的事件会自动解除跟 owner 的绑定；
- 将下个流程交给了 activeStateChanged()，这里具体能够看抽象类ObserverWrapper中的activeStateChanged源码；
看一下ObserverWrapper抽象类中activeStateChanged方法中，onActive和onInactive分别干什么呢？
- 对于onActive方法，当活动观察者的数量从0变为1时调用；对于onInactive方法，当活动观察者的数量从1变为0时调用
```
if (wasInactive && mActive) {
    onActive();
}
if (LiveData.this.mActiveCount == 0 && !mActive) {
    onInactive();
}
复制代码
```
看一下ObserverWrapper抽象类中activeStateChanged方法中，dispatchingValue是干什么呢？
- 这个方法在分析下面setValue源码时还会说到，具体看下面的介绍！

7.3 看看mObservers.putIfAbsent操做

关于observe源码中这一行代码ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper)做用是什么呢？

mObservers.putIfAbsent(observer, wrapper)存入容器中，mObservers.putIfAbsent这个添加数据的方式比较少见。
看了下面源代码可知，支持键值对存储，用链表实现，不是线程安全的。既然这里有存数据，那确定有地方会取数据用到，这个后面会说到……

//mObservers是一个集合
private SafeIterableMap<Observer<T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();

//在SafeIterableMap类中的putIfAbsent方法
public V putIfAbsent(@NonNull K key, @NonNull V v) {
    Entry<K, V> entry = get(key);
    if (entry != null) {
        return entry.mValue;
    }
    put(key, v);
    return null;
}

protected Entry<K, V> put(@NonNull K key, @NonNull V v) {
    Entry<K, V> newEntry = new Entry<>(key, v);
    mSize++;
    if (mEnd == null) {
        mStart = newEntry;
        mEnd = mStart;
        return newEntry;
    }

    mEnd.mNext = newEntry;
    newEntry.mPrevious = mEnd;
    mEnd = newEntry;
    return newEntry;

}
复制代码

7.4 注册观察者流程

那么注册观察者以后的触发流程是怎样的？
- 调用 observe() 注册后，因为绑定了 owner，因此在 active 的状况下，使用LiveData中setValue发送数据，则 Observer 会立马接受到该数据修改的通知。
- observe ——> onStateChanged ——> activeStateChanged ——> dispatchingValue ——> considerNotify ——> onChanged
- 至于最终走到了onChanged方法，这个方法则是交给外部开发者处理接收消息事件的逻辑

08.setValue发送源码分析

8.1 setValue源码分析

LiveData 更新数据方式有两个，一个是 setValue() 另外一个是 postValue()，这两个方法的区别是，postValue() 在内部会抛到主线程去执行更新数据，所以适合在子线程中使用；而 setValue() 则是直接更新数据。

@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    // 这里的 mVersion，它本问题关键，每次更新数据都会自增，默认值是 -1。
    mVersion++;
    mData = value;
    dispatchingValue(null);
}
复制代码

跟进下 dispatchingValue() 方法，注意，这里须要重点看considerNotify代码：

private void dispatchingValue(@Nullable ObserverWrapper initiator) {
    // mDispatchingValue的判断主要是为了解决并发调用dispatchingValue的状况
    // 当对应数据的观察者在执行的过程当中, 若有新的数据变动, 则不会再次通知到观察者。因此观察者内的执行不该进行耗时工做
    if (mDispatchingValue) {
        //给分发失败打个标记
        mDispatchInvalidated = true;
        return;
    }
    // 标记分发开始
    mDispatchingValue = true;
    do {
        mDispatchInvalidated = false;
        //这里须要注意：区分ObserverWrapper对象为空，和不为空的逻辑是不同的
        if (initiator != null) {
            // 等下重点看这里的代码
            considerNotify(initiator);
            initiator = null;
        } else {
            //能够发现这里用到mObservers集合，使用迭代器遍历数据
            for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                // 等下重点看这里的代码
                considerNotify(iterator.next().getValue());
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    // 标记分发开始
    mDispatchingValue = false;
}
复制代码

接下来看一下上面源码中initiator对象为空判断逻辑区别
- dispatchingValue 这里分两种状况：ObserverWrapper不为null和ObserverWrapper为null
- ObserverWrapper不为null 的状况。LifecycleBoundObserver.onStateChanged 方法里调用了 activeStateChanged ，而该方法调用dispatchingValue(this);传入了 this ，也就是 LifecycleBoundObserver ，这时候不为 null 。也就是说生命周期改变触发的流程就是这种状况，这种状况下，只会通知跟该 Owner 绑定的 Observer。
- ObserverWrapper为null 的状况。通过分析发如今setValue方法中调用dispatchingValue(null)传递了空对象，这个时候的流程则会通知 active 的mObservers

8.2 看一下considerNotify()作什么

而后看一下considerNotify() 方法作了什么，代码以下所示，这里有道词典翻译下注释

若是ObserverWrapper的mLastVersion小于LiveData的mVersion，就会去回调mObserver的onChanged方法。
每一个新的订阅者，其version都是-1，LiveData一旦设置过其version是大于-1的（每次LiveData设置值都会使其version加1），这样就会致使LiveDataBus每注册一个新的订阅者，这个订阅者马上会收到一个回调，即便这个设置的动做发生在订阅以前。

private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) {
        return;
    }
    // 检查最新的状态b4调度。也许它改变了状态，但咱们尚未获得事件。
    // 咱们仍是先检查观察者。活动，以保持它做为活动的入口。
    // 所以,即便观察者移动到一个活动状态，若是咱们没有收到那个事件，咱们最好不要通知一个更可预测的通知顺序。
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    
    //注意认真看下面的代码
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    //noinspection unchecked
    observer.mObserver.onChanged((T) mData);
}
复制代码

思考一下dispatchingValue除了setValue会调用，其余还有地方调用么？

dispatchingValue除了在咱们主动更新数据的时候会触发,
当LifeCircleOwner的状态发生变化的时候，会调用LiveData.ObserverWrapper的activeStateChanged函数。
在咱们的观察者状态变动(inactive->active)的时候, 也会通知到, 这就致使了LiveData必然支持粘性事件。
若是这个时候ObserverWrapper的状态是active，就会调用LiveData的dispatchingValue。
它主要是处理分发通知逻辑，而且在分发通知前会判断 owner 的状态，再加上 LiveData 自己内部的版本管理，确保了只会发送最新的数据给 active 状态下的 Observer。
LiveData 对同时屡次修改数据作了处理，若是同时屡次修改，只会修改成最新的数据。

private abstract class ObserverWrapper {
    final Observer<T> mObserver;
    boolean mActive;
    int mLastVersion = START_VERSION;
    //省略部分代码
    void activeStateChanged(boolean newActive) {
        if (newActive == mActive) {
            return;
        }
        // 当observer的状态从active->inactive, 或者inactive->active的时候走如下流程
        // 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();
        }
        //当observer是从inactive->active的时候，须要通知到观察者
        if (mActive) {
            dispatchingValue(this);
        }
    }
}
复制代码

8.3 发送消息事件流程

那么发送消息事件以后的触发流程是怎样的？
- setValue ——> dispatchingValue(null) ——> considerNotify（注意，这里是个for迭代器循环，表示通知全部观察者） ——> onChanged

09.observeForever源码

这个方法是干什么用的呢？看一下源代码

将给定的观察者添加到观察者列表中，意味着给定的观察者将接收全部事件，而且永远不会被自动删除，无论在什么状态下都能接收到数据的更改通知

@MainThread
public void observeForever(@NonNull Observer<T> observer) {
    // 建立一个AlwaysActiveObserver对象
    AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        return;
    }
    //刷新数据
    wrapper.activeStateChanged(true);
}
复制代码

10.LiveData源码总结

LiveData的观察者能够联动生命周期, 也能够不联动。在联动生命周期时，会自动在 DESTROYED 的状态下移除 Observer ，取消订阅，因此不用担忧内存泄露；
LiveData的观察者只能与一个LifecycleOwner绑定, 不然会抛出异常。而一个 owner 能够绑定多个 Observer 实例；
LiveData 跟 LifecycleOwner 绑定，能感知生命周期变化，而且只会在 LifecycleOwner 处于 Active 状态（STARTED/RESUMED）下通知数据改变；若是数据改变发生在非 active 状态，数据会变化，可是不发送通知，等 owner 回到 active 的状态下，再发送通知；
使用observeForever()方法，会注意AlwaysActiveObserver对象，意味着给定的观察者将接收全部事件，而且永远不会被自动删除，无论在什么状态下都能接收到数据的更改通知
LiveData 利用版本管理、绑定 Lifecycle 确保了只会发送最新的数据给 active 状态下的 Observer