Android 架构组件之 DataBinding

DataBinding 是 Google 推出的数据绑定的支持库，本文将从以下几个方面来介绍 DataBinding：

• DataBinding 是什么？
• 简单分析 DataBinding 的实现原理
• 通过示例，介绍如何使用 DataBinding

1. DataBinding 是什么？

DataBinding 总结起来就是可以通过声明式的语法，完成 ViewModel 和 View 中组件的绑定。

在 Android 的 Model-View-ViewModel 模式中:

• Model 对应实体 Bean，还有 Retrofit 中的 Service；
• View 处理与 UI 相关的任务，View 包括 xml、Activity、Fragment；
• ViewModel 完成业务相关的工作，ViewModel 不会持有 UI 中控件的引用，不会去更新 UI。

DataBinding 在 MVVM 模式中的位置，是完成 View 与 ViewModel 的绑定。

接下来，看一下 DataBinding 是如何实现 View与 ViewModel 绑定的。

2. 分析 DataBinding 的实现原理

具体说来，DataBinding 会在编译阶段，为每一个布局文件生成一个绑定类。默认情况下，绑定类名称基于布局文件的名称。它会转换为 Pascal 大小写形式并在末尾添加 Binding 后缀。

比如：布局文件名为 layout_main.xml，

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="name"
            type="String" />
        <variable
            name="lastName"
            type="String" />
    data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    LinearLayout>
layout>

生成的绑定类名称为 LayoutMainBinding，此类会包含从布局属性（例如，mName 变量）到布局视图的所有绑定，并且知道如何为绑定的表达式指定具体的值。生成的 LayoutMainBinding 代码：

public abstract class LayoutMainBinding extends ViewDataBinding {
  @Bindable
  protected String mName;

  @Bindable
  protected String mLastName;

  protected LayoutMainBinding(Object _bindingComponent, View _root, int _localFieldCount) {
    super(_bindingComponent, _root, _localFieldCount);
  }

  public abstract void setName(@Nullable String name);

  @Nullable
  public String getName() {
    return mName;
  }

  public abstract void setLastName(@Nullable String lastName);

  @Nullable
  public String getLastName() {
    return mLastName;
  }

  @NonNull
  public static LayoutMainBinding inflate(@NonNull LayoutInflater inflater,
      @Nullable ViewGroup root, boolean attachToRoot) {
    return inflate(inflater, root, attachToRoot, DataBindingUtil.getDefaultComponent());
  }
  
……

接下来通过一些简单的示例，介绍如何使用 DataBinding。

3. 通过示例，介绍如何使用 DataBinding

先来看 DataBinding 的基本使用。

3.1 DataBinding 的基本使用

如果要在一个项目中使用 DataBinding，需要完成以下几个步骤：

1.首先，打开 DataBinding 的控制，在 build.gradle 中

android {
...
    dataBinding {
       enabled true
    }
}

2. 用 标签包装布局，需要将原来 xml 中的根元素，包装在 标记中。

<layout xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:app="http://schemas.android.com/apk/res-auto"
       xmlns:tools="http://schemas.android.com/tools">
   <data>

   data>
   <androidx.constraintlayout.widget.ConstraintLayout
           android:layout_width="match_parent"
           android:layout_height="match_parent">

       

3.根据需要添加 layout 变量和 layout 表达式。

<data>
        <variable name="name" type="String"/>
        <variable name="lastName" type="String"/>
    data>
    
<TextView
                android:id="@+id/plain_name"
                android:text="@{name}" 
        ... />

使用 layout 表达式，有以下几个好处：

• 改善应用程序的性能；
• 能够防止内存泄漏和空指针异常；
• 通过删除框架的调用，达到了简化 Activity 的目的。

4.修改 Activity 中的布局填充，使用 DataBindingUtil.setContentView() 方法替换 setContentView() 方法。

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //setContentView(R.layout.plain_activity)
       val binding: PlainActivitySolution2Binding =
            DataBindingUtil.setContentView(this, R.layout.plain_activity_solution_2)

        binding.name = "Scott"
        binding.lastName = "Song"
}

至此，就可以通过 binding 变量来控制 UI 中的内容了。

上面的示例中使用到了 layout 变量和 layout 表达式，我们接下来归纳一下它们的使用。

3.2 layout 变量和 layout 表达式

DataBinding 中 layout 变量是在 标签下，通过

    <layout xmlns:android="http://schemas.android.com/apk/res/android">
       <data>
       <data>  
        <variable  name="str"  type="String"/>  
        <variable name="user" type="com.example.User"/>
       data>
......

使用 Java 中基本类型时，不需要进行导包，自定义的类型，需要指定完成的路径。每个 variable 都声明了一个在布局文件生成的绑定类的属性。

如果针对不同的配置，有多个布局文件，（比如横向和纵向），则变量会合并在一起，这些布局文件之间不能存在有冲突的变量定义。

在生成的绑定类中，每一个变量都有一个对应的 setter 和 getter，在调用 setter 之前，这些变量都有默认值，引用类型的默认值 null，boolean 类型的默认值 false，int 类型的默认值 0。

