DataBinding 学习

目录

一、环境搭建

---

1. Android 的 Gradle 插件版本不低于 1.5.0-alpha1：

classpath 'com.android.tools.build:gradle:1.5.0'

2. 修改对应模块（app）的 build.grade：

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

二、基本使用

---

1. 布局文件

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

<layout xmlns:android="http://schemas.android.com/apk/res/android">  
    <data>  
    </data>  
    <!--原先的根节点（Root Element）-->  
    <LinearLayout>  
    ....  
    </LinearLayout>  
</layout>  

要实现 MVVM 的 ViewModel 就需要把数据与UI进行绑定，data 节点就为此提供了一个桥梁，我们先在 data 中声明一个 variable，这个变量会为 UI 元素提供数据（例如 TextView 的 android:text），然后在 Java 代码中把”后台”数据与这个 variable 进行绑定。

2. 数据对象

添加一个 POJO 类 - User

public class User {
    private final String firstName;
    private final String lastName;
    private String displayName;
    private int age;

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

    public User(String firstName, String lastName, int age) {
        this(firstName, lastName);
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public String getDisplayName() {
        return firstName + " " + lastName;
    }

    public boolean isAdult() {
        return age >= 18;
    }
}

稍后，我们会新建一个 User 类型的变量，然后把它跟布局文件中声明的变量进行绑定。

3. 定义 Variable

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

<data>
    <variable name="user" type="com.liangfeizc.databindingsamples.basic.User" />
</data>

data 节点也支持 import，所以上面的代码可以换一种形式来写。

<data>
    <import type="com.liangfeizc.databindingsamples.basic.User" />
    <variable name="user" type="User" />
</data>

其中 type 属性就是我们在 Java 文件中定义的 User 类。name 属性的值只能包含大小写字母，有下划线会报错
在data中可以使用任意数量的variable元素。每一个variable元素描述了一个用于layout文件中Binding表达式的属性
该Variable类型在编译时检查，因此如果一个Variable实现了Observable或observable collection，这应该反映在类型中。（译注：需要查找资料来理解）如果variable是一个没有实现Observable接口的基本类或者接口，Variables不会被observed！

注意

java.lang.* 包中的类会被自动导入，可以直接使用，例如要定义一个 String 类型的变量：

<variable name="firstName" type="String" />

4. 自定义Binding类名称

然后我们刚才在 build.gradle 中添加的那个插件 ==com.android.databinding== 会根据xml文件的名称 Generate 一个继承自 ViewDataBinding 的类。

例如，这里 xml 的文件名叫 ==activity_basic.xml==，那么生成的类就是 ==ActivityBasicBinding==。

Binding类可通过调整data元素中的class属性来重命名或放置在不同的包中。例如：

修改生成的类名（需要编译一次才能生成）

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

直接在模块包中生成

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

或者提供整个包名

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

5. 绑定 Variable

修改 BasicActivity 的 onCreate 方法，用 DatabindingUtil.setContentView()来替换掉 setContentView()，然后创建一个 user 对象，通过 binding.setUser(user) 与 variable 进行绑定。

此处获取布局的方式还有
ActivityBasicBinding binding = ActivityBasicBinding.inflate(getLayoutInflater())

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ActivityBasicBinding binding = DataBindingUtil.setContentView(
            this, R.layout.activity_basic);
    User user = new User("fei", "Liang");
    binding.setUser(user);
    //等价于
    //binding.setVariable(BR.user,user);
}

注意

ActivityBasicBinding 类是自动生成的，所有的 set 方法也是根据 variable 名称生成的。例如，我们定义了两个变量。

<data>
    <variable name="firstName" type="String" />
    <variable name="lastName" type="String" />
</data>

那么就会生成对应的两个 set 方法。

setFirstName(String firstName);
setLastName(String lastName);

6. 使用 Variable

数据与 Variable 绑定之后，xml 的 UI 元素就可以直接使用了。

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

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

三、高级用法

---

1. 使用类方法

