Jetpack之LiveData使用和源码解析

2021-05-02

LiveData的主要作用是可以通过观察者模式进行异步的通知，我们使用它的主要场景就是把网络数据，数据库数据等通过异步的方式通知UI。他的优点是可以避免内存泄漏，与生命周期关联起来，回调也是在主线程中。

使用

我们一般会把LiveData结合ViewModel一起使用，ViewModel作为桥梁，LiveData就是当中的运输数据的工具，与DataBinding中的ObserverField类似。

//SettingViewModel
class SettingViewModel : ViewModel() {
    val liveData by lazy { MutableLiveData<HttpResult<Setting>>() }
    
    fun requestSetting(){
        //repo是负责发起网络请求或者是本地数据库请求的逻辑
        repo.request(liveData)
    }
}

//SettingRepo
class SettingRepo{
    fun request(liveData:MutableLiveData<HttpResult<Setting>>){
        thread(){
            //通过retrofit或者其他的方式获取到setting
            ...
            liveData:MutableLiveData.postValue(setting);            
    }
    }
}
//Activity中

class SettingActivity : AppCompatActivity() {

    private var provider: ViewModelProvider? = null]
    private lateinit var mVM: TestVM
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_aidl)
        provider = ViewModelProvider(this)
        mVM = provider?.get(TestVM::class.java)!!
        mVM.liveData.observe(this){
            //处理传递回来的setting
        }
        mVM.requestSetting()
    }
}

与我们平时使用回调的方式是不太一样的，我们只需通过LiveData的observe方法即可监听到请求的返回结果，该方法的参数一个是LifecycleOwner，通过该参数LiveData可以获取到Lifecycle然后监听生命周期，另外一个是Observer接口，监听他就可以收到LiveData传递回来的参数。

源码解析

LiveData是一个抽象类，我们一般使用的是MutableLiveData，他的实现类，MutableLiveData与LiveData的区别只是它把LiveData的setValue和postValue方法改为了public而已。
LiveData通知数据更新主要有两种方式，一种是postValue，另外一种是setValue，他们二者的区别是前者可以在任意线程进行调用，后者是必须在主线程调用。
然后他的观测数据变更方法也是有两个，一个是observe，另外一个是observeForever，他们二者的区别后面再细说，需要知道的是我们监听数据的回调，也就是Observer的接口实现方法的回调都是在主线程的。
LiveData是一个泛型类，声明是LiveData<T>，我们先分析它的成员变量

mDataLock，同步锁，使用在那里后面说
mObservers，他是SafeIterableMap<Observer<? super T>, ObserverWrapper>类型，关于该类型可以看Jetpack之FastSafeIterableMap源码，用于存储所有的观察者对象
mActiveCount，记录激活的次数
mChangingActiveState，用于判断是否正在调用changeActiveCounter()方法，该方法作用后续再说
mData，需要更新的数据，只记录最后一次需要更新的数据
mPendingData，用于标识当前需要处理的数据，然后判断是否需要进行数据更新
mVersion，相当于LiveData数据更新的次数或者是版本
mDispatchingValue，用于判断是否正在更新通知回调
mDispatchInvalidated，用于判断是否需要继续通知回调，与mDispatchingValue结合使用
mPostValueRunnable，用于异步更新时候的Runable对象
NOT_SET，默认的mPendingData值，等于该值的时候表明不需要进行数据分发
12，START_VERSION，LiveData的默认开始版本值

然后是LiveData的构造函数

public LiveData(T value) {
        //有默认值
        mData = value;
        //version=1
        mVersion = START_VERSION + 1;
    }
     //无默认值
    public LiveData() {
        mData = NOT_SET;
        mVersion = START_VERSION;
    }

我们先分析一下LiveData如何添加一个Observer的过程，先分析observe方法，平常使用它的频率也较高

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        //必须在主线程调用
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //把我们的owner和observer包裹成LifecycleBoundObserver对象
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //判断之前是否存在这个对象，LifecycleBoundObserver是继承了ObserverWrapper的
        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;
        }
        //把该wrapper添加到生命周期的观测当中
        owner.getLifecycle().addObserver(wrapper);
    }

