Data Binding Library官方文档中文翻译

2018-04-16 本文已影响49人 xiaobug

Google Data Binding Library官方文档原文地址

Data Binding Library 数据绑定库

本文档解释了如何使用Data Binding Library编写声明式布局，并尽量减少绑定应用程序逻辑和布局所需的胶合代码。
Data Binding Library提供了灵活性和广泛的兼容性 - 它是一个支持库，所以您可以将它与所有Android平台版本一起使用回到Android 2.1（API级别7+）。
使用DataBinding要求Gradle插件为1.5.0-alpha1及以上版本。查看如何升级Gradle插件。

Build Environment 构建环境

使用Data Binding之前,需要用Android SDK manager 在Support repository中下载依赖库。
配置app使用data binding,在app模块下的build.gradle文件中添加dataBinding元素。

android {
    ....
    dataBinding {
        enabled = true
    }
}

如果你的app模块依赖的library使用了data binding,你的app模块也必须在它的build.gradle文件中配置data binding。
同时，确定你使用的是兼容版本的Android Studio，Android Studio 1.3及更高版本支持data binding ，如Android Studio Support for Data Binding中所说的那样。

Data Binding Compiler V2 数据绑定编译器V2

Android Gradle Plugin 3.1.0 Canary 6 附带了一个可选的新编译器。要开始使用它，更新你的gradle.properties 文件使它包含下面这行内容

 android.databinding.enableV2=true

在编译器V2中:

ViewBinding 类由Android Gradle Plugin在java编译器之前自动生成。如果java编译由于不相关的原因失败,这样可以避免很多真实的错误.
在v1中,编译应用程序时将重新生成库的绑定类(分享生成的代码并访问最终的BR和R文件).在v2中,库保留其生成的绑定类以及映射器信息，从而显着提高多模块项目的数据绑定性能。

请注意，这个新编译器向后不兼容，因此使用v1编译的库不能被v2使用，反之亦然。
V2也减少了一些很少使用的功能：

在v1中,一个应用程序能够提供可以覆盖依赖中的适配器的绑定适配器.在v2中,它只会对您自己的模块/应用程序及其依赖项中的代码生效.
以前,如果一个布局文件在2个或更多不同资源配置中包含一个具有相同id,不同类的View.Data Binding将会查找最常见的父类.在V2中,当类型和配置不匹配时,它会默认是view.
在v2中,不同的模块将不能在manifest使用相同的包名,因为Data Binding将会使用该包名来生成绑定映射器类.

Data Binding Layout Files 数据绑定布局文件

Writing your first set of data binding expressions 编写第一个数据绑定表达式

Data-binding 布局文件是略有不同的,以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描述了一个属性,可以在这个布局中使用.

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

布局中的表达式使用@{}语法.下面是将TextView的text设置成user的firstName属性

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

Data Object 数据对象

让我们假设有一个普通的java对象类User:

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

这种类型的对象的数据从不变化.在应用程序中读取一次,数据一直不变的数据很正常.也可以使用JavaBeans对象:

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;
   }
}

从数据板顶的角度看,有两个类是等价的.TextView中android:text属性使用的@{user.firstName}表达式将会获取前一个类的firstName变量和后面类中的 getFirstName()方法.无论哪种方式,如果该方法存在,都会被解析成firstName()方法.

Binding Data 绑定数据

默认情况下,一个Binding类会以资源文件的名称为基础创建,将其转化为驼峰命名并以Binding结尾.上面资源文件是main_activity.xml所以自动生成的类是MainActivityBinding.这个类包含了布局中的所有视图的所有绑定的属性(如,user变量),并且知道如何为绑定表达式赋值.创建绑定最容易的方法是在它inflating的时候:

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

完成后,运行程序,你可以在UI中看到Test User.或者,你可以通过下面的方式:

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

如果你使用数据绑定ListView获取RecyclerView 适配器的条目,你或许更喜欢下面的方法:

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

Event Handling 事件绑定

Data Binding允许您编写处理从view分发事件的表达式(如onClick)。事件属性名称由监听方法的名称控制，只有少数例外。例如,View.OnLongClickListener有一个onLongClick()方法.所以这个时间的属性是android:onLongClick,有两种方法去处理事件.

