Android Jetpack架构组件(四)之LiveData

三、 LiveData的基本使用

3.1 使用步骤

LiveData的使用比较简单，主要会涉及以下几个步骤：

• 创建 LiveData 实例以存储某种类型的数据，通常在ViewModel中完成。
• 定义一个具有onChanged()方法的Observer对象，当LiveData持有数据发生变化时回调该方法。通常，我们可以在UI控制器类中创建该Observer对象，如Activity或Fragment。
• 通过使用observe()方法将上述的LiveData对象和Observer对象关联在一起。这样Observer对象就与LiveData产生了订阅关系，当LiveData数据发生变化时通知，而在Observer更新数据，所以Observer通常是Activity和Fragment。

从上述步骤可以看出，LiveData使用了观察者模式，观察者通常是UI控制器，如Activity或Fragment，而被观察者则是LiveData包谷的数据对象， 当LiveData对象持有数据发生变化，会通知对它订阅的所有处于活跃状态的订阅者。

3.2 LiveData使用示例

3.2.1 创建 LiveData 对象

LiveData是一种可用于任何数据的封装容器，其中包括可实现 Collections 的对象，如 List。LiveData 对象通常存储在 ViewModel 对象中，并可通过 getter 方法进行访问，如下所示。

public class NameViewModel extends ViewModel {

    private MutableLiveData<String> name;
    public MutableLiveData<String> getName() {
        if (name == null) {
            name = new MutableLiveData<String>();
        }
        return name;
    }
}

3.2.2 观察 LiveData 对象

在大多数情况下，我们可以应用组件的 onCreate() 方法中开始观察 LiveData 对象。并且，LiveData 仅在数据发生更改时才发送更新，并且仅发送给活跃观察者，如下所示。

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private NameViewModel model;
    private TextView nameTV;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        nameTV=findViewById(R.id.nameTV);
        model = new ViewModelProvider(this).get(NameViewModel.class);
        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                nameTV.setText(newName);
            }
        };
        model.getName().observe(this, nameObserver);
    }
}

当我们传递 nameObserver 参数的情况下调用 observe() 后，系统会立即调用 onChanged()，从而提供 mCurrentName 中存储的最新值，如果 LiveData 对象尚未在 mCurrentName 中设置值，则不会调用 onChanged()。事实上，最简单的LiveData使用方法是MutableLiveData，如下所示。

public class MainActivity extends AppCompatActivity {
   private static final String TAG="MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MutableLiveData<String> mutableLiveData  = new MutableLiveData<>();
        mutableLiveData.observe(this, new Observer<String>() { 
            @Override
            public void onChanged(@Nullable final String s) {
                Log.d(TAG, "onChanged:"+s);
            }
        });
        mutableLiveData.postValue("Android应用开发实战");
    }
}

3.2.3 更新 LiveData 对象

LiveData 本身没有公开可用的方法来更新存储的数据，如果需要修改LiveData的数据，可以使用MutableLiveData 类将公开 setValue(T) 和 postValue(T) 方法。通常情况下会在 ViewModel 中使用 MutableLiveData，然后 ViewModel 只会向观察者公开不可变的 LiveData 对象，如下所示。

    button.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View v) {
            String anotherName = "John Doe";
            model.getCurrentName().setValue(anotherName);
        }
    });
   

3.2.4 扩展 LiveData

如果观察者的生命周期处于 STARTED 或 RESUMED 状态，则 LiveData 会认为该观察者处于活跃状态。以下示例代码说明了如何扩展 LiveData 类。

    public class StockLiveData extends LiveData<BigDecimal> {
        private StockManager stockManager;

        private SimplePriceListener listener = new SimplePriceListener() {
            @Override
            public void onPriceChanged(BigDecimal price) {
                setValue(price);
            }
        };

        public StockLiveData(String symbol) {
            stockManager = new StockManager(symbol);
        }

        @Override
        protected void onActive() {
            stockManager.requestPriceUpdates(listener);
        }

        @Override
        protected void onInactive() {
            stockManager.removeUpdates(listener);
        }
    }
    

