布局和绑定表达式

借助表达式语言,您可以编写表达式来处理视图分派的事件。数据绑定库会自动生成将布局中的视图与您的数据对象绑定所需的类。

数据绑定布局文件略有不同,以根标记 layout 开头,后跟 data 元素和 view 根元素。此 view 元素就是非绑定布局文件中的根。以下代码展示了一个示例布局文件:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
   <data>
       <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}"/>
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.lastName}"/>
   </LinearLayout>
</layout>

data 中的 user 变量描述了可在此布局中使用的属性:

<variable name="user" type="com.example.User" />

布局中的表达式使用 @{} 语法在特性属性中编写。在以下示例中,TextView 文本设置为 user 变量的 firstName 属性:

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

数据对象

假设您有一个用于描述 User 实体的普通对象:

Kotlin

data class User(val firstName: String, val lastName: String)

Java

public class User {
  public final String firstName;
  public final String lastName;
  public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
  }
}

此类型的对象拥有永不改变的数据。在应用中,通常会有一些数据在读取一次后便不再发生变化。也可以使用遵循一组惯例的对象,例如在 Java 编程语言中使用访问器方法,如以下示例所示:

Kotlin

// Not applicable in Kotlin.
data class User(val firstName: String, val lastName: String)

Java

public class User {
  private final String firstName;
  private final String lastName;
  public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
  }
  public String getFirstName() {
      return this.firstName;
  }
  public String getLastName() {
      return this.lastName;
  }
}

从数据绑定的角度来看,这两个类是等效的。用于 android:text 属性的表达式 @{user.firstName} 会访问前一个类中的 firstName 字段和后一个类中的 getFirstName() 方法。如果 firstName() 方法存在,它也会解析为该方法。

绑定数据

系统会为每个布局文件生成一个绑定类。默认情况下,类的名称基于布局文件的名称(转换为 Pascal 大小写形式),并添加了 Binding 后缀。例如,上述布局文件名为 activity_main.xml,因此生成的对应绑定类为 ActivityMainBinding。

此类包含从布局属性(例如 user 变量)到布局视图的所有绑定,并知道如何为绑定表达式分配值。我们建议您在扩充布局时创建绑定,如以下示例所示:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val binding: ActivityMainBinding = DataBindingUtil.setContentView(
            this, R.layout.activity_main)

    binding.user = User("Test", "User")
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
   User user = new User("Test", "User");
   binding.setUser(user);
}

在运行时,应用会在界面中显示 Test 用户。或者,您也可以使用 LayoutInflater 获取视图,如以下示例所示:

Kotlin

val binding: ActivityMainBinding = ActivityMainBinding.inflate(getLayoutInflater())

Java

ActivityMainBinding binding = ActivityMainBinding.inflate(getLayoutInflater());

如果您在 Fragment、ListView 或 RecyclerView 适配器中使用数据绑定项,则可能更愿意使用绑定类的 inflate() 方法或 DataBindingUtil 类,如以下代码示例所示:

Kotlin

val listItemBinding = ListItemBinding.inflate(layoutInflater, viewGroup, false)
// or
val listItemBinding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false)

Java

ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false);
// or
ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);

表达式语言

常见功能

表达式语言与托管代码中的表达式非常相似。您可以在表达式语言中使用以下运算符和关键字:

  • 数学:+ - / * %
  • 字符串串联:+
  • 逻辑:&& ||
  • 二进制:& | ^
  • 一元:+ - ! ~
  • 班次:>> >>> <<
  • 比较:== > < >= <=(< 需要转义为 &lt;)
  • instanceof
  • 分类:()
  • 字面量,例如字符、字符串、数字、null
  • 投屏
  • 方法调用
  • 字段访问
  • 数组访问:[]
  • 三元运算符:?:

下面是一些示例:

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

缺少的运算

您可以在托管代码中使用的表达式语法缺少以下操作:

  • this
  • super
  • new
  • 显式泛型调用

Null 合并运算符