Method References:在表达式中，可以引用符合listener方法签名的方法。当表达式计算为方法引用时，Data Binding将方法引用和所有者对象包装在listener中,并且将listener设置到目标view上.如果表达式计算为null，则Data Binding不会创建listener，而是设置一个空listener。
Listener Bindings:这是在事件发生时被计算的lambda表达式.Data Binding 总是创建一个listener,并将它设置到view上.当事件被分发时,listener计算lambda表达式

Method References 方法引用

事件可以直接绑定到处理程序方法,类似于android:onClick可以分配到一个Activity中.相比较view#onClick一个主要的优势是该表达式在编译时被处理,所以如果这个方法不存在或者签名不正确,你会收到一个编译时错误.

Method References和Listener Bindings主要的区别是实际的监听器是在数据绑定时创建的,而不是在事件触发时.如果你喜欢在事件发生时计算表达式,你应该使用listener binding.

将事件分配给它的处理程序,使用一个正常的绑定表达式,以值为方法名调用.举个例子,如果你的data对象有两个方法:

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

绑定表达式可以为view指派一个click listener:

<?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>

注意,表达式中的方法签名必须和监听事件中的方法签名完全匹配.

Listener Bindings 监听事件绑定

Listener Bindings 是当事件发生时才运行的绑定表达式.它和方法引用相似 ,但是它可以运行任何数据绑定的表达式.此特性适用于Gradle 2.0版及更高版的Android Gradle插件.
在方法引用中,该方法的参数必须和listener的参数匹配.在监听器绑定中,只有你的返回值必须和listener匹配(除非返回值是void).举个栗子,你可以有一个具有下面方法的presenter类:

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

然后,你可以按照下面的写法绑定click事件:

  <?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>

监听器由仅允许作为表达式的根元素的lambda表达式代理.当表达式中使用回调时,Data Binding自动为该事件创建相关的监听器和注册器.当view触发该事件,Data Bindign解析给出的表达式.在一般的绑定表达式中,在编译监听表达式时,你任然可以获取null和线程安全性.
注意上面的例子,我们没有定义传入onClick(android.view.View)的view参数.Listener bindings 为监听参数提供了两种选择:你可以省略忽略该方法的所有参数或者命名所有参数.如果你喜欢声明参数,你可以在你的表达式中使用它.举个栗子,上面的表达式将会改为:

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

或者你如果想在表达式中使用这个参数,像下面这样写:

public class Presenter {
    public void onSaveClick(View view, Task task){}
}

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

你可以使用多参的lambda表达式:

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,你的表达式也必须返回相同类型的返回值.举个栗子,如果你想监听long click 事件,你的表达式必须返回boolean值.

public class Presenter {
    public boolean onLongClick(View view, Task task){}
}

android:onLongClick="@{(theView) -> presenter.onLongClick(theView, task)}"

如果表达式不能被解析成null对象.Data Binding返回该类型的默认值.举个栗子,引用类型为null,int类型为0,boolen类型是false,等等.
如果你需要使用带断言的表达式(如,三元运算符),你可以使用void作为符号.

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

Avoid Complex Listeners 避免复杂的监听

Listener表达式非常强大，可以让你的代码非常容易阅读。另一方面,监听器包含复杂的表达式会使你的布局难以阅读和无法维护.这些表达式应该像从UI传递数据到回调方法一样简单.你应该在把业务逻辑放到监听表达式调用的回调方法中处理.
存在一些专门的单击事件,他们需要一个除了android:onClick来避免冲突.下面的属性就是为了避免冲突而创建的:

image.png

Layout Details 布局详情

Imports 导包

data元素内可以使用0个或多个import元素.这些可以轻松引用布局文件中的类,就像在Java中一样.

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

现在,你可以在你的绑定表达式中使用View了

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

当类名冲突的时候,其中一个类可以重命名为一个"别名":

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

现在,Vista类被用作com.example.real.estate.View的引用,并且View类作为android.view.View在布局文件中.导入的类型可以用作变量和表达式中的引用.

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

注意:Android Studio暂不支持自动导包.你的应用可以正常使用,你可以在你的变量定义中通过使用全包名来解决IDE的问题.

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

