LiveData详解

先奉上LiveData官方文档地址：

https://developer.android.com/topic/libraries/architecture/livedata

LiveData是什么？

1、LiveData是一种可观察的数据存储器类。通俗点说就是存储数据，同时可以被观察者观察数据的变化。

2、LiveData具有生命周期感知能力（这玩意儿是不是很眼熟，参考上篇Lifecycle），这种感知能力可确保LiveData仅更新处于活跃生命周期状态的应用组件观察者。

LiveData原理分析

首先看LiveData类的observe方法，observe和observeForever的区别在于，observeForever无视生命周期，只要数据改变就会回调通知observer。observe方法主要做了下面几件事儿：

• 绑定的组件生命周期状态为DESTROYED的时候, 则会忽视订阅请求
• 将 LifecycleOwner 和 Observer 封装成支持生命周期感知的LifecycleBoundObserver类
• 观察者只能与一个owner绑定，不允许重复注册
• 利用Lifecycle，把观察者注册到LifecycleBoundObserver里面去，从而监听宿主生命周期状态的变化

    // 添加跟生命周期相关的 observer
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        // 若 LifecycleOwner 被销毁,则忽略该 observer
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            return;
        }

        // 将 LifecycleOwner 和 Observer 封装成支持生命周期感知的LifecycleBoundObserver
        //下面再解析
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 避免重复添加相同的observer
        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;
        }

        // 实现对 LifecycleOwner 生命周期的感知  这里可以见lifecycle详解
        owner.getLifecycle().addObserver(wrapper);
    }

    // 无视生命周期, 每次数据发生变化时,都会回调通知 Observer
    // 需要手动在不需要时移除 Observer
    @MainThread
    public void observeForever(@NonNull Observer<T> observer) {
        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);
    }

添加宿主生命周期的监听后（owner.getLifecycle().addObserver(wrapper)）里面的主要逻辑方法到---》ObserverWithState（dispatchEvent）---》LifecycleBoundObserver（onStateChanged）中间是Lifecycle处理逻辑之前花篇幅写过，为了偷懒这里不做过多解释=。=从LifecycleBoundObserver（onStateChanged）开始讲。

//前面Livedata的observe中有用到dLifecycleBoundObserver是LiveData内部类
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() {
        //组件生命周期状态为活跃时只有2种情形，started和resume
        //观察者是否活跃就等价于宿主的状态是否大于等于STARTED；
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }
 
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source,
            @NonNull Lifecycle.Event event) {
        //当接收到宿主生命周期的DESTROYED 事件时会自动解除跟 owner 的绑定
        //所以我们不用去手动移除观察者
        if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
            removeObserver(mObserver);
            return;
        }
        //宿主的状态发生了变化时，此时会判断宿主是否处于活跃状态，
        //如果页面不处于活跃状态，即使状态改变，此时也不会被分发，可以避免后台任务抢占资源,当页面        
        //重新处于活跃状态才会分发。
        activeStateChanged(shouldBeActive());
    }
 
    @Override
    boolean isAttachedTo(LifecycleOwner owner) {
        return mOwner == owner;
    }
 
    @Override
    void detachObserver() {
        mOwner.getLifecycle().removeObserver(this);
    }
}
 

下面进入ObserverWrapper （activeStateChanged）

        void activeStateChanged(boolean newActive) {
            //宿主的活跃状态发生改变时才会往下走，否则直接结束该方法
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            //把新观察者状态赋值给mActive
            mActive = newActive;
            //判断此前处于活跃状态的观察者数是否为0
            boolean wasInactive = LiveData.this.mActiveCount == 0;
        //如果该观察者是由不活跃变为活跃时，则先将处于活动状态的观察者个数加1，否则-1
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            
            if (wasInactive && mActive) {
            //此前没有活跃者，且该观察者由不活跃变活跃
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
            //该观察者是由活跃变不活跃 且之后LiveData中不存在活动状态的观察者
                onInactive();
            }
            if (mActive) {
                //该观察者由不活跃变活跃
                dispatchingValue(this);
            }
        }

mActive表示这个观察者是不是活跃状态【组件生命周期状态为活跃时只有2种情形，started和resume，观察者是否活跃就等价于宿主的状态是否大于等于STARTED】