这个过程就是把我们的Observer对象存入mObservers中，存入的过程把它包装了一些，与Lifecycle比较的类型。其中ObserverWrapper也是一个抽象类，LifecycleBoundObserver实现了它并且可以根据生命周期判断是否需要通知观测者。

private abstract class ObserverWrapper {
        //观察者对象
        final Observer<? super T> mObserver;
        //是否处于激活态，激活的时候才可以被通知
        boolean mActive;
        //开始的版本
        int mLastVersion = START_VERSION;
        ObserverWrapper(Observer<? super T> observer) {
            mObserver = observer;
        }
        //是否应该处于激活态
        abstract boolean shouldBeActive();
        //是否依附到LifecycleOwner这个生命周期组件中
        boolean isAttachedTo(LifecycleOwner owner) {
            return false;
        }
        //mObserver不在需要观测的时候调用这个方法
        void detachObserver() {
        }
        //激活状态改变的时候
        void activeStateChanged(boolean newActive) {
            if (newActive == mActive) {
                //新旧一样则不处理
                return;
            }
            //激活状态改变
            mActive = newActive;
            //调用changeActiveCounter
            changeActiveCounter(mActive ? 1 : -1);
            if (mActive) {
                //假如是出于激活态的，则进行事件通知
                dispatchingValue(this);
            }
        }
    }

然后我们看与生命周期关联的LifecycleBoundObserver

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @NonNull
        final LifecycleOwner mOwner; //生命周期组件
        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            mOwner = owner;
        }
        //只有生命周期是至少出于STARTED的时候，也就是onStart，onResume，onPause这三个状态
        //只有这时候才是出于激活态，不是的话就出于非激活态，非激活态的时候是不会把事件通知给Observer的
        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
            if (currentState == DESTROYED) {
                //假如生命周期组件destroy的时候，把该mObserver通LiveData的mObservers中移除
                removeObserver(mObserver);
                return;
            }    
            Lifecycle.State prevState = null;
            while (prevState != currentState) {
                prevState = currentState;
                //判断是否需要数据变换，同时更改是否处于激活态
                activeStateChanged(shouldBeActive());
                //预防执行activeStateChanged的时候mOwner的状态更改
                currentState = mOwner.getLifecycle().getCurrentState();
            }
        }
        //假如传入的生命周期组件与当前的一直则认为是依附者在传入的owner中的
        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }
        //不在需要的时候调用该方法，那么讲不在需要数据观测
        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

经过这个过程分析，我们可以知道，使用observe进行观测的Observer的回调被调用只会发生在onStart，onResume，onPause中，那么是否那些在onCreate，onstop进行通知的事件是否Observer将不会知道呢，我们接着看他的，首先是changeActiveCounter方法

@MainThread
    void changeActiveCounter(int change) {
        //他是在ObserverWrapper的activeStateChanged方法被调用，假如ObserverWrapper处于激活态，则change为1，否则是-1
        int previousActiveCount = mActiveCount;
        //当前激活的数量
        mActiveCount += change;
        if (mChangingActiveState) {
            //是否是处于分发激活或者是非激活调用当中，如果处于则返回
            return;
        }    
        //标记为处于
        mChangingActiveState = true;
        try {
           //当激活的与上一次的不一致，也就是changeActiveCounter方法处于执行while阶段的又被继续调用了
            //那么将需要使用while循环直到他们一致
            while (previousActiveCount != mActiveCount) {
               //假如之前的激活数量是0，但是现在的mActiveCount大于0，则表明需要调用激活方法
                boolean needToCallActive = previousActiveCount == 0 && mActiveCount > 0;
               //假如之前激活的数量是>0，现在是出于0，则不必调用
                boolean needToCallInactive = previousActiveCount > 0 && mActiveCount == 0;
                 //把当前赋值给previousActiveCount
                previousActiveCount = mActiveCount;
                if (needToCallActive) {
                    //假如是需要激活的调用该方法，他是一个空方法，自定义LiveData可以执行自己被激活的时候的逻辑
                    onActive();
                } else if (needToCallInactive) {
                  //假如是是出于非激活的调用该方法，他是一个空方法，自定义LiveData可以执行自己转为非激活的时候的逻辑
                    onInactive();
                }
            }
        } finally {
            //完成调用
            mChangingActiveState = false;
        }
    }