导入的类型也可以在表达式中用于静态变量和静态方法上:

<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中java.lang.*一样的自动导入的.

Variables 变量

data元素内可以使用任意数量的variable元素.layout中的每个variable元素描述了一个属性,都可以在布局文件中在绑定表达式中被使用.

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

变量的类型在编译器被检查,如果一个变量实现了android.databinding.Observable或者是observable collection,那应该被反应在类型中.如果变量是不实现Observable*接口的基类或接口,将不会被观察!
当布局文件有不同的配置(横向或纵向),变量将被合并.这些布局文件直接必须不存在冲突的变量定义.
自动生成的绑定类对于每个描述的变量都提供了setter和getter方法.变量将具有java默认值,直到setter方法被调用-引用类型中的null,int类型的0,boolean的false,等等.
根据需求为我们的绑定表达式生成一个特殊的变量context. context的值是根布局的getContext()方法提供的Context.context变量奖杯具有该名称的显示变量所覆盖.

Custom Binding Class Names 自定义绑定类的名称

默认情况下,绑定类是以布局文件的名称为基础生成的,以大写字母开头,删除下划线并将后面字母大写,最后以"Binding"结尾.这个类将会生成在模块包下的数据绑定包下.举个栗子,布局文件contact_item.xml将会生成ContactItemBinding.如果模块的包名是com.example.my.app,该类将会创建在com.example.my.app.databinding包下面.
通过调整data元素的class属性,绑定类可以重命名或放在不同包下.举个栗子:

<data class="ContactItem">
    ...
</data>

这将会在模块的包下面,databindingg包下生成一个ContactItem类.如果想要在模块包内不同的包下生成这个类,需要在前面加".":

<data class=".ContactItem">
   ...
</data>

在这个例子中, ContactItem是直接在模块包中生成的.如果你提供的是一个全包名的话,可以在任意包下生成:

<data class="com.example.ContactItem">
    ...
</data>

Includes include标签

变量从包含的布局传递到include的布局的绑定中,通过程序的命名空间和属性的变量名:

<?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>

现在,在name.xml和contact.xml布局文件中必须有一个user变量.
Data Binding不支持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>
       <include layout="@layout/name"
           bind:user="@{user}"/>
       <include layout="@layout/contact"
           bind:user="@{user}"/>
   </merge>
</layout>

Expression Language 表达式语法

Common Features 通用特性

表达式语法非常像Java表达式.相同的有:

数学运算 + - / * %
字符串拼接 +
逻辑运算 && ||
二进制 & | ^
一元运算 + - ! ~
位运算 >> >>> <<
比较 == > < >= <=
instanceof
分组 ()
数据类型 character,String,numeric,null
类型转换
方法回调
数据属性
数组 []
三元操作符 ?:
例子:

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

Missing Operations 缺失的语法

缺少了一小部分Java中的表达式语法.

this
super
new
显式泛型调用

Null Coalescing Operator 空合并运算符

空合并运算符(??)如果不是空的话就用左边的,是空的话就用右边的.

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

功能上等同于:

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

Property Reference 属性引用

在"Writing your first set of data binding expressions"节中已经讨论过了,简单的JavaBean引用.当在一个类中,一个表达式引用一个属性时,他使用相同的格式对于字段,获取,或者观察者的字段.

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

Avoiding NullPointerException 避免空指针

生成的数据绑定的代码hi自动检测null值,避免空指针.举个栗子,在表达式@{user.name}中,如果user的值为null,user.name将分配其默认值(null).如果你引用的是user.age,age的是int类型,默认值将会是0.

Collections 集合

普通集合:arrays,list,sparse list,map集合,可以通过[]操作符方便的访问.

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

String Literals 字符串文本

在属性值的外面使用单引号,在表达式中使用双引号就会很容易:

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

也可以在属性值的外面使用双引号,如果这样做了,字符串需要用正引号或反引号:

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

Resources 资源
使用正常语法可以将资源作为表达式的一部分进行访问:

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

可以通过提供参数来进行格式化字符串,复数:

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

当一个复数需要多个参数时，应该传递所有参数：

Have an orange
Have %d oranges
android:text="@{@plurals/orange(orangeCount, orangeCount)}"

