Android进阶四：Databinding的使用(基础篇)_android 三元运算符-优快云博客

本文详细介绍了Android Databinding的配置、基本使用和高级特性，包括事件绑定、变量传递、静态方法、Null Coalescing运算符等。通过数据绑定，可以减少UI代码，提高开发效率，并实现数据与UI的自动刷新。同时，文章还讨论了其优缺点和使用场景。

Data Binding是2015年Google I/O大会上提出的，从Beta版至今，Data Binding已经是一个可用度较高，也能带来实际生产力提升的技术。

Data Binding顾名思义就是数据绑定，是Google对MVVM在Android上的一种实现，可以直接绑定数据到xml上，并实现自动刷新，现在最新的版本还支持双向绑定。

Data Binding的优点：

1、去掉Activities & Fragments内的大部分UI代码（setOnClickListener, setText, findViewById, etc.)

2、 UI代码放到了xml中，布局和数据更紧密

3、提升开发效率，性能高（甚至超越手写代码）

4、功能强大

Data Binding的缺点：

1、 IDE支持还不那么完善（提示、表达式）

2、报错信息不那么直接

3、重构支持不好（xml中进行重构，java代码不会自动修改）

一.配置环境：

1、使用Databinding兼容包，可以兼容到Android 2.1（API level 7+）版本，Gradle插件需要使用1.5.0-alpha1及以上版本，

2、需要使用Andorid Studio 1.3及以上IDE.

3、然后需要在项目的app主模块对应build.gradle文件中配置：

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

假如你app主模块已经依赖了一个使用databinding功能的模块，也需要做以上配置

二.基本使用

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 进行绑定。

如果要用一个表格来展示用户的基本信息，用 Data Binding 应该怎么实现呢？

2.数据对象

添加一个POJO 类 - User，非常简单，四个属性以及他们的 getter 和 setter 。

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>

其中 type 属性就是我们在 Java 文件中定义的 User 类。
当然，data 节点也支持 import ，所以上面的代码可以换一种形式来写。

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

如果两个类名都是User，可以使用alias 属性：

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

然后Data Binding插件会根据xml文件的名称 Generate 一个继承自 ViewDataBinding 的类。
例如，这里 xml 的文件名叫 activity_basic.xml，那么生成的类就是 ActivityBasicBinding。

我们也可以自定义名称，只需要：

<data class=“ContactItem”>
…
</data>

这样生成的类就不是 ActivityBasicBinding，而会变成ContactItem。

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

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

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

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

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

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

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

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

这里获取ActivityBasicBinding类的实例，用于与user进行数据绑定，获取ActivityBasicBinding实例还可以使用：

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

假如ListView和RecyclerView需要使用Data Binding，可以用以下方法获取binding实例：

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

5.使用 Variable

数据与 Variable 绑定之后，xml 的 UI 元素就可以直接使用了，注意需要使用“@{}”语法。

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

至此，一个简单的数据绑定就完成了，可参考完整代码

三.高级使用

1.事件绑定

我们可以在xml中直接绑定下面属性的值，称为事件绑定：
android:onClick
android:onLongClick
android:onTextChanged
…

事件绑定分方法引用和监听器绑定

(1)、方法引用
通常会在java代码中定义一个名为Handler或者Presenter的类，然后set进来，方法签名需和对应listener方法一致，即方法的传参必须一样。

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
    binding.setPresenter(new Presenter());
    ...
}

public class Presenter {
    public void onTextChanged(CharSequence s, int start, int before, int count) {
        employee.setFirstName(s.toString());
        employee.setFired(!employee.isFired.get());
    }

    public void onClick(View view) {
        Toast.makeText(DemoActivity.this, "点到了", Toast.LENGTH_SHORT).show();
    }
}

在xml中：

<layout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:bind="http://schemas.android.com/apk/res-auto">
    <data>
        <import type="android.view.View"/>
        <variable
            name="employee"
            type="com.github.markzhai.databindingsample.Employee"/>
        <variable
            name="presenter"
            type="com.github.markzhai.databindingsample.DemoActivity.Presenter"/>
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center_horizontal"
        android:orientation="vertical"
        tools:context=".DemoActivity">
        <EditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="输入 First Name"
            android:onTextChanged="@{presenter::onTextChanged}"/>
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:onClick="@{presenter.onClick}"/>
    </LinearLayout>
</layout>

注意这里使用presenter.onClick或者presenter::onClick都可以

(2)、监听器绑定

监听器绑定就相当于直接在xml写方法体，只不过方法体只有调用一个方法，使用lambda表达式：

public class Presenter {
    public void onClickListenerBinding(Employee employee) {
        Toast.makeText(DemoActivity.this, employee.getLastName(),
                Toast.LENGTH_SHORT).show();
    }
}

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_margin="5dp"
    android:visibility="@{employee.isFired ? View.GONE : View.VISIBLE}"
    android:onClick="@{() -> presenter.onClickListenerBinding(employee)}"/>

或者可以写为：

android:onClick="@{(view) -> presenter.onClickListenerBinding(employee)}

如果要使用view参数，可以写为：

android:onClick="@{(theview) -> presenter.onClickListenerBinding(theview,employee)}

加入你想使用三元表达式，注意返回类型需要一致，这里是onClick(view)的返回类型为void：

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

2.变量传递Includes

variable节点定义个变量，可以在xml之间传递，
主布局：

<?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/sub_layout"
           bind:user="@{user}"/>
   </LinearLayout>
</layout>

子布局sub_layout.xml：

<?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}"/>
    </LinearLayout>
