Data Binding MVVM 数据绑定 总结

示例代码： https://github.com/baiqiantao/DataBindingTest

参考： 精通Android Data Binding     Android Data Binding（数据绑定）用户指南

官方教程： Data Binding Guide      API   

关于 Data Binding

Data Binding 解决了 Android UI 编程的一个痛点，官方原生支持 MVVM 模型可以让我们在不改变既有代码框架的前提下，非常容易地使用这些新特性。

Data Binding 框架如果能够推广开来，也许 RoboGuice、ButterKnife 这样的依赖注入框架会慢慢失去市场，因为在 Java 代码中直接使用 View 变量的情况会越来越少。

【使用条件】

Data Binding库不仅灵活而且广泛兼容：它是一个support库，因此你可以在所有的Android平台最低能到Android 2.1（API等级7+）上使用它。

Gradle 1.5 alpha 及以上自带支持 DataBinding，仅需在使用 DataBinding 的 module 里面的 build.gradle 里面加上配置即可：

android {
    dataBinding {
        enabled true
    }
}

【利弊】

优势

• DataBinding 出现以前，我们在实现 UI 界面时，不可避免的编写大量的毫无营养的代码：比如 View.findViewById()，比如各种更新 View 属性的 setter：setText()，setVisibility()，setEnabled() 或者 setOnClickListener() 等等。
• 这些“垃圾代码”数量越多，越容易滋生 bug。
• 使用 DataBinding，我们可以避免书写这些“垃圾代码”。

劣势

• 使用 Data Binding 会增加编译出的 apk 文件的类数量和方法数量。
  
• 新建一个空的工程，统计打开 build.gradle 中 Data Binding 开关前后的 apk 文件中类数量和方法数量，类增加了 120+，方法数增加了 9k+（开启混淆后该数量减少为 3k+）。
  
• 如果工程对方法数量很敏感的话，请慎重使用 Data Binding。
  

基础功能的完整案例

【编写布局文件】

使用 Data Binding 之后，xml 的布局文件就不再用于单纯地展示 UI 元素，还需要定义 UI 元素用到的变量。所以，它的根节点不再是一个 ViewGroup，而是变成了 layout，并且新增了一个节点 data。

     …    //新增的data节点 
    
     ...   //原先的根节点

要实现 MVVM 的 ViewModel 就需要把数据（Model）与 UI（View） 进行绑定，data 节点的作用就像一个桥梁，搭建了 View 和 Model 之间的通路。

【定义数据对象】

定义一个 POJO 类：

public class User {
    private String firstName;//就是一个简单的Java Bean
    private String lastName;
    ...
}

稍后，我们会在 xml 布局文件的 data 节点中声明一个 User 类型的 variable，这个变量会为 UI 元素提供数据，然后在 Java 代码中把『后台』数据与这个 variable 进行绑定。

【布局中定义 variable】

回到布局文件，在 data 节点中声明一个 User 类型的变量 user。

其中 type 属性就是我们刚刚定义的 User 类。

当然，data 节点也支持 import，并且 import 并没有要求一定要放在使用前，所以上面的代码可以这样写：

注意：

• java.lang.* 包中的类会被自动导入，可以直接使用。
  
• 基本类型的type可以使用包装类或直接使用原型，比如，整数可以使用【type="int"】或【type="Integer"】

【 Java代码中创建** Binding类】

我们 build 工程后会自动在 build 目录下生成一个继承自 ViewDataBinding 的类，这个类将被放置在databinding包下。比如，如果我们的包名是com.bqt.databinding，那么它将被放置在com.bqt.databinding.databinding包下。

默认情况下， **Binding类的命名是基于layout文件的名称的，用大写开头，除去下划线并将下划线后的首字母大写，然后添加“Binding”后缀。 例如，这里 xml 的文件名叫 activity_basic.xml，那么 自动 生成的类就是 ActivityBasic Binding 。

创建bindings的最简单的方式是在inflating（注：layout文件与Activity/Fragment的“链接”）期间，比如：

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //用 DatabindingUtil.setContentView() 来替换掉 setContentView()
    MainActivityBinding binding = DataBindingUtil.setContentView(this, R.layout.main_activity);
    ...
}

【Java代码中绑定variable】

在创建**Binding类的实例后，我们便可以使用它来绑定variable，例如：

User user = new User("Test", "User");
binding.setUser(user);

注意，所有的 set/get 方法都是根据 variable 名称生成的，例如，上面布局中定义了一个 name="user" 的变量：

那么就会生成对应的 set/get 方法：

public void setUser(com.bqt.databinding.model.User User) { ... }
public com.bqt.databinding.model.User getUser() { ... }

【布局中使用variable】

数据与variable 绑定之后，通过 @{} 可以直接把 Java 中定义的属性值赋值给 xml 中 UI 元素的某个属性。

至此，一个简单的数据绑定就完成了。

Observable Binding

任何Plain old Java object（POJO）可用于Data Binding，但修改POJO不会导致UI更新。比如在上面我们的案例中，我们通过 binding.setUser(user) 将数据 User 和 View 绑定在了一起，我们本想着，在 User 改变之后， View 会自动更新，但实际上是没有这种效果的。

Data Binding的真正能力是当数据变化时，可以通知给你的Data对象。有三种不同的数据变化通知机制：Observable对象、ObservableFields以及Observable集合。当这些可观察Data对象绑定到UI，Data对象属性的更改后，UI也将自动更新。

Observable和BaseObservable