有些资源需要明确解析类型.

image.png

Data Objects 数据对象

任何普通JavaBeans(POJO)都可以用于数据绑定,但是修改POJO不会导致UI更新.数据绑定的真正能力是使用时,可以赋予数据对象变化时的通知能力.有三种不同的更改通知机制,Observable对象,observable字段和observable集合.
当这些可观察数据对象之一绑定到UI并且数据对象的属性改变时,UI将会自动更新.

Observable Objects 观察者对象

一个类实现了android.databinding.Observable接口,将允许绑定单个监听器去绑定对象来监听对象上所有的属性改变.
android.databinding.Observable接口具有添加和删除侦听器的机制，但通知由开发人员决定。为了简化开发,一个基类,android.databinding.BaseObservable被创建来实现监听器注册机制.数据实现类仍然可以负责当属性改变时通知.这是通过将一个android.databinding.Bindable注解分配给getter并在setter中通知来完成的。

private static class User extends BaseObservable {
   private String firstName;
   private String lastName;
   @Bindable
   public String getFirstName() {
       return this.firstName;
   }
   @Bindable
   public String getLastName() {
       return this.lastName;
   }
   public void setFirstName(String firstName) {
       this.firstName = firstName;
       notifyPropertyChanged(BR.firstName);
   }
   public void setLastName(String lastName) {
       this.lastName = lastName;
       notifyPropertyChanged(BR.lastName);
   }
}

android.databinding.Bindable注解是编译期间在BR类文件中生成一个条目。BR类文件将在模块包中生成。如果数据类的基类无法更改，则android.databinding.Observable接口可以使用方便的android.databinding.PropertyChangeRegistry实现，以有效地存储和通知监听器.

ObservableFields 观察者字段

创建android.databinding.Observable类需要做一点工作，因此想要节省时间或具有少量属性的开发人员可以使用android.databinding.ObservableField的兄弟姐妹，

android.databinding.ObservableBoolean,
android.databinding.ObservableByte, 
android.databinding.ObservableChar, 
android.databinding.ObservableShort,
android.databinding.ObservableInt, 
android.databinding.ObservableLong, 
android.databinding.ObservableFloat, 
android.databinding.ObservableDouble, 
android.databinding.ObservableParcelable.

ObservableFields是具有单个字段的独立可观察对象。原始版本在访问操作期间避免装箱和取消装箱。要使用，请在数据类中创建公共最终字段：

private static class User {
   public final ObservableField<String> firstName = new ObservableField<>();
   public final ObservableField<String> lastName = new ObservableField<>();
   public final ObservableInt age = new ObservableInt();
}

就是这样!要访问该值，请使用set和get访问器方法：

user.firstName.set("Google");
int age = user.age.get();

Observable Collections 观察者集合

一些应用程序使用更多动态结构来保存数据。观察者集合允许对这些数据对象通过键访问。android.databinding.ObservableArrayMap是有用的当key是一种引用类型,比如String.

ObservableArrayMap<String, Object> user = new ObservableArrayMap<>();
user.put("firstName", "Google");
user.put("lastName", "Inc.");
user.put("age", 17);

在布局中，可以通过String类型的键获取map的数据：

<data>
    <import type="android.databinding.ObservableMap"/>
    <variable name="user" type="ObservableMap&lt;String, Object&gt;"/>
</data>
…
<TextView
   android:text='@{user["lastName"]}'
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>
<TextView
   android:text='@{String.valueOf(1 + (Integer)user["age"])}'
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

当key是一个integer类型时使用android.databinding.ObservableArrayList更好:

ObservableArrayList<Object> user = new ObservableArrayList<>();
user.add("Google");
user.add("Inc.");
user.add(17);

在布局中,list可以通过索引获取数据:

<data>
    <import type="android.databinding.ObservableList"/>
    <import type="com.example.my.app.Fields"/>
    <variable name="user" type="ObservableList&lt;Object&gt;"/>
</data>
…
<TextView
   android:text='@{user[Fields.LAST_NAME]}'
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>
<TextView
   android:text='@{String.valueOf(1 + (Integer)user[Fields.AGE])}'
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

Generated Binding 生成绑定