另外，系统会根据需要生成名为 context 的特殊变量，用于绑定表达式。context 的值是根 View 的 getContext() 方法中的 Context 对象。context 变量会被具有该名称的显式变量声明替换。

DataBinding 中的 layout 表达式是通过 lambda 定义的，格式为 @{ }，比如上面示例代码中的User 类型的变量，layout 表达式中可以这样使用。

<TextView android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              android:text="@{user.firstName}" />

layout 表达式的功能非常强大，我们总结归纳为以下几点：

1. layout 表达式中支持以下运算符的使用：

• 算术运算符 + - / * %
• 字符串连接运算符 +
• 逻辑运算符 && ||
• 二元运算符 & | ^
• 一元运算符 + - ! ~
• 移位运算符 >> >>> <<
• 比较运算符 == > < >= <=（请注意，< 需要转义为 <）
• instanceof
• 分组运算符 ()
• 字面量运算符 - 字符、字符串、数字、null
• 类型转换
• 方法调用
• 字段访问
• 数组访问 []
• 三元运算符 ?:

示例代码：

android:text="@{String.valueOf(index + 1)}"
    android:visibility="@{age > 13 ? View.GONE : View.VISIBLE}"
    android:transitionName='@{"image_" + id}'

2. 在 layout 表达式中不支持关键字 this、super、new 以及显示的泛型调用。

**3.layout 表达式会自动进行判空操作，避免出现空指针异常。**例如，在表达式 @{user.name} 中，如果 user 为 Null，则为 user.name 分配默认值 null。如果您引用 user.age，其中 age 的类型为 int，则数据绑定使用默认值 0。另外 layout 表达式还支持 Null 合并运算符(??)， 比如：

android:text="@{user.displayName ?? user.lastName}"

如果左边运算数不是 null，则 Null 合并运算符 (??) 选择左边运算数，如果左边运算数为 null ，则选择右边运算数。

4.在 layout 表达式中使用数组、列表、Map、稀疏列表，首先需要使用进行导包，然后使用 [] 运算符访问。比如：

<data>
        <import type="android.util.SparseArray"/>
        <import type="java.util.Map"/>
        <import type="java.util.List"/>
        <variable name="list" type="List<String>"/>
        <variable name="sparse" type="SparseArray<String>"/>
        <variable name="map" type="Map<String, String>"/>
        <variable name="index" type="int"/>
        <variable name="key" type="String"/>
    data>
    …
    android:text="@{list[index]}"
    …
    android:text="@{sparse[index]}"
    …
    android:text="@{map[key]}"

示例中的 @{map[key]} 也可替换为 @{map.key}，不要写成 List 形式，而是必须写成 List，否则会导致 xml 的语法错误。

5.使用 layout 表达式访问资源时， 可以通过以下语法：

android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"

如果是通过格式化字符串的方式，可以通过提供参数进行求值，比如：

Have an orange
Have %d oranges

android:text="@{@plurals/orange(orangeCount, orangeCount)}"  

对以下资源的访问，需要显示类型求值。

类型	常规引用	layout表达式引用
String[]	@array	@stringArray
int[]	@array	@intArray
TypedArray	@array	@typedArray

Animator @animator @animator StateListAnimator @animator @stateListAnimator color int @color @color ColorStateList @color @colorStateList

6.如果 layout 表达式中引入的多个包中，出现了类型冲突，可以使用别名。，比如：

<import type="android.view.View"/>
    <import type="com.example.real.estate.View"
            alias="Vista"/>

在布局文件中使用 Vista 引用 com.example.real.estate.View，使用 View 引用 android.view.View。

还可以使用导入的类型来对表达式的一部分进行类型转换，比如：

<TextView
       android:text="@{((User)(user.connection)).lastName}"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"/>

示例将 connection 属性强制转换为类型 User。

此外，还可以在表达式中引用静态字段和方法，比如：

<data>
        <import type="com.example.MyStringUtils"/>
        <variable name="user" type="com.example.User"/>
    data>
    …
    <TextView
       android:text="@{MyStringUtils.capitalize(user.lastName)}"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"/>

示例使用 MyStringUtils 中的 capitalize() 方法。

**7. layout表达式还可以用在 标签中，不能作为 的直接子元素。**比如：

    <layout xmlns:android="http://schemas.android.com/apk/res/android"
            xmlns:bind="http://schemas.android.com/apk/res-auto">
       <data>
           <variable name="user" type="com.example.User"/>
       data>
       <LinearLayout
           android:orientation="vertical"
           android:layout_width="match_parent"
           android:layout_height="match_parent">
           <include layout="@layout/name"
               bind:user="@{user}"/>
           <include layout="@layout/contact"
               bind:user="@{user}"/>
       LinearLayout>
    layout>

示例中的布局文件中，包含 name.xml 和 contact.xml，变量可以从包含的布局传递到被包含布局中。在name.xml 以及 contact.xml 两个 layout 文件中必需要有 user 变量。

