Android Jetpack库剖析之LiveData组件篇

LiveData简介

在日常安卓开发中，一些耗时的 * 如列网络请求，数据库读写都不能在主线程执行，必须开一条子线程去执行这些耗时操作，但我们往往需要在这些耗时操作执行完毕后更新UI，但安卓不能在子线程进行UI的更新，这时我们只能通过创建一个Handler来切回到主线程进行UI的更新，直到LiveData出现，LiveData是一个可被观察的数据容器，它将数据包装起来，使数据成为被观察者。当数据发生改变时，观察者能够及时得到通知。

LiveData用法

LiveData是一个数据容器，订阅视图的生命周期，在子线程通过postValue()切换到主线程来传递数据给观察者，当视图是活动的状态下观察者即可接受到数据，LiveData是一个典型的观察者模式。

class MainActivity : AppCompatActivity() {
   private val mLiveData = MutableLiveData<String>()
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       val binding = ActivityMainBinding.inflate(LayoutInflater.from(baseContext))
       setContentView(binding.root)
       mLiveData.observe(this, {
           binding.tvContent.text = it
       })
       Thread(BackgroundThread(mLiveData)).start()
   }
   private class BackgroundThread(liveData: MutableLiveData<String>) : Runnable {
       private val mLive = WeakReference(liveData)
       override fun run() {
           mLive.apply {
               get()?.apply {
                   postValue("hello LiveData")
               }
           }
       }
   }
}

数据订阅过程

@MainThread
   public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
       //1,判断是否在主线程
       assertMainThread("observe");
       if (owner.getLifecycle().getCurrentState() == DESTROYED) {
           // ignore
           return;
       }
       //2，通过owner，observer来构建一个LifecycleBoundObserver
       LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
       //3，把observer存放到mObservers中
       ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
       //4，如果existing不为空代表观察者已经存在并且已经绑定了生命周期，抛一个Exception来提示                
       if (existing != null && !existing.isAttachedTo(owner)) {
           throw new IllegalArgumentException("Cannot add the same observer"
                   + " with different lifecycles");
       }
       if (existing != null) {
           return;
       }
       //5,调用Lifecycle的addObserver()方法来订阅生命周期
       owner.getLifecycle().addObserver(wrapper);
   }

1，先判断当前订阅数据这个操作是否是在主线程中执行，否则的话抛一个Exception

2，把owner,observer传入到LifecycleBoundObserver构建出一个LifecycleBoundObserver对象

3，调用mObservers.putIfAbsent()方法把观察者放到观察者集合中，mObservers是SafeIterableMap类型的集合类似Map，但它是通过链表的方式来实现Map接口，SafeIterableMap.putIfAbsent()方法与Map.put()方法不一样，如果根据key获取的value不为null，就将当前的value返回，如果为null，就将当前的键值对存储起来，然后返回一个null

4，existing不为null，代表Observer存在，就抛一个Exception来提示开发者：无法添加具有不同生命周期的同一观察者

5，existing为null，代表observer不存在，添加观察者来观察生命周期拥有者的生命周期，

当我们的视图的生命周期发生改变，LifecycleBoundObserver的onStateChange()方法就会被调用

PostValue过程

protected void postValue(T value) {
       boolean postTask;
       //判断当前是否正在下发数据
       synchronized (mDataLock) {
           postTask = mPendingData == NOT_SET;
           mPendingData = value;
       }
       //如果正在下发数据则继续下发数据
       if (!postTask) {
           return;
       }
       //构建Handler并关联主线程的Looper，回到主线程执行run方法中的逻辑
       ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
   }
private final Runnable mPostValueRunnable = new Runnable() {
       @Override
       public void run() {
           Object newValue;
           synchronized (mDataLock) {
               newValue = mPendingData;
               mPendingData = NOT_SET;
           }
           //在主线程中调用setValue来执行数据下发逻辑
           //noinspection unchecked
           setValue((T) newValue);
       }
   };

当调用postValue()方法是通过构建一个Handler并关联主线程的Looper来post一个Runnable来回到主线程执行run方法里面的逻辑，而mPostValueRunnable的run()方法则调用了setValue()方法来实现数据的发送

