Livedata源码详细解析-面试这么讲就ok

附上一篇Livedata使用篇

Livedata使用篇

时序图

不太擅长画图，勉强画了一幅

如果您对Livedata的源码有一定了解看了这个图应该就差不多了。

如果对Livedata源码了解不多，那么粗略看一下图，然后直接看后面的逻辑。看完逻辑回过头再细看时序图效果更佳

Livedata 方法调用简单说明

既然是源码解析，自然入口就是我们的方法调用，这里简单把注册 Livedata 的数据监听和 Livedata.setValue 方法进行简单说明

注册监听代码

mapViewModel.mapLiveData.observe(this,{//这个回调中会收到数据更改的监听
            logEE(it)
            tv_map.text=it
        })

数据更改，发送数据

 val userLivedata =MutableLiveData<User>()
 fun sendData() {
        userLivedata.value=User("李白",1200)//这句代码发送最新数据
    }

下一节就是 Livedata 的工作流程简单分析了

Livedata 代码逻辑

我主要把代码逻辑分为了三部分：

1. 业务代码 Livedata.observe 注册数据观察

2. setValue 发送最新数据

3. 用户视图回到前台自动进行数据分发

第一部分逻辑：

基本的逻辑就是我们注册数据监听的时候，会传入一个 LifeCycle 的数据监听者接口。Livedata 的 observe 方法会将接口封装成一个 LifecycleBoundObserver对象，并且注册 LifeCycle 的生命周期监听。

第二部分逻辑：

当我们调用 Livedata.setValue 方法的时候，会逐个遍历每一个注册的 LifecycleBoundObserver，然后分别调用 Observer 的 onChange 回调方法向我们的业务数据监听返回数据

第三部分逻辑：

因为我们注册了 LifeCycle 的生命周期，当用户视图回到前台的时候会回调 LifecycleBoundObserver 的 onStateChanged 方法。onStateChanged 方法内会进行数据的分发

本节讲了 Livedata 的基本逻辑，下一节主角就是代码了

结合代码讲解逻辑

注册 Livedata 监听

1. observe 方法体

 public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {//如果生命周期已经被销毁，return。这说明了使用Livedata不会发生内存泄露的原因
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);//这个对象是LifecycleEventObserver的一个实现，是我们注册生命周期组件的观察者
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);//将wrapper加入到map中，得到上一个wrapper,
        if (existing != null && !existing.isAttachedTo(owner)) {//isAttachedTo：上一个wrapper关联的生命周期如果不是当前生命周期，就抛出异常
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {如果上一个wrapper不为空就return（因为会复用上一个wrapper）
            return;
        }
        owner.getLifecycle().addObserver(wrapper);//如果上一个为空则说明是第一次，需要注册生命周期监听
    }

Livedata.setValue

1. 首先看一下 setValue 方法体：

 protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;//数据的版本，每次调用setValue都会++
        mData = value;
        dispatchingValue(null);//分发数据
    }

2. 我们发现方法最后调用了 dispatchingValue 方法，那么就再看一下 dispatchingValue 方法体吧

void dispatchingValue(@Nullable ObserverWrapper initiator) {
	        if (mDispatchingValue) {// 1、如果正在分发中则返回
	            mDispatchInvalidated = true;// 2、目的是如果有新的setValue方法被调用，会在步骤4中跳出for循环，重新再进行一次分发
	            return;
	        }
	        mDispatchingValue = true;、// 3、设置正在分发中状态为true，防止1中重复进入分发消息
	        do {
	            mDispatchInvalidated = false;// 4、进入循环后设置mDispatchInvalidated为false，如果用户重新setValue需要将mDispatchInvalidated重新设置为true，一边可以在上一轮分发结束后继续走一轮分发
	            if (initiator != null) {
	                considerNotify(initiator);// 5、分发消息
	                initiator = null;
	            } else {
	                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
	                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
	                    considerNotify(iterator.next().getValue());// 6、循环中分发消息
	                    if (mDispatchInvalidated) {//6、如果这里为true说明用户又设置了一次value，那么跳出for循环，重新执行外层的dowhile循环
	                        break;
	                    }
	                }
	            }
	        } while (mDispatchInvalidated);
	        mDispatchingValue = false;//7、消息分发完成，设置正在分发中状态为false
    	}

3.通过分析，我们发现 dispatchingValue 方法内最终再次分发消息的方法是 considerNotify，方法体：

private void considerNotify(ObserverWrapper observer) {
			        if (!observer.mActive) {//1、如果当前lifecycle不是活跃状态就返回不进行消息分发,销毁会在生命周期最近变活跃的时候自动分发
			            return;
			        }
			        if (!observer.shouldBeActive()) {//2、如果lifecycle状态为started||resumed
			            observer.activeStateChanged(false);//3、激活状态，activeStateChanged方法里面会再次调用dispatchValue分发消息，一般用作livedata从不活跃状态回到活跃状态的时候自动分发消息
			            return;
			        }
			        if (observer.mLastVersion >= mVersion) {//4、如果true，说明第6步中有更小版本的消息正在调用，所以返回
			            return;
			        }
			        observer.mLastVersion = mVersion;//5、记住当前正在分发value的版本,用于第四部中的逻辑判断
			        observer.mObserver.onChanged((T) mData);//6、调用注册livedata的observer的onChanged通知用户更新数据
			    }

considerNotify 方法中调用了 mObserver.onChanged 后就会回调我们业务代码中的消息注册监听，整个数据流转的逻辑就完成了

视图重新回到前台

逻辑同 Livedata.setValue

我们知道我们是通过 LifeCycle 生命周期组件来监听生命周期的。

监听生命周期的接口实现就是 LifecycleBoundObserver 类，当生命周期发生改变的时候会回调 LifecycleBoundObserver 类的方法 onStateChanged：

1. onStateChanged 方法体如下

public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
            if (currentState == DESTROYED) {//如果生命周期已经销毁，那么移除监听者
                removeObserver(mObserver);
                return;
            }
            Lifecycle.State prevState = null;
            while (prevState != currentState) {//回调的生命周期状态和当前不同，则进行数据回调
                prevState = currentState;
                activeStateChanged(shouldBeActive());//这个方法是关键，他内部会进行数据的分发
                currentState = mOwner.getLifecycle().getCurrentState();//重置生命周期状态
            }
        }

2. activeStateChanged 方法体

void activeStateChanged(boolean newActive) {
            if (newActive == mActive) {
                return;
            }
            mActive = newActive;
            changeActiveCounter(mActive ? 1 : -1);
            if (mActive) {
                dispatchingValue(this);//看到这里你直接去找上一节Livedata.setValue的源码分析就ok了
            }
        }

postValue

实际没啥好说的，就是将线程切回到主线程，然后调用 Livedata.setValue 更新数据而已。

最后，更重要的在下面：

关注公众号学习更多知识