接下来是核心的数据更新通知方法

void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            //假如有数据通知正在执行则返回，同时通知循环体有新数据进入了
            mDispatchInvalidated = true;
            return;
        }
        //标记为dispatchingValue正在执行
        mDispatchingValue = true;
        do {
            //重置外部是否有数据通知
            mDispatchInvalidated = false;
            if (initiator != null) {
                //有初始化的则先通知该Observer
                considerNotify(initiator);
                initiator = null;
            } else {
                //没有初始化的则把所有的ObserverWrapper递归进行通知
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

然后看最终通知Observer的considerNotify方法

private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            //假如不是处于激活态则不通知，从这里我们可以看出LifecycleBoundObserver的只会在onStart，onResume和onPuase中才会执行
            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()) {
            //这里还判断了一次，以防mActive没有更新到
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
             //mVersion的版本需要大于mLastVersion，避免重复通知
            return;
        }
        //把mVersion赋值给mLastVersion，单号调用Observer的通知方法
        observer.mLastVersion = mVersion;
        observer.mObserver.onChanged((T) mData);
    }

这就是整个流程了，我们再梳理一次：对于使用observe(LifecycleOwner owner,Observer<? super T> observer)注册的Observer而已，通知的执行顺序是(暂不考虑setValue的)：

1. 当声明周期发生变化，会调用LifecycleBoundObserver的onStateChanged，假如生命周期组件已经DESTROYED了，则把该Observer从观察者mObservers中移除，否则调用activeStateChanged更改自身的激活态变量
2. 更改的激活态值是通过shouldBeActive获取，假如不是onStart，onResume，onPause则是false，是则为true
3. activeStateChanged中调用changeActiveCounter，通知LiveData有数据变为激活或者是非激活
4. 然后调用dispatchingValue进行递归，对所有的Observer调用considerNotify进行通知
5. considerNotify中对是否进行通知进行最终判断，假如是激活态的，而且是没有通知过的(即mLastVersion<mVersion)进行通知

这就是大体的数据更新通知流程，然后我们看除了生命周期变化会触发通知以外，还有postValue(T value)和setValue(T value)，前者最终是通过Handle调用了后者，我们先看前者

protected void postValue(T value) {
       boolean postTask;
       //防止并发
       synchronized (mDataLock) {
           //是否应该post，假如上一次的post没有执行完成之前，则为true
           postTask = mPendingData == NOT_SET;
           //记录最后的数据
           mPendingData = value;
       }
       //假如上一次的还没有执行完，则不会继续分发通知
       if (!postTask) {
           return;
       }
       //调用mPostValueRunnable分发回主线程
       ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
   }

通过这个方法我们知道假如说同时调用了多次postValue(value)，那么他只会记录最后一次的value，然后使用这个value去分发，然后我们看mPostValueRunnable

private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
           //记录新值
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                //把mPendingData重置，这时候外部调用postValue才会执行分发
                mPendingData = NOT_SET;
            }
            //调用setValue
            setValue((T) newValue);
        }
    };

然后我们看setValue

protected void setValue(T value) {
        assertMainThread("setValue");
        //把LiveData的被调用次数，也就是版本号+1
        mVersion++;
        //记录需要分发的值
        mData = value;
        //进行分发
        dispatchingValue(null);
    }

这就是整个数据外部更新的过程。

然后我们来思考一个问题，假如我们的Activity处于onStop/onCreate阶段，外部调用了setValue或者是postValue，这时候会发生什么情况

首先，我们的Observer不会立即接收到数据，因为这时候是处于非激活态
LiveData的mVersion会+1
假如说我们的Activity执行到onStart，onPause，onResume，这时候会触发LifecycleBoundObserver的onStateChanged方法，然后把Observer设置为激活态
触发之后他会调用数据通知，数据通知的时候我们的Observer的mLastVersion是小于LiveData的mVersion，所以这时候才会去通知Observer

