带你们看LiveData源码,不一知半解算我输好吗

看下使用好不好,没想到真是简洁的离谱啊,好了,我们从这里开始观察

val getTopTabLiveData by lazy {  MutableLiveData<Boolean>() }
...
viewModel.getTopTabLiveData.observe(this){
     // do some thing    
}

observer()做了什么

将指定事件跟生命周期绑定

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        // 判断生命周期为销毁,则忽略
        if (owner.getLifecycle().getCurrentState() == DESTROYED) return;
        // 实例一个新的生命周期绑定观察者
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 判断是否之前已经赋值,来防止有煞笔重复调用,专治代码水土不服
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        // 注意看LifecycleBoundObserver.isAttachedTo()
        // 如果之前已经赋值但又有煞笔在不同LifecycleOwner(生命周期管理者)中调用,话不多说,直接给crash,google就是牛逼
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        // 如果已经赋值且上面煞笔处理没问题,就不再做处理了
        if (existing != null) {
            return;
        }
        // 看到了没有,核心啊,精髓啊,给当前LifecycleOwner加入Observer(观察者),在生命周期各个阶段响应事件
        owner.getLifecycle().addObserver(wrapper);
    }

看看mObservers.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);
        // 返回代表之前不存在的null值,这就是理解有木有 
        return null;
    }

看看LifecycleBoundObserver :

    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @NonNull
        // 生命周期管理者
        final LifecycleOwner mOwner;
        // 看到这里没,直接赋值了,有什么好说的
        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            mOwner = owner;
        }

        // 有点意思,这里判断是否处在活跃状态,就可以他妈的做正确的生命周期回调响应
        @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();
            // 若生命周期已为销毁状态, 则移除 observer, 避免内存泄露
            if (currentState == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            Lifecycle.State prevState = null;
            while (prevState != currentState) {
                prevState = currentState;
                activeStateChanged(shouldBeActive());
                currentState = mOwner.getLifecycle().getCurrentState();
            }
        }
        // 判断两个生命周期管理者是否为同一个
        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

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

好了到这LiveData.observe()已经观察完毕了,到看看LiveData.postValue()了, 别说,google还是有点讲究的,看看这个官方提示:

liveData.postValue("a");// 异步传值
liveData.setValue("b"); //同步传值
// 结果: 值“b”将首先设置，然后主线程将用值“a”覆盖它。
// 如果在此主线程执行postValue()之前多次调用postValue()，则只会调度最后一个值

postValue()做了什么

他妈的,还能做什么,就是传值啊,这还用说的文章到此结束了,不会吧,不会吧,异步传值得注意处理多线程下的共享变量问题呢

...
protected void postValue(T value) {
   boolean postTask;
   synchronized (mDataLock) {
     // 判断之前是否已经赋值过了
     postTask = mPendingData == NOT_SET;
     // 给mPendingData赋值 
     mPendingData = value;
   }
   // 看到没有,他妈的,之前已经赋值就return了,好气哦,干嘛这样呢
   // 嘿,看下mPostValueRunnable没有,他就是防止煞笔多线程下多次赋相同值做的
   if (!postTask) return;
   // 把传值线程放到主线程执行
   ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
...
// 未赋值状态
static final Object NOT_SET = new Object()
// 默认就是未赋值状态
volatile Object mPendingData = NOT_SET
// 传值线程
private final Runnable mPostValueRunnable = new Runnable() {
  @SuppressWarnings("unchecked")
  @Override
  public void run() {
    // 看到没有,真正传值都是通过newValue来传的好不好
    Object newValue;
    synchronized (mDataLock) {
      newValue = mPendingData;
      // 嘿嘿,这里回归默认未赋值状态了
      mPendingData = NOT_SET;
    }
    // 最终还是调到setValue啊,果然啊,条条道路通setValue啊
    setValue((T) newValue);
  }
};

setValue()

有什么好说的,其他的一枪秒了,我才是传输数据的核心代码好不好,屁,dispatchingValue才是

// 设置传输数据。 如果有活跃的ObserverWrapper(观察者)，值将被分发给他们。    
protected void setValue(T value) {
  assertMainThread("setValue");
  mVersion++;
  mData = value;
  dispatchingValue(null);
}
@SuppressWarnings("WeakerAccess") /* synthetic access */
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;
}
...
private void considerNotify(ObserverWrapper observer) {
        // 如果生命周期管理者已经销毁,则忽略
        if (!observer.mActive) {
            return;
        }
        // 在分发之前检查下最先状态,如果不在活跃阶段,则不改变状态
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        // 判断version , 因为从上面来看,每次赋值version都会变得
        // 他妈的的,这样就不会陷入多次分发,保证只取最先的传值
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        // 执行每个生命周期管理者的观察者的事件分发
        observer.mObserver.onChanged((T) mData);
}

get到没有?