onActive()和onInactive()都是空方法，可以由开发自己继承去做一些操作。该观察者由不活跃变活跃，进入dispatchingValue(this);

//该方法在两个地方有调用。
//1、在宿主生命周期发生变化的时候。回调LifecycleBoundObserver的onStateChanged方法。最后会调到这个方法，传入this(LifecycleBoundObserver)；也就是上边分析的流程
//2、在setValue的时候调用。传入null;
void dispatchingValue(@Nullable ObserverWrapper initiator) {
    // 当前正在处于分发数据中   直接return，继续之前的分发
    if (mDispatchingValue) {
        mDispatchInvalidated = true;
        return;
    }
    mDispatchingValue = true;
    do {
        //进该方法体就是有效分发了
        mDispatchInvalidated = false;
        //宿主生命周期状态变化initiator != null; setValue时initiator = null;
        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;
}

dispatchingValue方法在两个地方有调用。
1、在宿主生命周期发生变化的时候。回调LifecycleBoundObserver的onStateChanged方法。最后会调到这个方法，传入this(LifecycleBoundObserver)；也就是上边分析的流程
2、在setValue的时候调用。传入null;-------------------这个后面会讲解

下面进入considerNotify

private void considerNotify(ObserverWrapper 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;
        }
        //判断观察者的最新版本号如果不小于LiveData的当前版本号，那么观察者的数据就是最新，  
        //说明不需要更新，直接退出方法
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        //将livedata版本号赋值给observer最新版本号
        observer.mLastVersion = mVersion;
            // 回调 onChanged方法就是我们监听到数据源发生改变做的处理逻辑了。
        observer.mObserver.onChanged((T) mData);
    }

LiveData有一个版本号，观察者也有一个最新版本号。当LiveData的数据发生变化，版本号+1，每次更新观察者的数据时，会将观察者的最新版本号置为LiveData的当前版本号。所以两者相等，则表示观察者拿到的数据是最新的。
所以这里就会，否则就将最后版本号的值值为LiveData的当前版本号，再更新数据，更新数据就是调用observer的onChanged方法。

总结：

注册的流程：

LiveData（observe） ---》 LifecycleRegistry（addObserver）---》ObserverWithState（dispatchEvent）---》LifecycleBoundObserver（onStateChanged）     ---》ObserverWrapper （activeStateChanged）---》LiveData（dispatchingValue）---》LiveData（considerNotify）---》Observer（onChanged）最终就到数据的onChange回调了。

再看看LiveData更新数据时的过程setValue和postValue

//LiveData.java
protected void postValue(T value) {
    boolean postTask;
    synchronized (mDataLock) {
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    if (!postTask) {
        return;
    }
    //从工作线程切换到UI线程，通过创建一个Handler关联到主线程的Looper，
    //调用了post方法提交一个Runnable，切换到主线程去执行run方法中的逻辑
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}



//单例模式，返回一个ArchTaskExecutor对象        
public static ArchTaskExecutor getInstance() {
    if (sInstance != null) {
        return sInstance;
    }
    synchronized (ArchTaskExecutor.class) {
        if (sInstance == null) {
            sInstance = new ArchTaskExecutor();
        }
     }
    return sInstance;
}


@Override
public void postToMainThread(Runnable runnable) {
    if (mMainHandler == null) {
        synchronized (mLock) {
            if (mMainHandler == null) {
                //创建一个关联到主线程Looper的Handler
                mMainHandler = createAsync(Looper.getMainLooper());
            }
        }
    }
    //noinspection ConstantConditions
    mMainHandler.post(runnable);
}

private final Runnable mPostValueRunnable = new Runnable() {
    @SuppressWarnings("unchecked")
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {
            newValue = mPendingData;
            mPendingData = NOT_SET;
        }
        //还是调用setValue
        setValue((T) newValue);
    }
};

@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    mVersion++;
    mData = value;
    dispatchingValue(null);
}

postValue最终会调用setValue，UI线程中一般使用的是setValue()，而在非UI线程中我们必须使用postValue()。dispatchValue方法开始已经在上面分析过了。

总结

发送数据时的流程：

LiveData（setValue/postValue）---》LiveData（dispatchingValue）                                      --->LiveData（considerNotify）--->Observer（onChanged）

多多批评指正吧~