生成的绑定类将布局变量与布局中的视图链接起来。如前所述，绑定的名称和包可能是自定义的。生成的绑定类全部集成android.databinding.ViewDataBinding。

Creating

应该在膨胀后立即创建绑定，以确保View层次结构在绑定到布局中带有表达式的视图之前不受干扰。有几种方法可以绑定到布局。最常见的是在Binding类上使用静态方法。膨胀方法膨胀了View层次结构并将其绑定到一步。有一个更简单的版本只需要一个LayoutInflater，另一个需要一个ViewGroup：

MyLayoutBinding binding = MyLayoutBinding.inflate(layoutInflater);
MyLayoutBinding binding = MyLayoutBinding.inflate(layoutInflater, viewGroup, false);

如果布局使用不同的机制进行充气，则可能需要单独绑定:

MyLayoutBinding binding = MyLayoutBinding.bind(viewRoot);

有时绑定不能预先知道。在这种情况下，可以使用android.databinding.DataBindingUtil类创建绑定：

ViewDataBinding binding = DataBindingUtil.inflate(LayoutInflater, layoutId,parent,attachToParent);
ViewDataBinding binding = DataBindingUtil.bindTo(viewRoot, layoutId);

Views With IDs

将在布局中为每个视图根据ID生成一个公开的最终字段。该绑定是视图结构上通过ID获取View的唯一的入口.这种机制可能比调用多个view的findViewById更快。例如：

<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}"
           android:id="@+id/firstName"/>
       <TextView 
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.lastName}"
           android:id="@+id/lastName"/>
   </LinearLayout>
</layout>

将会生成一个绑定类:

public final TextView firstName;
public final TextView lastName;

ID不像没有数据绑定那样必要，但仍然有一些情况下代码仍然需要访问视图。

Variables

每个变量将被赋予访问器方法。

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

将会在绑定类中生成setters和getters方法:

public abstract com.example.User getUser();
public abstract void setUser(com.example.User user);
public abstract Drawable getImage();
public abstract void setImage(Drawable image);
public abstract String getNote();
public abstract void setNote(String note);

ViewStubs

ViewStubs标签和普通的View稍有不同.他们从不可见的时候开始，当他们要么变得可见时，要么被明确告知膨胀时，他们通过膨胀另一种布局来取代布局。因为视图是最终的，所以android.databinding.ViewStubProxy对象取代了ViewStub，使开发人员能够在ViewStub存在时访问ViewStub，并且在ViewStub被充满时也可以访问充满的View层次结构。
当膨胀另一个布局时，必须为新布局建立绑定。因此，ViewStubProxy必须侦听ViewStub的ViewStub.OnInflateListener并在此时建立绑定。由于只有一个可以存在，因此ViewStubProxy允许开发人员在建立绑定后设置一个OnInflateListener，它将调用它。

Advanced Binding 高级绑定

Dynamic Variables 动态变量

有时，特定的绑定类将不被知道。例如，针对任意布局的RecyclerView.Adapter不会知道特定的绑定类。它必须在onBindViewHolder（VH，int）期间分配绑定值。
在这个例子中，RecyclerView绑定到的所有布局都有一个“item”变量。 BindingHolder有一个返回android.databinding.ViewDataBinding库的getBinding方法。

public void onBindViewHolder(BindingHolder holder, int position) {
   final T item = mItems.get(position);
   holder.getBinding().setVariable(BR.item, item);
   holder.getBinding().executePendingBindings();
}

Immediate Binding 即使绑定

当变量或观察者变化时，绑定将被安排在下一帧之前改变,然而，有时候，绑定必须立即执行.要强制执行，请使用android.databinding.ViewDataBinding.executePendingBindings（）方法。

Background Thread

只要不是集合，您可以在子线程中更改数据模型。数据绑定将在编译时实例化每个变量/字段以避免任何并发问题

Attribute Setters

对于一个属性，数据绑定试图找到方法setAttribute。属性的命名空间并不重要，只有属性名称本身。
例如，与 TextView 的属性 android：text 相关联的表达式将查找 setText（String） 。如果表达式返回一个int，则数据绑定将搜索setText（int）方法。请注意让表达式返回正确的类型，如果需要的话可以强转。请注意，即使给定名称不存在任何属性，数据绑定也会起作用。然后，您可以使用数据绑定轻松地为任何setter创建属性。例如，支持DrawerLayout没有任何属性，但有很多setter。您可以使用自动设置器来使用其中之一。