通过上面流程我们得到，使用了observe方法注册的Observer，他在页面处于onCreate，onStop的时候是不会接受到数据更新的，只有onStart，onPause，onResume才会，这是我们使用注意的点。

还有一点就是我们的LiveData构造函数是带有一个默认值的，这时候我们先生成了LiveData，然后再去注册Observer，改Observer是否会接受到通知呢？答案是能？因为我们使用了LifecycleBoundObserver，他注册了之后Activity会自身的状态给它。即调用它的onStateChanged方法。所以假如我们的LiveData有默认值，那么每一个新注册的Observer都会被调用一次(激活态的时候，就算当时不是，后续转为激活态也会调用)

那有没有即时接受到数据更新的Observer呢？有，就是使用我们的observeForever(Observer<? super T> observer)，

public void observeForever(@NonNull Observer<? super T> observer) {
        assertMainThread("observeForever");
        //使用了AlwaysActiveObserver对Observer对象进行包裹
        AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
        //存入mObservers中
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing instanceof LiveData.LifecycleBoundObserver) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        //立即进行通知
        wrapper.activeStateChanged(true);
    }

可以看到他是使用了AlwaysActiveObserver，而且是立马就会同步当前的LiveData的数据给该Observer，我们看下AlwaysActiveObserver的代码

private class AlwaysActiveObserver extends ObserverWrapper {

        AlwaysActiveObserver(Observer<? super T> observer) {
            super(observer);
        }

        @Override
        boolean shouldBeActive() {
            //可以从这里看他，该Observer是一直处于激活态的，也就是只要有数据更新了，那么它就会被调用
            return true;
        }
    }

这就是可以立即收到数据更新的Observer了，我们再看下其他的源码，

//移除单个Observer
public void removeObserver(@NonNull final Observer<? super T> observer) {
    ObserverWrapper removed = mObservers.remove(observer);
    if (removed == null) {
        return;
    }
    removed.detachObserver();
    removed.activeStateChanged(false);
}
//移除整个LifecycleOwner所属的Observer
public void removeObservers(@NonNull final LifecycleOwner owner) {
    assertMainThread("removeObservers");
    for (Map.Entry<Observer<? super T>, ObserverWrapper> entry : mObservers) {
        if (entry.getValue().isAttachedTo(owner)) {
            removeObserver(entry.getKey());
        }
    }
}

这就是LiveData的整体源码分析了。

数据倒灌和EventBus

我们通过上面的源码分析，发现可以把LiveData改造成简单的EventBus，或者是总数据源。比如我们有这样的一个需求，我们有一个用户信息，他是全局的，很多的Activity都会使用到，同时假如用户信息更新了，我们的Activity也需要知道，这就可以利用LiveData进行处理。关于他的好处可以看Android消息总线的演进之路：用LiveDataBus替代RxBus、EventBus

由于我们的LiveData新增Observer的时候，他会把上一次的值通知给该Observer，即LiveData自动执行了一次setValue操作或者叫做发送了一次stick事件，这是不可以接受的，美团的解决方案是通过发生的方式，对于使用了observe方法的，把所属的LiveData的mVersion字段赋值给该Observer的mLastVersion，对于observeForever它将不会收到回调。
还有一种是继承LiveData，重写他的关键方法，具体可以看LiveData 数据倒灌，他给Observer添加一层限制来实现，使用HashMap<Integer, Boolean>，当value为true的时候是不接受时间，false的时候接受，

private void observe(@NonNull Integer storeId,
                         @NonNull LifecycleOwner owner,
                         @NonNull Observer<? super T> observer) {

        if (observers.get(storeId) == null) {
            observers.put(storeId, true);
        }
        super.observe(owner, t -> {
            if (!observers.get(storeId)) {
                observers.put(storeId, true);
                if (t != null || isAllowNullValue) {
                    observer.onChanged(t);
                }
            }
        });
    }

上面两个方案的实现源码可以看：UnPeek-LiveData和LiveEventBus
我们可以使用一个全局的ViewModel，有一个LiveData变量承载用户信息。全局的ViewModel可以在Application创建一个ViewModelProvider然后去创建这个ViewModel。