在上面的示例中，我们首先建立一个StockLiveData并继承自LiveData，并重写了onActive和onInactive两个重要方法。

• onActivite()：当有活跃状态的订阅者订阅LiveData时会回调该方法，意味着需要在这里监听数据的变化。
• onInactive()：当没有活跃状态的订阅者订阅LiveData时会回调该方法，此时没有必要保持StockManage服务象的连接。
• setValue()：注意到value=price这里是调用了setValue(price)方法，通过该方法更新LiveData的值，进而通知处于活跃状态的订阅者。

此时，LiveData会认为订阅者的生命周期处于STARTED或RESUMED状态时，该订阅者是活跃的，那么如何使用 StockLiveData 类呢，如下所示。

    public class MyFragment extends Fragment {
        @Override
        public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
            super.onViewCreated(view, savedInstanceState);
            LiveData<BigDecimal> myPriceListener = ...;
            myPriceListener.observe(getViewLifeycleOwner(), price -> {
                // Update the UI.
            });
        }
    }
   

以Fragment作LifecycleOwner的实例传递到observer()方法中，这样就将Observer绑定到拥有生命周期的拥有者。由于LiveData可以在多个Activity、Fragment和Service中使用，所以可以创建单例模式。

    public class StockLiveData extends LiveData<BigDecimal> {
        private static StockLiveData sInstance;
        private StockManager stockManager;

        private SimplePriceListener listener = new SimplePriceListener() {
            @Override
            public void onPriceChanged(BigDecimal price) {
                setValue(price);
            }
        };

        @MainThread
        public static StockLiveData get(String symbol) {
            if (sInstance == null) {
                sInstance = new StockLiveData(symbol);
            }
            return sInstance;
        }

        private StockLiveData(String symbol) {
            stockManager = new StockManager(symbol);
        }

        @Override
        protected void onActive() {
            stockManager.requestPriceUpdates(listener);
        }

        @Override
        protected void onInactive() {
            stockManager.removeUpdates(listener);
        }
    }
    

然后，我们就可以在 Fragment 中使用它，如下所示。

    public class MyFragment extends Fragment {
        @Override
        public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
            super.onViewCreated(view, savedInstanceState);
            StockLiveData.get(symbol).observe(getViewLifecycleOwner(), price -> {
                // Update the UI.
            });
        }
    }
    

3.2.5 转换 LiveData

有时候，我们希望在把数据分发给观察者之前进行一些处理，或者返回一个基于已有值的LiveData对象的另外一个LiveData对象，此时就会用到 Transformations类。转化LiveData时需要用到Transformations.map()和Transformations.switchMap()等方法。

Transformations.map()

例如，下面是使用Transformations.map()方法处理LiveData存储的数据，然后将其传递给下游的示例代码。

    LiveData<User> userLiveData = ...;
    LiveData<String> userName = Transformations.map(userLiveData, user -> {
        user.name + " " + user.lastName
    });
    

Transformations.switchMap()

使用Transformations.switchMap()方法同样可以改变LiveData下游的结果，但传递给switchMap()函数的必须是一个LiveData对象，如下所示。

    private LiveData<User> getUser(String id) {
      ...;
    }

    LiveData<String> userId = ...;
    LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );
    

不过，这种转换方式是惰性的，也就是只有Observer来订阅数据的时候，才会进行转换。因此，当在ViewModel中使用一个Lifecycle对象，这种转换是一种很好的解决方案。例如，假设您有一个界面组件，该组件接受地址并返回该地址的邮政编码，那么我们可以使用switchMap()方法进行转化。

    class MyViewModel extends ViewModel {
        private final PostalCodeRepository repository;
        private final MutableLiveData<String> addressInput = new MutableLiveData();
        public final LiveData<String> postalCode =
                Transformations.switchMap(addressInput, (address) -> {
                    return repository.getPostCode(address);
                 });

      public MyViewModel(PostalCodeRepository repository) {
          this.repository = repository
      }

      private void setInput(String address) {
          addressInput.setValue(address);
      }
    }
    