首先为类添加一个静态方法

public class MyStringUtils {
    public static String capitalize(final String word) {
        if (word.length() > 1) {
            return String.valueOf(word.charAt(0)).toUpperCase() + word.substring(1);
        }
        return word;
    }
}

然后在 xml 的 data 节点中导入：

<import type="com.liangfeizc.databindingsamples.utils.MyStringUtils" />

使用方法与 Java 语法一样：

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

2. 类型别名

如果我们在 data 节点了导入了两个同名的类怎么办？

<import type="com.example.home.data.User" />
<import type="com.examle.detail.data.User" />
<variable name="user" type="User" />

这样一来出现了两个 User 类，那 user 变量要用哪一个呢？不用担心，import 还有一个 alias 属性。

<import type="com.example.home.data.User" />
<import type="com.examle.detail.data.User" alias="DetailUser" />
<variable name="user" type="DetailUser" />

3. Null Coalescing 运算符 (空合并运算符)

?? - 左边的对象如果它不是null，选择左边的对象；或者如果它是null，选择右边的对象：

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

就等价于

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

4. 属性值

通过 ${} 可以直接把 Java 中定义的属性值赋值给 xml 属性。

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

5. 使用资源数据

<TextView
    android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"
    android:background="@android:color/black"
    android:textColor="@android:color/white"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_world" />

6. Observable Binding

要实现 Observable Binding，首先得有一个实现了 android.databinding.Observable 的类，为了方便，Android 原生提供了已经封装好的一个类 - ==BaseObservable==，并且实现了监听器的注册机制。

有3种方式实现动态更新界面数据：

• [ ] 实现 Observable 接口；
• [ ] 继承 BaseObservable；
• [ ] 使用 ObservableField；

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

@Bindable 方法修饰的get()方法还有另一种写法

public @Bindable String firstName;

必须是public修饰

BR 是编译阶段生成的一个类，功能与 R.java 类似，用 @Bindable 标记过 getter 方法会在 BR 中生成一个 entry

通过代码可以看出，当数据发生变化时还是需要手动发出通知。 通过调用

notifyPropertyChanged(BR.firstName)

来通知系统 BR.firstName 这个 entry 的数据已经发生变化，需要更新 UI。

notify函数函数，包括notifyChange和notifyPropertyChanged，前者会刷新所有的变量值，后者则只更新对应BR的flag

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

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

系统为我们提供了所有的 primitive type 所对应的 Observable类，例如 ObservableInt、ObservableFloat、ObservableBoolean 等等，还有一个 ObservableField 对应着 reference type。

剩下的数据绑定与前面介绍的方式一样，具体可参考 ObservableActivity

数据类型对应关系：

Observable类型	对应原类型
ObservableArrayList	ArrayList
ObservableArrayMap	ArrayMap
ObservableBoolean	boolean
ObservableByte	byte
ObservableChar	char
ObservableFloat	float
ObservableDouble	double
ObservableLong	long
ObservableInt	int
ObservableParcelable
ObservableField

7. 带 ID 的 View

Data Binding 有效降低了代码的冗余性，甚至完全没有必要再去获取一个 View 实例，但是情况不是绝对的，万一我们真的就需要了呢？不用担心，只要给 View 定义一个 ID，Data Binding 就会为我们生成一个对应的 final 变量。

<TextView
    android:id="@+id/firstName"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

上面代码中定义了一个 ID 为 firstName 的 TextView，那么BR中对应的变量就是

public final TextView firstName;

调用方式为：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ActivityViewWithIdsBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_view_with_ids);
    binding.firstName.setText("firstName");
}

具体代码可参考 ==ViewWithIDsActivity.java==

8. ViewStubs

xml中的 ViewStub 经过 binding 之后会转换成 ViewStubProxy, 具体代码可参考 ViewStubActivity.java

xml 文件与之前的代码一样，根节点改为 layout，在 LinearLayout 中添加一个 ViewStub，添加 ID。

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <LinearLayout
        ...>
        <ViewStub
            android:id="@+id/view_stub"
            android:layout="@layout/view_stub"
            ... />
    </LinearLayout>