</layout>

或者：

<?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>
    <merge
        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}"/>
    </merge>
</layout>

注意：
这里如果主布局使用了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/sub_layout"
           bind:user="@{user}"/>
   </merge>
</layout>

3.使用类方法（静态方法）

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

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.example.StringUtils" />

使用方法与 Java 语法一样：

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

4.Null Coalescing 运算符

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

就等价于：

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

5.属性值

通过 ${} 可以直接把 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}"/>

6.使用资源数据

如使用dimen.xml里面的资源

<TextView
    android:padding="@{large? (int)@dimen/largePadding : (int)@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" />

使用colors.xml中的资源：

   android:textColor = "@{@color/scrim}"

两个dimen相加：

android:marginLeft="@{@dimen/margin + @dimen/avatar_size}"

使用strings.xml中的资源：

<string name="app_name">Databinding</string>

android:text= "@{@string/app_name}"

组合string：

 <string name="stringmerge">%1$s,%2$s</string>

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

使用plurals：

android:text="@{@plurals/banana(bananaCount)}"

plurals的使用可以参考：
http://blog.youkuaiyun.com/qjyasly/article/details/18309677

Type	Normal Reference	Expression Reference
String[]	@array	@stringArray
int[]	@array	@intArray
TypedArray	@array	@typedArray
Animator	@animator	@animator
StateListAnimator	@animator	@stateListAnimator
color int	@color	@color
ColorStateList	@color	@colorStateList

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，那么它对应的变量就是：

public final TextView firstName;

可以直接在activity中使用它：

firstName.setText();

8.避免空指针

data binding会自动帮助我们进行空指针的避免，比如说@{employee.firstName}，如果employee是null的话，employee.firstName则会被赋默认值（null）。int的话，则是0。

需要注意的是数组的越界，毕竟这儿是xml而不是java，没地方让你去判断size的。

9.ViewStubs

ViewStub比较特殊，在被实际inflate前是不可见的，所以使用了特殊的方案，用了final的ViewStubProxy来代表它，并监听了ViewStub.OnInflateListener:

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

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

10.转换器(Converters)

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

<Button
    android:onClick="toggleIsError"
    android:text="@{isError ? @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;
}

11.集合（Collections）

<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]}"

12.Attribute setters

有了 Data Binding，即使属性没有在 declare-styleable 中定义，我们也可以通过 xml 进行赋值操作。为了演示这个功能，我自定义了一个 View - UserView，其中 R.styleable.UserView 中只定义了一个 age 属性，其中 firstName 和 lastName 只有对应的两个 setter 方法。
（https://github.com/LyndonChin/MasteringAndroidDataBinding/blob/master/app/src/main/res/values/styles.xml）
只要有 setter 方法就可以这样为属性赋值：

<com.liangfeizc.databindingsamples.attributesetters.UserView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:paddingLeft="@dimen/largePadding"
    app:onClickListener="@{activity.clickListener}"
    app:firstName="@{@string/firstName}"
    app:lastName="@{@string/lastName}"
    app:age="27" />

onClickListener 也是同样道理，只不过我们是在 Activity 中定义了一个 Listener。

13.表达式

1、算术 + - / * %
2、字符串合并 +
3、逻辑 && ||
4、二元 & | ^
5、一元 + - ! ~
6、移位 >> >>> <<
7、比较 == > < >= <=
8、Instanceof
9、Grouping ()
10、文字 - character, String, numeric, null
11、Cast
12、方法调用
13、Field 访问
14、Array 访问 []
15、三元 ?:

比如：

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

14.动态变量

以 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);

15.Observable

一个纯净的Java ViewModel类被更新后，并不会让UI去更新。而数据绑定后，我们当然会希望数据变更后UI会即时刷新，Observable就是为此而生的概念。
要实现 Observable Binding，首先得有一个实现了 android.databinding.Observable 的类，为了方便，Android 原生提供了已经封装好的一个类 - BaseObservable，并且实现了监听器的注册机制。
我们可以直接继承 BaseObservable。

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

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

通过代码可以看出，当数据发生变化时还是需要手动发出通知。通过调用notifyPropertyChanged(BR.firstName)来通知系统 BR.firstName 这个 entry 的数据已经发生变化，需要更新 UI。

(1)、Observable Fields：

如果所有要绑定的都需要创建Observable类，那也太麻烦了。所以Data Binding还提供了一系列Observable，包括 ObservableBoolean, ObservableByte, ObservableChar, ObservableShort, ObservableInt, ObservableLong, ObservableFloat, ObservableDouble, 和ObservableParcelable。我们还能通过ObservableField泛型来申明其他类型，如：

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

而在xml中，使用方法和普通的String，int一样，只是会自动刷新，但在java中访问则会相对麻烦：

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

相对来说，每次要get/set还是挺麻烦，私以为还不如直接去继承BaseObservable。

(2)、Observable Collections：

有一些应用使用更动态的结构来保存数据，这时候我们会希望使用Map来存储数据结构。Observable提供了ObservableArrayMap:

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

而在xml中，我们可以直接通过下标key访问它们：

<data>
    <import type="android.databinding.ObservableMap"/>
    <variable name="user" type="ObservableMap&lt;String, Object>"/>
</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的时候，可以使用ObservableArrayList:

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

layout中直接通过数字下标进行访问。

16.开发时预览

在android studio布局编辑界面，可以用default关键字设置设置TextView的预览，如下：

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

这时候在android studio右侧的Preview界面就可以看到TextView上显示”PLACEHOLDER”: