Android Jetpack之LiveData概述

概述

LiveData是一个可被观察的数据持有者类。与常规的Observable不同，LiveData能意识到应用程序组件的生命周期变化，这意味着它能遵守Activity、Fragment、Service等组件的生命周期。这种意识确保LiveData只更新处于活跃状态的应用程序组件Observer。

Note: 如何在Android项目中引入LiveData组件， 请参阅 添加项目组件。

如果一个Observer的生命周期处于STARTED或RESUMED状态，那么LiveData将认为这个Observer处于活跃状态。 LiveData仅通知活跃的Observer去更新UI。 非活跃状态的Observer，即使订阅了LiveData，也不会收到更新的通知。

结合一个实现了LifecycleOwner接口的对象，你能注册一个Observer。这种结合关系使得当具有生命周期的对象的状态变为DESTROYED时，Observer将被取消订阅。 这对于Activity和Fragment尤其有用，因为它们可以安全地订阅LiveData对象，而不必担心内存泄漏 - 当Activity和Fragment生命周期为DESTROYED时，它们立即会被取消订阅。

有关如何使用LiveData的更多信息，请参阅 使用LiveData对象。

LiveData的优点

在项目中使用LiveData，会有以下优点:

使用LiveData对象

按照以下步骤使用LiveData对象：

Note:您可以使用observeForever(Observer)方法注册一个没有关联LifecycleOwner对象的Observer。 在这种情况下，Observer被认为始终处于活动状态，因此当有数据变化时总是会被通知。 您可以调用removeObserver(Observer)方法移除这些Observer。

当你更新LiveData对象中存储的数据时，所有注册了的Observer，只要所绑定的LifecycleOwner处于活动状态，就会被触发通知。

LiveData允许UI控制器Observer订阅更新。 当LiveData对象所保存的数据发生变化时，UI会在响应中自动更新。

创建LiveData对象

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

public class NameViewModel extends ViewModel {
// Create a LiveData with a String
private MutableLiveData<string> mCurrentName;
public MutableLiveData<string> getCurrentName() {
if (mCurrentName == null) {
mCurrentName = new MutableLiveData<string>();
}
return mCurrentName;
}
// Rest of the ViewModel...
}
/<string>/<string>/<string>

起初，LiveData对象中的数据未设置。

Note:确保在ViewModel而不是Activity或Fragment中保存用来更新UI的LiveData对象，原因如下：

有关ViewModel更多的用处和益处，请参阅Android应用结构之ViewModel。

观察LiveData对象

在大多数情况下，出于以下原因，应用程序组件的onCreate()方法是开始观察LiveData对象的最佳位置：

通常情况下，LiveData只在数据有变化时，给活跃的Observer进行通知。 此行为的一个例外是，Observer在从非活跃状态变为活跃状态时也会收到通知。 并且，如果Observer第二次从非活跃状态变为活跃状态，则只有在自上一次变为活跃状态以来该数据发生变化时才会接收到更新。

以下示例代码演示了如何开始观察LiveData对象：

public class NameActivity extends AppCompatActivity {
private NameViewModel mModel;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Other code to setup the activity...
// Get the ViewModel.
mModel = ViewModelProviders.of(this).get(NameViewModel.class);
// Create the observer which updates the UI.
final Observer<string> nameObserver = new Observer<string>() {
@Override
public void onChanged(@Nullable final String newName) {
// Update the UI, in this case, a TextView.
mNameTextView.setText(newName);
}
};
// Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
mModel.getCurrentName().observe(this, nameObserver);
}
}
/<string>/<string>

传递nameObserver作为参数,调用observe()之后，将立即回调onChanged()，提供存储在mCurrentName中的最新值。 如果LiveData对象mCurrentName的值并未设置，则不调用onChanged()。

更新LiveData对象

LiveData没有公用的方法来更新存储的数据。 MutableLiveData类暴露公用的setValue(T)和postValue(T)方法，如果需要编辑存储在LiveData对象中的值，必须使用这两个方法。 通常在ViewModel中使用MutableLiveData，然后ViewModel仅向Observer公开不可变的LiveData对象。

在建立观察者关系之后，可以更新LiveData对象的值，如以下示例所示，当用户点击按钮时向所有观察者发出通知：

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

在示例中调用setValue(T)会导致Observer使用值"John Doe"调用onChanged()方法。 这个例子展示了点击按钮，setValue()或者postValue()被调用来更新mName，原因有多种，包括响应网络请求或数据库加载完成; 在所有情况下，调用setValue()或postValue()都会触发观察者并更新UI。

Note: 必须要从主线程调用setValue(T) 方法来更新LiveData 对象. 如果代码在工作线程中执行, 你可以使用postValue(T) 方法来更新LiveData对象.

LiveData配合Room使用

Room持久性库支持Observable查询返回LiveData对象。 Observable查询成为数据库访问对象（DAO）的一项功能。

当更新数据库时，会生成所有必要的代码来更新LiveData对象。 生成的代码在需要时在后台线程上异步运行查询。 这种模式对于保持用户界面中显示的数据与存储在数据库中的数据同步很有用。 您可以在Room持久性库指南中阅读关于Room和DAO的更多信息。