</layout>

在 Java 代码中获取 binding 实例，为 ViewStubProy 注册 ViewStub.OnInflateListener 事件

binding = DataBindingUtil.setContentView(this, R.layout.activity_view_stub);
binding.viewStub.setOnInflateListener(new ViewStub.OnInflateListener() {
    @Override
    public void onInflate(ViewStub stub, View inflated) {
        ViewStubBinding binding = DataBindingUtil.bind(inflated);
        User user = new User("fee", "lang");
        binding.setUser(user);
    }
});

9. Dynamic Variables

以 RecyclerView 为例，Adapter 的 DataBinding 需要动态生成，因此我们可以在 onCreateViewHolder 的时候创建这个 DataBinding，然后在 onBindViewHolder 中获取这个 DataBinding。

public static class BindingHolder extends RecyclerView.ViewHolder {
    private ViewDataBinding binding;
    public BindingHolder(View itemView) {
        super(itemView);
    }
    public ViewDataBinding getBinding() {
        return binding;
    }
    public void setBinding(ViewDataBinding binding) {
        this.binding = binding;
    }
}
@Override
public BindingHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
    ViewDataBinding binding = DataBindingUtil.inflate(
            LayoutInflater.from(viewGroup.getContext()),
            R.layout.list_item,
            viewGroup,
            false);
    BindingHolder holder = new BindingHolder(binding.getRoot());
    holder.setBinding(binding);
    return holder;
}
@Override
public void onBindViewHolder(BindingHolder holder, int position) {
    User user = users.get(position);
    holder.getBinding().setVariable(BR.user, user);
    holder.getBinding().executePendingBindings();
}

注意此处 DataBindingUtil 的用法：

ViewDataBinding binding = DataBindingUtil.inflate(
    LayoutInflater.from(viewGroup.getContext()),
    R.layout.list_item,
    viewGroup,
    false);

10. Attribute setters

通过xml中variable声明的name属性，传递到组件中，组件自动去寻找符合@BindingAdapter({“XXX”}) 修饰的方法，方法必须是 public static void 类型，并把值传递进去，方法的参数1必须为view，完全匹配后此方法会自动被调用

<ImageView
    android:layout_width="100dp"
    android:layout_height="100dp"
    android:onClick="toggleIsError"
    bind:imageUrl="@{urlStr}"
    bind:context="@{mainActivity.context}"/>

bind:imageUrl也可以改成app:imageUrl

    @BindingAdapter({"imageUrl", "context"})
    public static void loadImageUrl(ImageView view, String url, Context context) {
        Glide.with(context)
                .load(url)
                .into(view);
    }

11. 转换器 (Converters)

具体代码可参考 ConversionsActivity.java

在 xml 中为属性赋值时，如果变量的类型与属性不一致，通过 DataBinding 可以进行转换。

<Button
    android:onClick="toggleIsError"
    android:text="@{isError.get() ? @color/red : @color/white}"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

只需要定义一个标记了 @BindingConversion 的静态方法即可：

@BindingConversion
public static int convertColorToString(int color) {
    switch (color) {
        case Color.RED:
            return R.string.red;
        case Color.WHITE:
            return R.string.white;
    }
    return R.string.app_name;
}

不可以多类型混合使用，转换只能转一种类型

12. 变量定义的高级用法

