LiveData源码解析

livedata中最主要的两个方法就是observe和setValue方法，observe是注册观察者，setValue是设置数据并通知观察者。

1 observe

observe的源码如下所示：

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, 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;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

@MainThread表示该方法在主线程中执行，它需要传入两个参数，第一个是LifecycleOwner，第二个是观察者对象。首先通过LifecycleOwner获取LifecycleRegistry对象，然后获取当前状态，判断LifecycleOwner是否处于DESTROYED状态，如果是则不处理直接返回。如果不是，则将owner和observer用LifecycleBoundObserver进行包装，然后将observer放在mObservers中，mObservers也是一个map类型。如果map中存在则putIfAbsent返回不为对应的wrapper对象，否则返回为null。这里判断如果map中存在，且要添加的owner和map中存在的owner不是同一个，则抛异常。如果存在但且是同一个owner，则直接返回。否则调用owner的getLifecycle方法获取LifecycleRegistry，将wrapper添加到LifecycleRegistry中。

总结：首先LiveData必须在主线程中使用，如果绑定的对象生命周期处于DESTROYED状态，则此次不添加观察者。然后判断添加的观察者是否之前存在，如果不存在才会添加观察者。

2 setValue

接下来看一下setValue源码：

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

代码很少，调用了dispatchingValue，且传入的值还是null，接下来看一下dispatchingValue方法：

    @SuppressWarnings("WeakerAccess") /* synthetic access */
    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {//上面传入的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;
    }

可以看到首先有个do{}while循环，在循环体中，会迭代mObservers，从中获取ObserverWrapper，在observe中，我们知道，ObserverWrapper实际是LifecycleBoundObserver。所以considerNotify的入参是LifecycleBoundObserver类型。在看看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;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        observer.mObserver.onChanged((T) mData);
    }

最主要的是最后一行代码，我们知道，LifecycleBoundObserver封装了用户传进来的observer和lifecycleOwner，所以这里调用observer.mObserver.onChanged就是直接调用用户传进来的observer的onChanged。

总结：setValue相当于观察者里面的notifyObserver角色，将值的改变通知观察者。只是这里面跟lifecycleOwner的生命周期绑定了而已。

总结：LiveData使用观察者模式，且还依赖了Lifecycle观察者模型，LiveData的observe方法会将观察者注册在LiveData中，同时还会注册到LifecycleRegistry中。LiveData中的观察者进行了一层封装，observe注册的观察者是Observer，最后作为成员变量被封装在LifecycleBoundObserver父类中，所以LiveData通知观察者是调用Observer的onChanged方法，而LifecycleRegistry通知观察者是调用LifecycleBoundObserver的onStateChanged方法。

原理总结：LiveData是基于观察者模式实现的，它使用Lifecycle与所在组件的生命周期绑定。它有两个重要的方法，一个是observe，一个是setValue。observe方法必须在主线程中执行，并且，它会先判断与之绑定的组件的生命周期是否处于DESTROYED状态，如果是，则不添加观察者；如果不是，则继续判断之前是否添加过该观察者对象，如果没有添加，才会将观察者对象添加进去。setValue方法相当于观察者里面的notifyObserver，就是设置值的时候通知观察者。