**DataBinding 不支持 include 作为 merge 元素的直接子元素。**比如，下面这样的布局是不支持的。

    <layout xmlns:android="http://schemas.android.com/apk/res/android"
            xmlns:bind="http://schemas.android.com/apk/res-auto">
       <data>
           <variable name="user" type="com.example.User"/>
       data>
       <merge>
           <include layout="@layout/name"
               bind:user="@{user}"/>
           <include layout="@layout/contact"
               bind:user="@{user}"/>
       merge>
    layout>

3.3 使用 layout 表达式处理事件

DataBinding 中处理事件有两种方式，分别是：方法引用 和 监听器绑定。下面分别来看一下：

1.方法引用，在使用 DataBinding 以前，如果实现页面中的点击事件，可以 android:onClick 中指定Activity的一个方法，使用 DataBinding 处理事件，在编译时对方法进行安全性检查。不会出现因为方法不存在，或者方法签名不一致，出现崩溃的问题。

接下来看一下具体的实现：

class MyHandlers {
        fun onClickFriend(view: View) { ... }
}

使用 layout 表达式，将 android:onClick 指定到 onClickFriend() 方法：

    <layout xmlns:android="http://schemas.android.com/apk/res/android">
       <data>
           <variable name="handlers" type="com.example.MyHandlers"/>
           <variable name="user" type="com.example.User"/>
       data>
       <LinearLayout
           android:orientation="vertical"
           android:layout_width="match_parent"
           android:layout_height="match_parent">
           <TextView android:layout_width="wrap_content"
               android:layout_height="wrap_content"
               android:text="@{user.firstName}"
               android:onClick="@{handlers::onClickFriend}"/>
       LinearLayout>
    layout>

需要注意的是，layout 表达式中的方法签名必须与对象中的方法签名完全一致。

2.监听器绑定，监听器绑定和方法引用的主要区别在于创建时机的不同，监听器实现是在绑定数据时创建的，而不是在事件触发时创建的。另外在方法引用中，方法的参数必须与事件监听器的参数匹配。在监听器绑定中，只有您的返回值必须与监听器的预期返回值相匹配。

接下来看一下监听器绑定的具体实现：

class Presenter {
     fun onSaveClick(task: Task){}
}

然后将点击事件绑定到 onSaveClick() 方法上。

    <layout xmlns:android="http://schemas.android.com/apk/res/android">
        <data>
            <variable name="task" type="com.android.example.Task" />
            <variable name="presenter" type="com.android.example.Presenter" />
        data>
        <LinearLayout android:layout_width="match_parent" android:layout_height="match_parent">
            <Button android:layout_width="wrap_content" android:layout_height="wrap_content"
            android:onClick="@{() -> presenter.onSaveClick(task)}" />
        LinearLayout>
    layout>

在表达式中使用回调时，数据绑定会自动为事件创建并注册必要的监听器。当视图触发事件时，数据绑定会对给定表达式求值。

避免使用复杂的监听器，这样会使布局文件变得难以阅读和维护。

3.4 使用 DataBinding 对界面数据动态更新

通过 DataBinding，使得绑定到界面的数据对象，在发生更改时，界面会自动刷新，总结起来有两种方法，这两种方法的本质都是使数据对象具有可观察性。

可观察性是指一个对象将其数据变化通知给其他对象的能力。

• 方法 1 DataBinding 配合 LiveData 使用。
• 方法 2 使用 Observable 接口，ObservableArrayList 等类使数据类变得可观察。

接下来我们分别看一下这两种方法。

**方法 1 DataBinding 配合 LiveData 使用，**首先将数据类型声明为 LiveData 类型。

class ScheduleViewModel : ViewModel() {
        val userName: LiveData

        init {
            val result = Repository.userName
            userName = Transformations.map(result) { result -> result.value }
        }
    }

要将 LiveData 对象与绑定类一起使用，需要指定生命周期所有者（LifecycleOwner）来定义对象的范围。

class ViewModelActivity : AppCompatActivity() {
        override fun onCreate(savedInstanceState: Bundle?) {
            // Inflate view and obtain an instance of the binding class.
            val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)

            // Specify the current activity as the lifecycle owner.
            binding.setLifecycleOwner(this)
        }
    }

**方法 2 使用 Observable 接口，ObservableArrayList 等类使数据类变得可观察。**通常一个可观察类会有三种类型，分别是可观察字段、可观察对象和可观察集合。分别来看一下：

可观察字段（ObservableField），Java 语言使用 public final 属性，在 Kotlin 中创建只读属性，比如：

class User {
        val firstName = ObservableField<String>()
        val lastName = ObservableField<String>()
        val age = ObservableInt()
    }

DataBinding 组件为基本类型都定义了可观察的类型，包括：

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

可观察集合，除了上述的基本类型，DataBinding 组件还提供集合的可观察类型，包括：

• ObservableArrayMap
• ObservableArrayList

示例代码：

ObservableArrayList<Any>().apply {
        add("Google")
        add("Inc.")
        add(17)
    }

在布局中，可通过索引访问列表，比如：

<data>
        <import type="android.databinding.ObservableList"/>
        <import type="com.example.my.app.Fields"/>
        <variable name="user" type="ObservableList