<layout xmlns:android="http://schemas.android.com/apk/res/android"> 
        <data> 
            <import type="android.graphics.Bitmap" /> 
            <import type="java.util.ArrayList" /> 
            <import type="java.util.HashMap" />  
          <!-- 集合的定义 -->
            <variable 
                name="list" 
                type="ArrayList<String>" /> 
            <variable 
                name="map" 
                type="HashMap<String, String>" /> 
            <variable 
                name="array" 
                type="String[]" /> 
          <!-- 为集合定义对应的索引 -->
            <variable 
                name="listKey" 
                type="int" /> 
            <variable 
                name="mapKey" 
                type="String" /> 
            <variable 
                name="arrayKey" 
                type="int" /> 

            <!-- 字符串，布尔值和int的用法-->
            <variable 
                name="str" 
                type="String"/> 
            <variable 
                name="error" 
                type="boolean"/> 
            <variable 
                name="num" 
                type="int" /> 

        </data> 

        <LinearLayout 
            android:orientation="vertical" 
            android:layout_width="match_parent" 
            android:layout_height="wrap_content"> 

            <TextView 
                android:layout_width="wrap_content" 
                android:layout_height="wrap_content" 
                android:text="@{list[listKey]}"/> 

            <TextView 
                android:layout_width="wrap_content" 
                android:layout_height="wrap_content" 
                android:text="@{map[`name`]}"/>
            <TextView 
                android:layout_width="wrap_content" 
                android:layout_height="wrap_content" 
                android:text="@{array[0]}"/> 

            <TextView 
                android:layout_width="wrap_content" 
                android:layout_height="wrap_content" 
                android:text="@{str}"/> 
            <TextView 
                android:layout_width="wrap_content" 
                android:layout_height="wrap_content" 
                android:text="@{String.valueOf(num)}"/> 
        </LinearLayout> 
    </layout>

其中的

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

等价于

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

转义：
“<” 替换成 “<”
“&” 替换成 “&”
“>” 替换成 “>”
“’” 替换成 “"”

13. include用法

通过使用application namespace以及在属性中的Variable名字从容器layout中传递Variables到一个被包含的layout：

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

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

注意：在主xml和include的两个layout文件中必需要有相同的user variable 才能进行正常的对象传递 bind:user=”@{user}” bind后面跟的名称跟variable的name要相同

流程：首先从activity代码中将user对象传递给主xml，主xml中将对象用bind:user=”@{user}”传递到具体的include的xml中，include xml中声明好相同的variable，即user，即可正常使用

当include的父节点为merge时将不支持

14. 方法事件绑定

普通方法的绑定，直接在布局文件中，通过变量名调用方法即可，和java代码里面使用相似

<!--类方法的绑定-->
<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@{user.getFullName(user.firstName, user.lastName)}"/> 
<!--调用User类里面的获取全名的方法-->

事件绑定
类似于 android:onClick 可以指定 Activity 中的函数，Data Binding 也允许处理从视图中发送的事件。有两种实现方式 ：
方法调用和监听绑定
二者主要区别在于方法调用在编译时处理，而监听绑定于事件发生时处理。

方法调用

方法的参数 showToast 必须与监听器对象的参数 onClick 相匹配。==handler为上面声明的变量名称==，showToast为监听方法,返回值也需要相同

<!--事件绑定-->
<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="ShowToast"
    android:onClick="@{handler::showToast}"/>

public void showToast(View v) {
    System.out.println("点击了");  
}

监听绑定

需要注意的是：此功能在 Android Gradle Plugin version 2.0 或更新版本上可用，支持lambda表达式
返回值需要与监听器对象的预期返回值相匹配 但是参数可以和onClick()不相同

() -> handler.showToast(task)
等价于
(v) -> handler.showToast(task)
区别在于你需不需要用系统监听方法(此处为onClick)里面的参数

<!-- 监听绑定 使用lambda表达式 -->
<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="runTask"
    android:onClick="@{() -> handler.showToast(task)}"/>

public void showToast(Task t) {
    System.out.println("点击了");  
}    

15. 技巧

当使用数据绑定的时候在预览界面不能看到显示的内容，这时你可以为你的控件设置默认显示内容

android:text="@{placeName,default=默认显示的内容}"

代码参考

---

参考资料:

完全掌握Android Data Binding
Android数据绑定框架DataBinding，堪称解决界面逻辑的黑科技
DataBinding实现原理探析
Android Data Binding（数据绑定）用户指南
DataBinding 的常见错误