实现 android.databinding.Observable 接口的类可以允许添加一个监听器到 Bound 对象以便监听对象上的所有属性的变化。Observable 接口有一个机制可以添加和删除监听器，但通知与否由开发人员管理。

为了使开发更容易，一个 BaseObservable 的基类为实现监听器注册机制而创建。Data实现类依然负责通知当属性改变时。这是通过指定一个@Bindable注解给getter以及setter内通知来完成的。

【接口Observable】

Observable classes provide a way in which data bound UI(数据绑定UI) can be notified of changes. ObservableList and ObservableMap also provide the ability to notify when changes occur. ObservableField, ObservableParcelable, ObservableBoolean, ObservableByte, ObservableShort, ObservableInt, ObservableLong, ObservableFloat, and ObservableDouble provide a means by which properties may be notified without implementing Observable.

An Observable object should notify the Observable.OnPropertyChangedCallback whenever an observed property of the class changes.

The getter for an observable property should be annotated with Bindable.

Convenience class BaseObservable implements this interface and PropertyChangeRegistry can help classes that don't extend BaseObservable to implement the listener registry.

【内部类OnPropertyChangedCallback】

The callback that is called by Observable when an observable property has changed.

abstract void   onPropertyChanged(Observable sender, int propertyId)： Called by an Observable whenever an observable property changes.

【实现类BaseObservable】

A convenience class that implements Observable interface and provides notifyPropertyChanged(int) and notifyChange() methods.

BaseObservable的已知子类：8个基本数据类型对应的 Observable 类，以及一个ObservableField

• ObservableField
  • ObservableParcelable
• ObservableBoolean, ObservableByte, ObservableChar, ObservableDouble, ObservableFloat, ObservableInt, ObservableLong, ObservableShort
  

【 BaseObservable的API 】

• [扩充的方法] synchronized void  notifyChange()：Notifies listeners that all properties of this instance have changed.
  
• [扩充的方法] void    notifyPropertyChanged(int fieldId)：Notifies listeners that a specific property has changed.
  
• [实现的方法] synchronized void  addOnPropertyChangedCallback(Observable.OnPropertyChangedCallback callback)：Adds a callback to listen for changes to the Observable.
  
• [实现的方法] synchronized void   removeOnPropertyChangedCallback(Observable.OnPropertyChangedCallback callback)：Removes a callback from those listening for changes.

/**
 * Notifies listeners that a specific property has changed. The getter for the property
 * that changes should be marked with @Bindable to generate a field in BR to be used as fieldId.
 * @param fieldId The generated BR id for the Bindable field.
 */
public void notifyPropertyChanged(int fieldId) {
    synchronized (this) {
        if (mCallbacks == null) return;//private transient PropertyChangeRegistry mCallbacks;
    }
    mCallbacks.notifyCallbacks(this, fieldId, null);//通过【PropertyChangeRegistry】来实现通知监听器
}

【使用示例】

public class ObservableUser extends BaseObservable {
	private String name;
	
	@Bindable//给getter方法添加注解。The getter for an observable property should be annotated with Bindable.
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
		notifyPropertyChanged(BR.name);//通知某个属性改变了。Notifies listeners that a specific property has changed.
	}
}

BR 是编译阶段生成的一个类，功能与 R.java 类似。

在编译期间，通过@Bindable注解标记的getter方法返回的字段会在BR类文件中生成一个同名的Entry，如下：

package com.bqt.databinding;
public class BR {
    ...
    public static final int name = 17;
    ...
}

Observable field

除此之外，还有一种更细粒度的绑定方式，可以具体到成员变量，这种方式无需继承 BaseObservable，一个简单的 POJO 就可以实现。

系统为我们提供了所有的原始类型所对应的 Observable 类，例如ObservableInt、ObservableFloat、ObservableBoolean等等，还有一个 ObservableField 对应着 引用类型。这种方式非常适合那些几乎没有几个属性的 POJO 。

public class android.databinding.ObservableInt extends BaseObservable implements Parcelable Serializable

ObservableInt：An observable class that holds a primitive int.

ObservableField：An object wrapper to make it observable.

Observable field classes may be used instead of creating an Observable object. 

Fields of this type should be declared final because bindings only detect检测 changes in the field's value, not of the field itself.

This class is parcelable可扩展的 and serializable but callbacks are ignored when the object is parcelled / serialized. Unless you add custom callbacks, this will not be an issue because data binding framework always re-registers callbacks when the view is bound.

要使用它需要在data对象中创建public final字段，如：

public class PlainUser {
	public final ObservableField name = new ObservableField<>();
	public final ObservableInt age = new ObservableInt();
}

要访问该值，使用set和get方法：

PlainUser plainUser = new PlainUser();
plainUser.name.set("包青天，ObservableField");
plainUser.age.set(27);

int age = plainUser.age.get();

Observable集合

一些app使用更多的动态结构来保存数据，Observable集合允许键控访问这些data对象。

【ObservableArrayMap】

public class android.databinding.ObservableArrayMap extends ArrayMap implements ObservableMap

ObservableArrayMap用于键是引用类型，如String。

ObservableArrayMap mapUser = new ObservableArrayMap<>();
mapUser.put("name", "ObservableArrayMap");
mapUser.put("age", 27);

在layout文件中，通过String键可以访问map。

android:text='@{mapUser["name"]}'
android:text='@{String.valueOf(1 + (Integer)mapUser["age"])}'

注意，在XML布局的某个属性值中使用泛型时，要用【<】来代替【<】

【ObservableArrayList】

public class android.databinding.ObservableArrayList extends ArrayList implements ObservableList

ObservableArrayList用于键是整数，如：

ObservableArrayList