SetValue过程

@MainThread
   protected void setValue(T value) {
       assertMainThread("setValue");
       mVersion++;
       mData = value;
       dispatchingValue(null);
   }
void dispatchingValue(@Nullable ObserverWrapper initiator) {
       //1，判断当前是正在下发数据
       if (mDispatchingValue) {
           mDispatchInvalidated = true;
           return;
       }
       mDispatchingValue = true;
       do {
           mDispatchInvalidated = false;
           //2，如果initiator不为空直接给initiator发送数据更新通知
           if (initiator != null) {
               considerNotify(initiator);
               initiator = null;
           } else {
               /,3，否则遍历所有observer
               for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                   /4，发送数据更新通知
                   considerNotify(iterator.next().getValue());
                   if (mDispatchInvalidated) {
                       break;
                   }
               }
           }
       } while (mDispatchInvalidated);
       mDispatchingValue = false;
   }
private void considerNotify(ObserverWrapper observer) {
       5，如果当前observer不是活动状态，不下发数据
       if (!observer.mActive) {
           return;
       }
       6，如果当前observer的状态至少不是started状态（可见状态），resumed比started高一个级别（可触摸状态）则不下发数据
       if (!observer.shouldBeActive()) {
           observer.activeStateChanged(false);
           return;
       }
       7，判断数据版本号 如果当前observer的数据是最新的 则不下发数据
       if (observer.mLastVersion >= mVersion) {
           return;
       }
       8，记录最新数据版本号
       observer.mLastVersion = mVersion;

9，通知数据更新
       observer.mObserver.onChanged((T) mData);
   }
    @Override
       boolean shouldBeActive() {
           判断当前状态是否>=STARTED
           return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
       }

1，检查当前是否在主线程

2， 每次调用setValue()方法版本号（mVersion）都进行累加

3，把需要新数据赋值给mData

4，调用dispatchingValue来执行数据下发

5，如果initiator不为null则直接给这个观察者下发数据更新通知

6，否则遍历所有的观察者，逐个下发数据更新通知

7，判断当前的observer是否为活动状态，不是活动状态不下发数据，这也就是为什么我们界面不可见时数据不会更新的原因（onStop状态）

8，判断当前的observer是否是resumed状态，不是resumed状态不下发数据，这就是为什么当我们的页面可见但不可触摸时数据不更新的原因（onPause状态）

9，比对数据版本号，如果当前observer的数据是最新数据则不需要下发

10，记录数据版本号并通知observer数据更新，回调observer的onChanged()方法

生命周期变化

@Override
       public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
           1，如果当前的状态为destroyed就移除observer
           if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
               removeObserver(mObserver);
               return;
           }
           2，更新状态并下发数据
           activeStateChanged(shouldBeActive());
       }
void activeStateChanged(boolean newActive) {
           3，如果新状态和当前状态一致的话不需要更新
           if (newActive == mActive) {
               return;
           }
           4，记录新状态
           mActive = newActive;
           boolean wasInactive = LiveData.this.mActiveCount == 0;
           LiveData.this.mActiveCount += mActive ? 1 : -1;
           if (wasInactive && mActive) {
               onActive();
           }
           if (LiveData.this.mActiveCount == 0 && !mActive) {
               onInactive();
           }
           5，如果是活动状态 下发数据
           if (mActive) {
               dispatchingValue(this);
           }
       }

在订阅数据那一刻（即调用LiveData.observer()）就构建了一个LifecycleBoundObserver并且让LifecycleBoundObserver订阅了页面生命周期，所以当页面的生命周期发生改变，LifecycleBoundObserver的onStateChanged()方法都会被调用

1，如果当前页面的状态为destroyed(即销毁状态)，则移除观察者

2，更新状态并下发数据

3，判断当前observer的状态跟新状态是否一致，如果时是则不需要更新状态以及数据

4，记录当前observer的状态

5，调用dispatchingValue()并传入当前observer，执行准确下发数据业务

来源：https://blog.csdn.net/qq_42359647/article/details/124980451