四、LiveData工作原理

通过前面的介绍，我们知道LiveData是一个可观察的数据持有者，并且它是具有组件生命周期感知能力的，那它是如何观察组件生命周期变化的呢？同时，LiveData仅更新处于活跃生命周期状态的应用组件观察者，也即是说LiveData并不会通知所有的观察者，它只会通知处于活跃状态的观察者，那么它是如何做到这一点的呢？

LiveData生命周期变化观察

前面介绍LiveData用法的时候提到，首先，我们创建 LiveData 实例，然后调用LiveData的observe方法来注册观察者，将ViewModel和LiveData关联起来。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);
    }

可以发现，observe首先会判断组件当前的状态，如果状态为DESTROYED，那么直接return，这说明DESTROYED状态的组件是不允许注册的。然后，新建一个LifecycleBoundObserver包装类，将owner和observer传了进去。接下来，将observer和LifecycleBoundObserver存储到SafeIterableMap<Observer<? super T>, ObserverWrapper>mObservers中，注意，此处使用的是putIfAbsent方法，接下来对传入的值进行判断，如果传入key对应的value已经存在，就返回存在的value，不进行替换，如果不存在就添加key和value，返回null。

最后，通过owner.getLifecycle().addObserver()方法将LifecycleBoundObserver添加到Lifecycle中完成注册，这样处理之后LiveData就有了观察组件生命周期变化的能力。

LifecycleBoundObservers

LifecycleBoundObservers是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() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            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);
        }
    }

LifecycleBoundObserver实现了GenericLifecycleObserver接口，当组件状态发生变化时，会调用onStateChanged方法，当组件处于DESTROYED状态时，会调用removeObserver方法移除observer。

而LifecycleBoundObserver继承了ObserverWrapper类，需要重写shouldBeActive方法，用于判断当前传入的组件的状态是否是Active状态，即处于STARTED和RESUMED状态。

ObserverWrapper

ObserverWrapper是Observer的包装类，LiveData的生命周期状态监听activeStateChanged方法就定义在抽象类ObserverWrapper中，源码如下。

private abstract class ObserverWrapper {
      final Observer<? super T> mObserver;
      boolean mActive;
      int mLastVersion = START_VERSION;

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

      abstract boolean shouldBeActive();

      boolean isAttachedTo(LifecycleOwner owner) {
          return false;
      }

      void detachObserver() {
      }

      void activeStateChanged(boolean newActive) {
          if (newActive == mActive) {
              return;
          }
          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();
          }
          if (mActive) {
              dispatchingValue(this);
          }
      }
  }

activeStateChanged()方法会根据Active状态和处于Active状态的组件的数量，来对onActive方法和onInactive方法进行回调，我们可以使用这两个方法拓展LiveData对象。如果生命周期状态是Active状态，那么会调用dispatchingValue方法。

private void dispatchingValue(@Nullable ObserverWrapper initiator) {
      if (mDispatchingValue) {
          mDispatchInvalidated = true;
          return;
      }
      mDispatchingValue = true;
      do {
          mDispatchInvalidated = false;
          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;
  }

mDispatchingValue用于标记当前是否处于分发状态中，如果处于分发状态就会进行状态的分发，并最终调用considerNotify方法进行消息的分发，代码如下所示。

private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) { 
        return;
    }
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false); 
        return;
    }
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    //noinspection unchecked
    observer.mObserver.onChanged((T) mData); 
}

considerNotify方法中做了多次的判断，首先，判断ObserverWrapper的mActive值如果不为true就直接return。然后，判断当前observer对应组件的状态是不是Active，如果不是就会再次调用activeStateChanged方法并传入false，其方法内部会再次判断是否执行onActive方法和onInactive方法回调。如果判断条件都满足就继续调用Observer的onChanged方法，这个方法正是使用LiveData的observe方法的回调。

最后

以上就是怕孤独大树为你收集整理的Android Jetpack架构组件(四)之LiveData的全部内容，希望文章能够帮你解决Android Jetpack架构组件(四)之LiveData所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。