<android.support.v4.widget.DrawerLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:scrimColor="@{@color/scrim}"
    app:drawerListener="@{fragment.drawerListener}"/>

Renamed Setters 重命名Setter方法

一些属性具有不匹配名称的setter。对于这些方法，可以通过 android.databinding.BindingMethods注解将一个属性与setter相关联。这必须与一个类相关联，并且包含android.databinding.BindingMethod注解，每个重命名的方法一个注释。例如，android：tint属性确实与setImageTintList（ColorStateList）关联，而不是setTint。

@BindingMethods({
       @BindingMethod(type = "android.widget.ImageView",
                      attribute = "android:tint",
                      method = "setImageTintList"),
})

开发人员不太可能需要重命名setter; android框架属性已经实现

Custom Setters

一些属性需要自定义绑定逻辑。例如，android：paddingLeft属性没有关联的setter。但是，setPadding（左，上，右，下）存在。具有android.databinding.BindingAdapter注解的静态绑定适配器方法允许开发人员定制如何调用属性的setter。
android属性已经创建了BindingAdapter。例如，下面是paddingLeft的一个例子：

@BindingAdapter("android:paddingLeft")
public static void setPaddingLeft(View view, int padding) {
   view.setPadding(padding,
                   view.getPaddingTop(),
                   view.getPaddingRight(),
                   view.getPaddingBottom());
}

绑定适配器对其他类型的自定义很有用。例如，一个自定义的加载器可以在子线程调用来加载一个图片。发生冲突时，开发人员创建的绑定适配器将覆盖数据绑定默认适配器。
您也可以让适配器接收多个参数。

@BindingAdapter({"bind:imageUrl", "bind:error"})
public static void loadImage(ImageView view, String url, Drawable error) {
   Picasso.with(view.getContext()).load(url).error(error).into(view);
}

<ImageView 
    app:imageUrl="@{venue.imageUrl}"
    app:error="@{@drawable/venueError}"/>

如果imageUrl和error都用于ImageView并且imageUrl是String类型的，并且error是drawable类型的的，则将调用此适配器。

自定义名称空间在匹配过程中被忽略。
您也可以为android命名空间编写适配器。

绑定适配器方法可以选择在其处理程序中使用旧值。采用旧的和新的值的方法应该是先使所有属性设置旧值，其次是新值：

@BindingAdapter("android:paddingLeft")
public static void setPaddingLeft(View view, int oldPadding, int newPadding) {
   if (oldPadding != newPadding) {
       view.setPadding(newPadding,
                       view.getPaddingTop(),
                       view.getPaddingRight(),
                       view.getPaddingBottom());
   }
}

事件处理程序只能用于一个抽象方法的接口或抽象类。例如：

@BindingAdapter("android:onLayoutChange")
public static void setOnLayoutChangeListener(View view, View.OnLayoutChangeListener oldValue,View.OnLayoutChangeListener newValue) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        if (oldValue != null) {
            view.removeOnLayoutChangeListener(oldValue);
        }
        if (newValue != null) {
            view.addOnLayoutChangeListener(newValue);
        }
    }
}

当一个监听器有多个方法时，它必须被拆分成多个监听器。例如，View.OnAttachStateChangeListener有两个方法：onViewAttachedToWindow（）和onViewDetachedFromWindow（）。然后，我们必须创建两个接口来区分它们的属性和处理程序。

@TargetApi(VERSION_CODES.HONEYCOMB_MR1)
public interface OnViewDetachedFromWindow {
    void onViewDetachedFromWindow(View v);
}

@TargetApi(VERSION_CODES.HONEYCOMB_MR1)
public interface OnViewAttachedToWindow {
    void onViewAttachedToWindow(View v);
}

因为更改一个侦听器也会影响另一个侦听器，所以我们必须有三个不同的绑定适配器，一个用于每个属性，另一个用于两者，如果它们都被设置。