如果左操作数不为 null,则 null 合并运算符 (??) 会选择左操作数;如果左操作数为 null,则选择右操作数:

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

这在功能上等同于以下内容:

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

属性引用

表达式可以使用以下格式引用类中的属性,这对于字段、getter 和 ObservableField 对象来说是相同的:

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

避免 null 指针异常

生成的数据绑定代码会自动检查 null 值并避免 null 指针异常。例如,在表达式 @{user.name} 中,如果 user 为 null,则 user.name 会被赋予其默认值 null。如果您引用 user.age(其中 age 的类型为 int),则数据绑定会使用默认值 0。

视图引用

表达式可以使用以下语法按 ID 引用布局中的其他视图:

android:text="@{exampleText.text}"

在以下示例中,TextView 视图引用了同一布局中的 EditText 视图:

<EditText
    android:id="@+id/example_text"
    android:layout_height="wrap_content"
    android:layout_width="match_parent"/>
<TextView
    android:id="@+id/example_output"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@{exampleText.text}"/>

集合

为方便起见,您可以使用 [] 运算符访问常见集合,例如数组、列表、稀疏列表和映射。

<data>
    <import type="android.util.SparseArray"/>
    <import type="java.util.Map"/>
    <import type="java.util.List"/>
    <variable name="list" type="List&lt;String>"/>
    <variable name="sparse" type="SparseArray&lt;String>"/>
    <variable name="map" type="Map&lt;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]}"

您还可以使用 object.key 表示法引用映射中的值。例如,您可以将上述示例中的 @{map[key]} 替换为 @{map.key}。

字符串字面量

您可以使用单引号括住属性值,这样您就可以在表达式中使用双引号,如以下示例所示:

android:text='@{map["firstName"]}'

