LiveData的使用和原理

一、LiveData的基本使用

//创建一个LiveData对象
private val livedata = MutableLiveData<String>();

//为LiveData设置监听
livedata.observe(this, Observer {
    Log.e("znh", "监听到livedata的数据了：${it}")
})

//设置LiveData的值
livedata.value = "测试数据"

上述代码中，当LiveData的value值改变时，就会触发observe方法中设置的监听。

二、LiveData的工作原理

MutableLiveData的observe方法里需要传递两个参数，第一个参数是LifecycleOwner的子类，实现了这个接口的子类就是一个被观察者，AppCompatActivity实现了LifecycleOwner接口成为了一个生命周期可被观察的被观察者，所以第一个参数可以设置为Activity自身。第二个参数是观察LiveData数据的观察者Observer。

在LiveData的observe方法中，会将LifecycleOwner和Observer两个参数关联起来封装到wrapper中去，然后将wrapper作为Lifecycle的一个观察者添加到观察者集合中，这样当Activity的生命周期发生改变时，wrapper就可以感知到(具体的感知过程可以查看《Lifecycle的基本使用和原理》)，这样Livedata就可以根据wrapper感知到的生命周期状态去处理跟Activity的关系，并决定是否要向Observer发送Livedata的数据。

除了上面Activity的生命周期发生改变时，有可能会触发向Observer发送Livedata数据的一个事件外，当LiveData的setValue或者postValue被调用时也会触发这样一个事件(具体的过程是通过调用dispatchingValue方法来实现的)。

下面看下LiveData的observe方法源码：

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
      assertMainThread("observe");

	  //注释1 判断owner的生命周期状态是不是被销毁了
      if (owner.getLifecycle().getCurrentState() == DESTROYED) {
          // ignore
          return;
      }

	  //注释2
      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;
      }

	  //注释3 为lifecycle添加观察者
      owner.getLifecycle().addObserver(wrapper);
 }

在注释2处将owner和observer封装到LifecycleBoundObserver中，然后在将wrapper添加到mObservers中，mObservers是以observer为key，wrapper为value的map集合，这样可以从集合中通过observer来找到封装它的LifecycleBoundObserver对象。

在注释3处将wrapper作为一个观察者添加到Lifecycle的观察者集合中，这样wrapper就具备了观察Lifecycle生命周期的能力。

LifecycleBoundObserver源码：

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @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);
        }

		//注释4
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        	//注释5
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            
            //注释6
            activeStateChanged(shouldBeActive());
        }

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

        @Override
        void detachObserver() {
        	//注释7
            mOwner.getLifecycle().removeObserver(this);
        }
}

从注释3处可以知道LifecycleBoundObserver类型的wrapper对象也是LifecycleObserver的子类，它作为lifecycle的一个观察者，当lifecycle回调生命周期方法的时候，会回调注释4处wrapper的onStateChanged方法。

在注释5处如果Lifecycle生命周期状态是DESTROYED那么就会将该wrapper从map(这里的map就是注释2处添加wrapper的mObservers)中移除掉并结束事件流，这里的移除操作会触发在注释7处的detachObserver方法调用，将wrapper从Lifecycle的观察者集合中移除掉，解除UI层对数据的监听，这样就解决了LiveData在UI层的内存泄漏问题。

如果生命周期没有结束，那么就会继续执行注释6处的activeStateChanged方法，在activeStateChanged中会调用dispatchingValue方法，在dispatchingValue方法中又会调用considerNotify方法处理事件流，considerNotify源码如下：

private void considerNotify(ObserverWrapper observer) {
       if (!observer.mActive) {
           return;
       }

       if (!observer.shouldBeActive()) {
           observer.activeStateChanged(false);
           return;
       }

	   //注释8
       if (observer.mLastVersion >= mVersion) {
           return;
       }
       observer.mLastVersion = mVersion;
       
       //注释9
       observer.mObserver.onChanged((T) mData);
}

在注释8处mVersion是LiveData中的一个变量，初始值为-1，每次LiveData进行postValue或者setValue时，mVersion都会进行++操作，mLastVersion是观察者ObserverWrapper中的一个变量，只有mLastVersion小于mVersion时才会进行数据分发并且会同步二者的值，否则就结束事件流，这样做可以防止数据的重复多次发送。

在注释9处会调用ObserverWrapper中封装的mObserver(这个就是在UI层通过LiveData的observe方法的第二个参数传递的观察者对象)观察者的onChanged方法，这样在UI层就能接收到数据了。