@BindingAdapter("android:onViewAttachedToWindow")
public static void setListener(View view, OnViewAttachedToWindow attached) {
    setListener(view, null, attached);
}

@BindingAdapter("android:onViewDetachedFromWindow")
public static void setListener(View view, OnViewDetachedFromWindow detached) {
    setListener(view, detached, null);
}

@BindingAdapter({"android:onViewDetachedFromWindow", "android:onViewAttachedToWindow"})
public static void setListener(View view, final OnViewDetachedFromWindow detach,
        final OnViewAttachedToWindow attach) {
    if (VERSION.SDK_INT >= VERSION_CODES.HONEYCOMB_MR1) {
        final OnAttachStateChangeListener newListener;
        if (detach == null && attach == null) {
            newListener = null;
        } else {
            newListener = new OnAttachStateChangeListener() {
                @Override
                public void onViewAttachedToWindow(View v) {
                    if (attach != null) {
                        attach.onViewAttachedToWindow(v);
                    }
                }

                @Override
                public void onViewDetachedFromWindow(View v) {
                    if (detach != null) {
                        detach.onViewDetachedFromWindow(v);
                    }
                }
            };
        }
        final OnAttachStateChangeListener oldListener = ListenerUtil.trackListener(view,
                newListener, R.id.onAttachStateChangeListener);
        if (oldListener != null) {
            view.removeOnAttachStateChangeListener(oldListener);
        }
        if (newListener != null) {
            view.addOnAttachStateChangeListener(newListener);
        }
    }
}

上面的例子比普通的稍微复杂一些，因为View使用add和remove来代替View.OnAttachStateChangeListener的set方法。android.databinding.adapters.ListenerUtil类有助于跟踪以前的侦听器，以便它们可以在Binding Adaper中删除。
通过在接口OnViewDetachedFromWindow和OnViewAttachedToWindow中添加@TargetApi(VERSION_CODES.HONEYCOMB_MR1)注解,数据绑定代码生成器知道只能在API11及以上版本使用，该版本支持[addOnAttachStateChangeListener(View.OnAttachStateChangeListener)

Converters 转换器

Object Conversions 对象转换

从绑定表达式返回对象时，将从自动，重命名和自定义设置器中选择一个setter。该对象将被转换为所选setter的参数类型。
这对于那些使用ObservableMaps来保存数据的人来说很方便。例如：

<TextView
   android:text='@{userMap["lastName"]}'
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

userMap返回一个Object，并且该Object将自动转换为在settersetText（CharSequence）中找到的参数类型。当可能对参数类型产生混淆时，开发人员需要在表达式中进行转换。

Custom Conversions

有时转换应该在特定类型之间自动进行。例如，在设置背景时：

<View
   android:background="@{isError ? @color/red : @color/white}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

在这里，背景需要一个Drawable，但颜色是一个整数.每当需要一个Drawable并返回一个整数时，int应该转换为ColorDrawable。这种转换是使用带有BindingConversion注释的静态方法完成的：

@BindingConversion
public static ColorDrawable convertColorToDrawable(int color) {
   return new ColorDrawable(color);
}

请注意，转换只发生在setter级别，因此不允许混合类型如下所示：

<View
   android:background="@{isError ? @drawable/error : @color/white}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

Android Studio Support for Data Binding

Android Studio支持许多用于数据绑定代码的代码编辑功能。例如，它支持数据绑定表达式的以下功能：

语法高亮显示
表达语言语法错误的标记
XML代码补全
参考资料，包括导航（如导航到声明）和快速文档

注意：数组和一个泛型类型（如android.databinding.Observable类）可能在没有错误的时候提示错误。
预览窗格显示数据绑定表达式的默认值（如果提供）。在以下示例摘录布局XML文件中的元素时，“预览”窗格在TextView中显示PLACEHOLDER默认文本值。

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

如果需要在项目的设计阶段显示默认值，则还可以使用工具属性而不是默认表达式值，如Design Time Layout Attributes中所述。

最后推荐两篇DataBinding使用的博客

从零开始的Android新项目7 - Data Binding入门篇

从零开始的Android新项目8 - Data Binding高级篇

https://blog.csdn.net/qiang_xi/article/category/6995820

https://blog.csdn.net/qiang_xi/article/details/75379321