您也可以使用英文双引号将属性值括起来。执行此操作时,字符串字面量必须用反引号 ` 括起来,如下所示:

android:text="@{map[`firstName`]}"

资源

表达式可以使用以下语法引用应用资源:

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

您可以通过提供参数来评估格式字符串和复数形式:

android:text="@{@string/nameFormat(firstName, lastName)}"
android:text="@{@plurals/banana(bananaCount)}"

您可以将属性引用和视图引用作为资源参数进行传递:

android:text="@{@string/example_resource(user.lastName, exampleText.text)}"

如果复数形式接受多个参数,请传递所有参数:


  Have an orange
  Have %d oranges

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

某些资源需要显式类型评估,如下表所示:

类型 常规引用 表达式引用
String[] @array @stringArray
int[] @array @intArray
TypedArray @array @typedArray
Animator @animator @animator
StateListAnimator @animator @stateListAnimator
color int @color @color
ColorStateList @color @colorStateList

事件处理

借助数据绑定,您可以编写表达式来处理从视图分派的事件,例如 onClick() 方法。事件属性名称由监听器方法的名称决定,但有一些例外情况。例如,View.OnClickListener 具有方法 onClick(),因此该事件的属性为 android:onClick。

有些专门针对点击事件的事件处理脚本需要使用 android:onClick 以外的属性,以避免冲突。您可以使用以下属性来避免这些类型的冲突:

类 监听器 setter 属性
SearchView setOnSearchClickListener(View.OnClickListener) android:onSearchClick
ZoomControls setOnZoomInClickListener(View.OnClickListener) android:onZoomIn
ZoomControls setOnZoomOutClickListener(View.OnClickListener) android:onZoomOut

您可以使用以下两种机制(在后续部分中详细介绍)来处理事件:

  • 方法引用:在表达式中,您可以引用符合监听器方法签名的方法。当表达式求值结果为方法引用时,数据绑定会将方法引用和所有者对象封装在监听器中,并在目标视图上设置该监听器。如果表达式的计算结果为 null,则数据绑定不会创建监听器,而是设置 null 监听器。
  • 监听器绑定:这些是在事件发生时求值的 lambda 表达式。数据绑定始终会创建一个监听器,并在视图上设置该监听器。分派事件后,监听器会评估 lambda 表达式。

方法引用

您可以将事件直接绑定到处理程序方法,类似于将 android:onClick 分配给 activity 中的方法。与 View onClick 属性相比,其优势在于表达式会在编译时间进行处理。因此,如果该方法不存在或其签名不正确,您会收到编译时错误。

方法引用与监听器绑定之间的主要区别在于,实际监听器实现是在绑定数据时创建的,而不是在触发事件时创建的。如果您希望在事件发生时评估表达式,请使用监听器绑定。

如需将事件分配给其处理脚本,请使用常规绑定表达式,并将要调用的方法名称作为值。例如,请考虑以下示例布局数据对象:

Kotlin

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

Java

public class MyHandlers {
    public void onClickFriend(View view) { ... }
}

绑定表达式可以将视图的点击监听器分配给 onClickFriend() 方法,如下所示:

<?xml version="1.0" encoding="utf-8"?>
<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>

监听器绑定

监听器绑定是在事件发生时运行的绑定表达式。它们类似于方法引用,但允许您运行任意数据绑定表达式。此功能适用于 Android Gradle 插件 2.0 及更高版本。

在方法引用中,方法的参数必须与事件监听器的参数一致。在监听器绑定中,只有返回值必须与监听器的预期返回值一致,除非预期返回值为 void。例如,假设有以下具有 onSaveClick() 方法的 presenter 类:

Kotlin

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

Java

public class Presenter {
    public void onSaveClick(Task task){}
}

您可以将点击事件绑定到 onSaveClick() 方法,如下所示:

<?xml version="1.0" encoding="utf-8"?>
<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>

在表达式中使用回调时,数据绑定会自动创建必要的监听器,并将其注册到事件。当视图触发事件时,数据绑定会评估给定表达式。与常规绑定表达式一样,在对这些监听器表达式进行求值时,您仍可以获得数据绑定的 null 安全性和线程安全性。

在上述示例中,未定义传递到 onClick(View) 的 view 参数。监听器绑定为监听器参数提供了两种选择:您可以忽略方法的所有参数,也可以为所有参数命名。如果您希望为参数命名,可以在表达式中使用这些参数。例如,您可以将上述表达式编写如下:

android:onClick="@{(view) -> presenter.onSaveClick(task)}"

如果您想在表达式中使用该参数,可以按如下方式操作:

Kotlin

class Presenter {
    fun onSaveClick(view: View, task: Task){}
}

Java

public class Presenter {
    public void onSaveClick(View view, Task task){}
}
android:onClick="@{(theView) -> presenter.onSaveClick(theView, task)}"

您还可以使用包含多个形参的 lambda 表达式:

Kotlin

class Presenter {
    fun onCompletedChanged(task: Task, completed: Boolean){}
}

Java

public class Presenter {
    public void onCompletedChanged(Task task, boolean completed){}
}
<CheckBox android:layout_width="wrap_content" android:layout_height="wrap_content"
      android:onCheckedChanged="@{(cb, isChecked) -> presenter.completeChanged(task, isChecked)}" />

如果您监听的事件返回的值类型不是 void,则表达式也必须返回相同类型的值。例如,如果您想监听轻触并按住(长按)事件,表达式必须返回一个布尔值。

Kotlin

class Presenter {
    fun onLongClick(view: View, task: Task): Boolean { }
}

Java

public class Presenter {
    public boolean onLongClick(View view, Task task) { }
}
android:onLongClick="@{(theView) -> presenter.onLongClick(theView, task)}"

如果表达式因 null 对象而无法求值,则数据绑定会返回该类型的默认值,例如引用类型的默认值为 null,int 的默认值为 0,boolean 的默认值为 false。

如果您需要使用带有谓词的表达式(例如三元表达式),则可以使用 void 作为符号:

android:onClick="@{(v) -> v.isVisible() ? doSomething() : void}"

避免使用复杂的监听器

监听器表达式功能强大,可让您的代码更易于阅读。另一方面,包含复杂表达式的监听器会使布局更难阅读和维护。让表达式尽可能简单,例如将可用数据从界面传递到回调方法。在您从监听器表达式调用的回调方法中实现任何业务逻辑。

导入、变量和包含

数据绑定库提供了导入、变量和包含等功能。通过导入,您可以在布局文件中轻松引用类。 通过变量,您可以描述可在绑定表达式中使用的属性。 通过包含功能,您可以在整个应用中重复使用复杂的布局。

导入

通过导入,您可以在布局文件中引用类,就像在托管代码中一样。 您可以在 data 元素中使用零个或多个 import 元素。以下代码示例将 View 类导入到布局文件:

<data>
    <import type="android.view.View"/>
</data>

导入 View 类后,您就可以从绑定表达式中引用它。 以下示例展示了如何引用 View 类的 VISIBLE 和 GONE 常量:

<TextView
   android:text="@{user.lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:visibility="@{user.isAdult ? View.VISIBLE : View.GONE}"/>

类型别名

如果存在类名称冲突,您可以将其中一个类重命名为别名。以下示例会将 com.example.real.estate 软件包中的 View 类重命名为 Vista:

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

然后,您可以在布局文件中使用 Vista 引用 com.example.real.estate.View,使用 View 引用 android.view.View。

导入其他类

您可以在变量和表达式中将导入的类型用作类型引用。以下示例展示了用作变量类型的 User 和 List:

<data>
    <import type="com.example.User"/>
    <import type="java.util.List"/>
    <variable name="user" type="User"/>
    <variable name="userList" type="List&lt;User>"/>
</data>

您可以使用导入的类型来转换表达式的一部分。以下示例将 connection 属性转换为 User 类型:

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

在表达式中引用静态字段和方法时,您也可以使用导入的类型。以下代码会导入 MyStringUtils 类并引用其 capitalize 方法:

<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"/>

就像在托管代码中一样,系统会自动导入 java.lang.*。

变量

您可以在 data 元素中使用多个 variable 元素。每个 variable 元素都描述了可以在布局上设置的属性,该属性用于布局文件中的绑定表达式。以下示例声明了 user、image 和 note 变量:

<data>
    <import type="android.graphics.drawable.Drawable"/>
    <variable name="user" type="com.example.User"/>
    <variable name="image" type="Drawable"/>
    <variable name="note" type="String"/>
</data>

变量类型会在编译时进行检查,因此,如果变量实现 Observable 或属于可观察集合,则必须在类型中反映出来。如果变量是未实现 Observable 接口的基类或接口,则不会观察这些变量。

如果各种配置(例如横向或纵向)有不同的布局文件,则变量会合并。这些布局文件之间不得存在冲突的变量定义。

生成的绑定类具有用于每个所述变量的 setter 和 getter。在调用 setter 之前,变量会采用默认的托管代码值,即引用类型为 null,int 为 0,boolean 为 false,等等。

系统会根据需要生成一个名为 context 的特殊变量,以便在绑定表达式中使用。context 的值是根视图的 getContext() 方法中的 Context 对象。context 变量会被具有该名称的显式变量声明替换。

包含

您可以使用应用命名空间和特性中的变量名称,将变量从包含的布局传递到被包含布局的绑定。以下示例显示了 name.xml 和 contact.xml 布局文件中包含的 user 变量:

<?xml version="1.0" encoding="utf-8"?>
<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>

数据绑定不支持将 include 作为 merge 元素的直接子元素。 例如,不支持以下布局:

<?xml version="1.0" encoding="utf-8"?>
<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><!-- Doesn't work -->
       <include layout="@layout/name"
           bind:user="@{user}"/>
       <include layout="@layout/contact"
           bind:user="@{user}"/>
   </merge>
</layout>

其他资源

如需详细了解数据绑定,请参阅以下其他资源。

示例

博文