扩展LiveData

如果Observer的生命周期处于STARTED或RESUMED状态，则LiveData将认为Observer处于活动状态。以下示例代码说明了如何扩展LiveData类：

public class StockLiveData extends LiveData<bigdecimal> {
private StockManager mStockManager;
private SimplePriceListener mListener = new SimplePriceListener() {
@Override
public void onPriceChanged(BigDecimal price) {
setValue(price);
}
};
public StockLiveData(String symbol) {
mStockManager = new StockManager(symbol);
}
@Override
protected void onActive() {
mStockManager.requestPriceUpdates(mListener);
}
@Override
protected void onInactive() {
mStockManager.removeUpdates(mListener);
}
}
/<bigdecimal>

本例中StockLiveData的实现包括以下重要的方法：

public class MyFragment extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {

observe()方法第一个参数是作为LifecycleOwner实例的Fragment。 这样做表示此Observer绑定了Lifecycle对象的生命周期，即：

public class StockLiveData extends LiveData<bigdecimal> {
private static StockLiveData sInstance;
private StockManager mStockManager;
private SimplePriceListener mListener = 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) {
mStockManager = new StockManager(symbol);
}
@Override
protected void onActive() {
mStockManager.requestPriceUpdates(mListener);
}
@Override
protected void onInactive() {
mStockManager.removeUpdates(mListener);
}
}

你可以在Fragment中使用它，如下所示：

public class MyFragment extends Fragment {
@Override
public void onActivityCreated(Bundle savedInstanceState) {
StockLiveData.get(getActivity()).observe(this, price -> {
// Update the UI.
});
}
}

多个Activity和Fragment可以观察到MyPriceListener实例。 LiveData只在他们至少一个处于可见和活跃状态时才连接到系统服务。

转换LiveData

您可能希望先转换存储在LiveData对象中的值，然后再将其分派给Observer，或者您可能需要根据一个LiveData实例的值返回不同的LiveData实例。Lifecycle包提供了 Transformations类，提供了支持这些使用场景的方法。

Transformations.map()

使用一个函数来转换存储在LiveData对象中的值，并向下传递转换后的值。

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

Transformations.switchMap()

与map()类似，使用一个函数来转换存储在LiveData对象中的值，并向下传递结果。 传递给switchMap()的函数必须返回一个LiveData对象，如下例所示：

private LiveData<user> getUser(String id) {
...;
}
LiveData<string> userId = ...;
LiveData<user> user = Transformations.switchMap(userId, id -> getUser(id) );
/<user>/<string>/<user>

您可以使用转换方法在Observer的生命周期中传递信息。 除非Observer正在观看返回的LiveData对象，否则不会计算转换。 由于转换是延迟计算的，所以与生命周期相关的行为隐式传递，而不需要额外的显式调用或依赖关系。

如果您认为在ViewModel对象中需要Lifecycle对象，则转换可能是更好的解决方案。 例如，假设您有一个接受地址并返回该地址的邮政编码的UI组件。 您可以为此组件实现朴素的ViewModel，如以下示例代码所示：

class MyViewModel extends ViewModel {
private final PostalCodeRepository repository;
public MyViewModel(PostalCodeRepository repository) {
this.repository = repository;
}
private LiveData<string> getPostalCode(String address) {
// DON'T DO THIS
return repository.getPostCode(address);
}
}
/<string>

UI组件随后需要从以前的LiveData对象注销，并在每次调用getPostalCode()时注册到新实例。 另外，如果UI组件被重新创建，它会触发对repository.getPostCode()方法的另一个调用，而不是使用前一个调用的结果。

相反，您可以实现邮政编码查找作为地址输入的转换，如以下示例所示：

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);
}
}
/<string>/<string>

在这种情况下，postalCode字段是公开的和最终的，因为该字段永远不会改变。 postalCode字段定义为addressInput的转换，这意味着addressInput发生更改时,如果有一个活跃的Observer,将调用repository.getPostCode()方法,如果在repository.getPostCode()被调用时没有活跃的Observer，直到添加一个观察者才会进行计算。

此机制允许较低级别的应用程序创建按需延迟计算的LiveData对象。 ViewModel对象可以很容易地获得对LiveData对象的引用，然后在其上定义转换规则。

创建新的Transformations

我们有十几个不同的具体Transformations，它们可能在你的应用程序中很有用，但是它们并不是默认提供的。 要实现自己的转换，您可以使用MediatorLiveData类，该类监听其他LiveData对象并处理它们发出的事件。 MediatorLiveData将其状态正确地传播到源LiveData对象。 要了解有关此模式的更多信息，请参阅Transformations的参考文档。

合并多个LiveData源

MediatorLiveData是LiveData的一个子类，帮助您合并多个LiveData源。 在任何原始LiveData源对象改变后，MediatorLiveData对象的Observer会被触发。

例如，如果在UI中有一个从本地数据库或网络获取更新的LiveData对象，则可以将以下数据源添加到MediatorLiveData对象：

【附录】

关注我私信回复【学习】获取免费学习视频，学习大纲另外还有像高级UI、性能优化、架构师课程、NDK、混合式开发（ReactNative+Weex）等Android高阶开发资料免费分享！