LiveData使用和源码解析

上一篇中讲了Lifecycle，如果你想使用MVP模式开发，那么就可以让P层利用Lifecycle的这个特性，那么P层就可以感知到生命周期，这对P层来说是一个比较大的提升，当然这只是Lifecycle的一种运用，这里要说的是Lifecycle的另一种运用，那就是LiveData的，它的设计使用了观察者模式，当数据变化时可以自动去更新UI，通过对它的使用，，可以让我们更加专注于逻辑的处理。

LiveData使用

public class SecondActivity extends AppCompatActivity {
    private static final String TAG = "SecondActivity";
    private MutableLiveData<String> data  = new MutableLiveData<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        TextView textView = findViewById(R.id.textView);
        data.observe(this, new Observer<String>() {
            @Override
            public void onChanged(@Nullable String s) {
                textView.setText(s);
            }
        });
        findViewById(R.id.start).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                data.setValue("tangedegushi");
            }
        });
    }
}

上面的代码还是比较的简单的，使用可以简单的概略为三步：

1. 创建一个MutableLiveData对象，这个对象的主要职责就是存放数据；
2. 给MutableLiveData设置一个观察者，这个观察者（Observer）在设置数据或是数据改变是就会被回调；
3. 给MutableLiveData设置数据；
   这三步做完后，MutableLiveData的完整使用就完成了。接下来看看是如何实现的，先看MutableLiveData：

public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

继承自LiveData，然后调用父类的方法（LiveData的这两个方法是protected的），这里主要就是设置数据使用，这里提供的两个方法是有区别的，主要是postValue（）可以在子线程使用，这就是他们用法的区别，LiveData的代码并不是很多，感兴趣的可以全部去看看，这里以代码片段来慢慢分析，首先需要看的是observe（），添加一个观察者：

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //这里将Observer传进去了，目的视为了在生命周期事件中执行事件，下面会分析到
        //LifecycleBoundObserver间接继承了Lifecycle
        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;
        }
        //给Lifecycle添加观察事件，以便可以生命周期事件可以执行
        owner.getLifecycle().addObserver(wrapper);
    }
    class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
            super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {
        //这里是为了确定observer中事件什么时候才可以执行，状态要不小于STARTED才会执行，也就是说数据的设置或是改变要在onStart（）方法后才是有效的
        //在onStart()调用之后和onStop()调用之前这里返回的都是true
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

		//在生命周期发生变化时，对应的事件就会执行到这里，上一篇文章已经说到了
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        //当执行activity的onDestroy（）时，会将之前添加的observer从集合中移除掉
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
        //当执行activity的onDestroy（）时会执行到，移除Lifecycle中的观察者
            mOwner.getLifecycle().removeObserver(this);
        }
    }
    private abstract class ObserverWrapper {
        final Observer<T> mObserver;
        boolean mActive;
        int mLastVersion = START_VERSION;

        ObserverWrapper(Observer<T> observer) {
            mObserver = observer;
        }

        abstract boolean shouldBeActive();

        boolean isAttachedTo(LifecycleOwner owner) {
            return false;
        }

        void detachObserver() {
        }

        void activeStateChanged(boolean newActive) {
        //mActive一开始默认是false的，在onStart执行前，传进来的newActive都是为false的，也就是说一开始添加进来的observer在onStart()方法执行前是不会执行的
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
            //有添加进来的observer，但还没有执行，在onStart（）之后，这个方法会执行一次，在所有的observer之前执行
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
            //在LivaData没作用了，也就是说要被销毁了，这个时候就会执行这里
                onInactive();
            }
            if (mActive) {
            //开始派发到observer去处理事务，也就是添加进来的observer可以被执行了
                dispatchingValue(this);
            }
        }
    }

总结下上面主要的逻辑流程是，在添加observer的时候，其实就是在Lifecycle中添加一个LifecycleObserver，这样就可以在对应的生命周期去处理observer的，当然对于这个observer的回调并不是一直都会被调用，只有在数据被改变或是数据被设置的时候才会被调用，下面就来看看dispatchingValue(this)的执行逻辑：

    private void dispatchingValue(@Nullable ObserverWrapper initiator) {
    //当前正在处理observer，这里就直接返回，mDispatchInvalidated的赋值全都是在这里，逻辑还比较好理解
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
            //通过生命周期转发过来的就执行当前的，这是因为每个LicycleObserver都会接收到对应的生命周期事件
                considerNotify(initiator);
                initiator = null;
            } else {
            //这里就是将所有添加进来的observer遍历一遍执行
                for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

不管是生命周期触发还是设置值，最终调用的都是considerNotify（）方法：

    private void considerNotify(ObserverWrapper observer) {
    //当前的observer是否是处于激活的状态，这个在onStart()之前是为false的
        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.
        //根据当前activity所处的状态判断是否需要observer进行回调，在onCreate（）和onStart（）之间这里为true，在执行				     
        //在onStop之后这里也是为true，所以都是不会去执行observer的回调的
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        //这里主要是判断数据是否更新了，没有更新就会直接返回
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        //这里就是在调用observer的回调
        observer.mObserver.onChanged((T) mData);
    }

这里在看下设置数据是的方法：

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

其实就是上面分析的dispatchingValue（）方法，这里mVersion自增，说明数据发生了变化。只有postValue（），最终还是调用到了setValue（），只不过是多了一个线程间的切换。
好了，到这就算完了，总体来说也不是很难理解，如果你有疑问，欢迎一起学习指正！！！