Data Binding

最新推荐文章于 2023-03-11 15:08:51 发布

wxx614817

最新推荐文章于 2023-03-11 15:08:51 发布

阅读量801

点赞数

分类专栏：开源项目文章标签： Android Data Binding

开源项目专栏收录该内容

46 篇文章 1 订阅

订阅专栏

转：

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

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

Data Binding Component详解 - 换肤什么的只是它的一个小应用！

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

引

Data Binding自从去年的Google I/O发布到至今，也有近一年的时间了。这一年来，从Beta到如今比较完善的版本，从Android Studio 1.3到如今2.1.2的支持，可以说Data Binding已经是一个可用度较高，也能带来实际生产力提升的技术了。

然而事实上，真正使用到Data Binding的公司、项目仍然是比较少的。可能是出于稳定性考虑，亦或是对Data Binding技术本身不够熟悉，又或许对新技术没什么追求。

我司在新的产品中就全面使用了Data Binding技术，无论是我，还是新来直接面对Data Binding上手的工程师也好，都对其爱不释手，用惯了后简直停不下来。

希望在看完本文的介绍后，会有更多的朋友产生兴趣，来使用Data Binding，参与它的讨论。

Demo源码库：DataBindingSample

什么是Data Binding

Data Binding，顾名思义，数据绑定，是Google对MVVM在Android上的一种实现，可以直接绑定数据到xml中，并实现自动刷新。现在最新的版本还支持双向绑定，尽管使用场景不是那么多。

Data Binding可以提升开发效率（节省很多以往需要手写的java代码），性能高（甚至超越手写代码），功能强（强大的表达式支持）。

用途

去掉Activities & Fragments内的大部分UI代码（setOnClickListener, setText, findViewById, etc.)
XML变成UI的唯一真实来源
减少定义view id的主要用途（数据绑定直接发生在xml）

开源方案

ButterKnife, Jake大神的知名库了，可以少些很多findViewById，setOnClickListener，取而代之地用annotation去生成代码。
Android Annotations，同样通过annotation，大量的annotation，侵入性较强，需要遵循其规范写一些代码，像是@AfterViews注释中才能对View进行操作。
RoboBinding，和Data Binding最相似的一个方案，同样很多事情放在xml去做了，使用了aspectJ去做生成。

除了这些比较有名的，还有很多各不相同的方案，但自从data binding发布后，可以说它们都再也没有用武之地了，因为无论从性能、功能，还是ide的支持上，data binding都更好。

优势

UI代码放到了xml中，布局和数据更紧密
性能超过手写代码
保证执行在主线程

劣势

IDE支持还不那么完善（提示、表达式）
报错信息不那么直接
重构支持不好（xml中进行重构，java代码不会自动修改）

使用

使用起来实在很简单，在app模块的build.gradle中加上几行代码就行了。

Gradle

android {
    …
    dataBinding {
        enabled = true
    }
}

layout tag

把一个普通的layout变成data binding layout也只要几行的修改:

1
2
3

<layout>
	// 原来的layout
</layout>

在xml的最外层套上layout标签即可，修改后就可以看到生成了该布局对应的*Binding类。

Binding生成规则

默认生成规则：xml通过文件名生成，使用下划线分割大小写。
比如activity_demo.xml，则会生成ActivityDemoBinding，item_search_hotel则会生成ItemSearchHotelBinding。

view的生成规则类似，只是由于是类变量，首字母不是大写，比如有一个TextView的id是first_name，则会生成名为firstName的TextView。

我们也可以自定义生成的class名字，只需要：

1
2
3

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

这样生成的类就会变成ContactItem。

基础用法

生成Binding实例

所有Binding实例的生成都可以通过DataBindingUtil进行，方法名与该view的原inflate方法一致，如activity仍然为setContentView，只是增加了参数因为需要获得activity。

去除findViewById

使用了Data Binding后，我们再也不需要findViewById，因为一切有id的view，都已经在Binding类中被初始化完成了，只需要直接通过binding实例访问即可。

变量绑定

使用data标签，我们就可以在xml中申明变量，在其中使用该变量的field，并通过binding实例set进来。

如:

<data>
    <variable
        name="employee"
        type="com.github.markzhai.databindingsample.Employee"/>
</data>
<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center_horizontal"
    android:orientation="vertical"
    tools:context=".DemoActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@{employee.lastName}"
        android:layout_marginLeft="5dp"/>

</LinearLayout>

然后我们就可以在java代码中使用

1
2
3

binding.setEmployee(employee);
// 或者直接通过setVariable
binding.setVariable(BR.employee, employee);

事件绑定

严格意义上来说，事件绑定也是一种变量绑定。我们可以在xml中直接绑定

android:onClick
android:onLongClick
android:onTextChanged
…

方法引用

通常会在java代码中定义一个名为Handler或者Presenter的类，然后set进来，方法签名需和对应listener方法一致。

<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}"
            android:text="@{employee.firstName}"/>

    </LinearLayout>

</layout>

在Java代码中:


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

监听器绑定（lambda）

可以不遵循默认的方法签名：

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

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

Data Binding原理

狭义原理

狭义上，我们可以直接通过调用的接口以及生成的一些类，来观察其工作原理。

作为切入口，我们来看看DataBindingUtil的接口:

public static <T extends ViewDataBinding> T setContentView(Activity activity, int layoutId,
        DataBindingComponent bindingComponent) {
    activity.setContentView(layoutId);
    View decorView = activity.getWindow().getDecorView();
    ViewGroup contentView = (ViewGroup) decorView.findViewById(android.R.id.content);
    return bindToAddedViews(bindingComponent, contentView, 0, layoutId);
}

private static <T extends ViewDataBinding> T bindToAddedViews(DataBindingComponent component,
        ViewGroup parent, int startChildren, int layoutId) {
    final int endChildren = parent.getChildCount();
    final int childrenAdded = endChildren - startChildren;
    if (childrenAdded == 1) {
        final View childView = parent.getChildAt(endChildren - 1);
        return bind(component, childView, layoutId);
    } else {
        final View[] children = new View[childrenAdded];
        for (int i = 0; i < childrenAdded; i++) {
            children[i] = parent.getChildAt(i + startChildren);
        }
        return bind(component, children, layoutId);
    }
}

可以看到，然后会跑到具体Binding类中:

public ItemFeedRecommendUserBinding(android.databinding.DataBindingComponent bindingComponent, View root) {
    super(bindingComponent, root, 9);
    final Object[] bindings = mapBindings(bindingComponent, root, 5, sIncludes, sViewsWithIds);
    this.mboundView0 = (android.widget.LinearLayout) bindings[0];
    this.mboundView0.setTag(null);
    this.recommendUserFirst = (com.amokie.stay.databinding.IncludeRecommendUserBinding) bindings[1];
    this.recommendUserFourth = (com.amokie.stay.databinding.IncludeRecommendUserBinding) bindings[4];
    this.recommendUserSecond = (com.amokie.stay.databinding.IncludeRecommendUserBinding) bindings[2];
    this.recommendUserThird = (com.amokie.stay.databinding.IncludeRecommendUserBinding) bindings[3];
    setRootTag(root);
    // listeners
    invalidateAll();
}

可以看到所有view是一次完成的初始化，比起一个个进行findViewById，显然这样一次性会更快。

除了view的初始化，在executeBindings中，会通过mDirtyFlags去判断各个field是否需要更新，而其置位则通过各个set函数去更新。

流程原理

处理layout文件 -> 变为没有data binding的layout文件
解析表达式 -> 确保表达式语法正确
解析依赖 -> user.isAdmin, isAdmin是field还是method…
Setter -> 如visibility

性能

0反射
findViewById需要遍历整个viewgroup，而现在只需要做一次就可以初始化所有需要的view
使用位标记来检验更新（dirtyFlags）
数据改变在下一次批量更新才会触发操作
表达式缓存，同一次刷新中不会重复计算

进阶用法

表达式

算术 + - / * %
字符串合并 +
逻辑 && ||
二元 & | ^
一元 + - ! ~
移位 >> >>> <<
比较 == > < >= <=
Instanceof
Grouping ()
文字 - character, String, numeric, null
Cast
方法调用
Field 访问
Array 访问 []
三元 ?:

尚且不支持this, super, new, 以及显示的泛型调用。

值得一提的是还有空合并运算符，如

1	android:text=“@{user.displayName ?? user.lastName}”

会取第一个非空值作为结果。

这里举一个常见的例子，某个view的margin是其左侧ImageView的margin加上该ImageView的宽度，以往我们可能需要再定义一个dimension来放这两个值的合，现在只需要

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

就搞定了。

我们甚至还可以直接组合字符串，如:

1
2
3

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

<string name="nameFormat">%s, %s</string>

避免空指针

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

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

include

1	<include layout=“@layout/name” bind:user="@{user}"/>

对于include的布局，使用方法类似，不过需要在里面绑定两次，外面include该布局的layout使用bind:user给set进去。

这里需要注意的一点是，被include的布局必须顶层是一个ViewGroup，目前Data Binding的实现，如果该布局顶层是一个View，而不是ViewGroup的话，binding的下标会冲突（被覆盖），从而产生一些预料外的结果。

ViewStubs

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

private OnInflateListener mProxyListener = new OnInflateListener() {
    @Override
    public void onInflate(ViewStub stub, View inflated) {
        mRoot = inflated;
        mViewDataBinding = DataBindingUtil.bind(mContainingBinding.mBindingComponent,
                inflated, stub.getLayoutResource());
        mViewStub = null;

        if (mOnInflateListener != null) {
            mOnInflateListener.onInflate(stub, inflated);
            mOnInflateListener = null;
        }
        mContainingBinding.invalidateAll();
        mContainingBinding.forceExecuteBindings();
    }
};

在onInflate的时候才会进行真正的初始化。

Observable

一个纯净的Java ViewModel类被更新后，并不会让UI去更新。而数据绑定后，我们当然会希望数据变更后UI会即时刷新，Observable就是为此而生的概念。

BaseObservable

类继承BaseObservable:

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

BaseObservable提供了一系列notify函数（其实就是notifyChange和notifyPropertyChanged），前者会刷新所有的值域，后者则只更新对应BR的flag，该BR的生成通过注释@Bindable生成，在上面的实例代码中，我们可以看到两个get方法被注释上了，所以我们可以通过BR访问到它们并进行特定属性改变的notify。

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中访问则会相对麻烦：

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

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

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中直接通过数字下标进行访问。

动态变量

有时候，我们并不知道具体生成的binding类是什么。比如在RecyclerView中，可能有多种ViewHolder，而我们拿到的holder只是一个基类（这个基类具体怎么写下篇中会提到），这时候，我们可以在这些item的layout中都定义名字同样的variable，比如item，然后直接调用setVariable：

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

executePendingBindings会强制立即刷新绑定的改变。

参考资料

https://developer.android.com/topic/libraries/data-binding/index.html

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

承接上篇，本篇继续讲解一些Data Binding更加进阶的内容，包括：列表绑定、自定义属性、双向绑定、表达式链、Lambda表达式、动画、Component注入（测试）等。

Demo源码库：DataBindingSample。

列表绑定

App中经常用到列表展示，Data Binding在列表中一样可以扮演重要的作用，直接绑定数据和事件到每一个列表的item。

RecyclerView

过去我们往往会使用ListView、GridView、或者GitHub上一些自定义的View来做瀑布流。自从RecyclerView出现后，我们有了新选择，只需要使用LayoutManager就可以。RecyclerView内置的垃圾回收，ViewHolder、ItemDecoration装饰器机制都让我们可以毫不犹豫地替换掉原来的ListView和GridView。

所以本篇仅拿RecyclerView做例子。

Generic Binding

我们只需要定义一个基类ViewHolder，就可以方便地使用上Data Binding:

public class BindingViewHolder<T extends ViewDataBinding> extends RecyclerView.ViewHolder {

    protected final T mBinding;

    public BindingViewHolder(T binding) {
        super(binding.getRoot());
        mBinding = binding;
    }

    public T getBinding() {
        return mBinding;
    }
}

Adapter可以直接使用该ViewHolder，或者再继承该ViewHolder，T使用具体Item的Binding类（以便直接访问内部的View）。至于Listener，可以在onBindViewHolder中进行绑定，做法类似于普通View，不做赘述。

由于同一个adapter未必只有一种ViewHolder，可能有好几种View type，所以在onBindViewHolder中，我们只能获取基类的ViewHolder类型，也就是BindingViewHolder，所以无法去做具体的set操作，如setEmployee。这时候就可以使用setVariable接口，然后通过BR来指定variable的name。

又比如我们可能有多重view type对应的xml，可以将对应的variable name全都写为item，这样可以避免强制转换Binding类去做set操作。类似地，监听器也能都统一取名为listener或者presenter。

开源方案及其局限性

evant / binding-collection-adapter
radzio / android-data-binding-recyclerview

均提供了简化的RV data binding方案。

前者可以直接在layout的RV上，设置对应的items和itemView进去，也支持多种view type，还能直接设定对应的LayoutManager。

后者类似地，提供了xml中直接绑定RV的items和itemView的功能。

相比来说前者的功能更强大一些。但这些开源库对应地都丧失了灵活性，ViewModel需要遵循规范，事件的绑定也比较死板，不如自己继承Adapter来得强大。唯一的好处也就是可以少写点代码了。

自定义属性

默认的android命名空间下，我们会发现并不是所有的属性都能直接通过data binding进行设置，比如margin，padding，还有自定义View的各种属性。

遇到这些属性，我们就需要自己去定义它们的绑定方法。

Setter

就像Data Binding会自动去查找get方法一下，在遇到属性绑定的时候，它也会去自动寻找对应的set方法。

拿DrawerLayout举一个例子:

<android.support.v4.widget.DrawerLayout
    android:layout_width=“wrap_content”
    android:layout_height=“wrap_content”
    app:scrimColor=“@{@color/scrimColor}”/>

如此，通过使用app命名空间，data binding就会去根据属性名字找对应的set方法，scrimColor -> setScrimColor:

public void setScrimColor(@ColorInt int color) {
    mScrimColor = color;
    invalidate();
}

如果找不到的话，就会在编译期报错。

利用这种特性，对一些第三方的自定义View，我们就可以继承它，来加上我们的set函数，以对其使用data binding。

比如Fresco的SimpleDraweeView，我们想要直接在xml指定url，就可以加上：

1
2
3

public void setUrl(String url) {
    view.setImageURI(TextUtils.isEmpty(url) ? null : Uri.parse(url));
}

这般，就能直接在xml中去绑定图片的url。这样是不是会比较麻烦呢，而且有一些系统的View，难道还要继承它们然后用自己实现的类？其实不然，我们还有其他方法可以做到自定义属性绑定。

BindingMethods

如果View本身就支持这种属性的set，只是xml中的属性名字和java代码中的方法名不相同呢？难道就为了这个，我们还得去继承View，使代码产生冗余？

当然没有这么笨，这时候我们可以使用BindingMethods注释。

android:tint是给ImageView加上着色的属性，可以在不换图的前提下改变图标的颜色。如果我们直接对android:tint使用data binding，由于会去查找setTint方法，而该方法不存在，则会编译出错。而实际对应的方法，应该是setImageTintList。

这时候我们就可以使用BindingMethod指定属性的绑定方法：

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

我们也可以称BindingMethod为Setter重命名。

BindingAdapter

如果没有对应的set方法，或者方法签名不同怎么办？BindingAdapter注释可以帮我们来做这个。

比如View的android:paddingLeft属性，是没有对应的直接进行设置的方法的，只有setPadding(left, top, right, bottom)，而我们又不可能为了使用Data Binding去继承修改这种基础的View（即便修改了，还有一堆继承它的View呢）。又比如那些margin，需要修改必须拿到LayoutParams，这些都无法通过简单的set方法去做。

这时候我们可以使用BindingAdapter定义一个静态方法:

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

事实上这个Adapter已经由Data Binding实现好了，可以在android.databinding.adapters.ViewBindingAdapter看到有很多定义好的适配器，还有BindingMethod。如果需要自己再写点什么，仿照这些来写就好了。

我们还可以进行多属性绑定，比如

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

来使用Picasso读取图片到ImageView。

BindingConversion

有时候我们想在xml中绑定的属性，未必是最后的set方法需要的，比如我们想用color（int），但是view需要Drawable，比如我们想用String，而view需要的是Url。这时候我们就可以使用BindingConversion:

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

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

双向绑定

自定义Listener

过去，我们需要自己定义Listener来做双向绑定:

1 2	<EditText android:text=“@{user.name}” android:afterTextChanged=“@{callback.change}”/>

public void change(Editable s) {
    final String text = s.toString();
    if (!text.equals(name.get()) {
        name.set(text);
    }
}

需要自己绑定afterTextChanged方法，然后检测text是否有改变，有改变则去修改observable。

新方式 - @=

现在可以直接使用@=（而不是@）来进行双向绑定了，使用起来十分简单

<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:inputType="textNoSuggestions"
    android:text="@={model.name}"/>

这样，我们对这个EditText的输入，就会自动set到对应model的name字段上。

原理

InverseBindingListener

InverseBindingListener是事件发生时触发的监听器:

1
2
3

public interface InverseBindingListener {
    void onChange();
}

所有双向绑定，最后都是通过这个接口来observable改变的，各种监听，比如TextWatcher、OnCheckedChange，都是间接通过这个接口来通知的，以上面的EditText为例子，最后生成的InverseBindingListener:

private android.databinding.InverseBindingListener mboundView1androidTe = new android.databinding.InverseBindingListener() {
     @Override
     public void onChange() {
         // Inverse of model.name
         //         is model.setName((java.lang.String) callbackArg_0)
         java.lang.String callbackArg_0 = android.databinding.adapters.TextViewBindingAdapter.getTextString(mboundView1);
         // localize variables for thread safety
         // model != null
         boolean modelObjectnull = false;
         // model
         com.github.markzhai.sample.FormModel model = mModel;
         // model.name
         java.lang.String nameModel = null;
         modelObjectnull = (model) != (null);
         if (modelObjectnull) {
             model.setName((java.lang.String) (callbackArg_0));
         }
     }
 };

InverseBindingMethod & InverseBindingAdapter

上面的生成代码中，我们可以看到代码通过TextViewBindingAdapter.getTextString(mboundView1)去获得EditText中的字符串，查看源码可以看到

@InverseBindingAdapter(attribute = "android:text", event = "android:textAttrChanged")
public static String getTextString(TextView view) {
    return view.getText().toString();
}

原来跟上面的BindingMethod和BindingAdapter做set操作类似，双向绑定通过注解进行get操作。

完整的逻辑又是:

@BindingAdapter("android:text")
public static void setText(TextView view, CharSequence text) {
    final CharSequence oldText = view.getText();
    if (text == oldText || (text == null && oldText.length() == 0)) {
        return;
    }
    if (text instanceof Spanned) {
        if (text.equals(oldText)) {
            return; // No change in the spans, so don't set anything.
        }
    } else if (!haveContentsChanged(text, oldText)) {
        return; // No content changes, so don't set anything.
    }
    view.setText(text);
}

@InverseBindingAdapter(attribute = "android:text", event = "android:textAttrChanged")
public static String getTextString(TextView view) {
    return view.getText().toString();
}

@BindingAdapter(value = {"android:beforeTextChanged", "android:onTextChanged",
        "android:afterTextChanged", "android:textAttrChanged"}, requireAll = false)
public static void setTextWatcher(TextView view, final BeforeTextChanged before,
        final OnTextChanged on, final AfterTextChanged after,
        final InverseBindingListener textAttrChanged) {
    final TextWatcher newValue;
    if (before == null && after == null && on == null && textAttrChanged == null) {
        newValue = null;
    } else {
        newValue = new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                if (before != null) {
                    before.beforeTextChanged(s, start, count, after);
                }
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (on != null) {
                    on.onTextChanged(s, start, before, count);
                }
                if (textAttrChanged != null) {
                    textAttrChanged.onChange();
                }
            }

            @Override
            public void afterTextChanged(Editable s) {
                if (after != null) {
                    after.afterTextChanged(s);
                }
            }
        };
    }
    final TextWatcher oldValue = ListenerUtil.trackListener(view, newValue, R.id.textWatcher);
    if (oldValue != null) {
        view.removeTextChangedListener(oldValue);
    }
    if (newValue != null) {
        view.addTextChangedListener(newValue);
    }
}

我们也可以使用InverseBindingMethod做到一样的效果:

@InverseBindingMethods({
    @InverseBindingMethod(
    type=android.widget.TextView.class,
    attribute=“android:text”,
    method=“getText”,                   // 默认会根据attribute name获取get
    event=“android:textAttrChanged”)})  // 默认根据attribute增加AttrChanged

data binding通过textAttrChanged的event找到setTextWatcher方法，而setTextWatcher通知InverseBindingListener的onChange方法，onChange方法则使用找到的get和set方法去进行检查和更新。

解决死循环

如果仔细想想双向绑定的逻辑，用户输入导致实例事件发生，更新了实例的属性，实例的属性改变又会触发这个View的notify，从而变成了一个不断互相触发刷新的死循环。

为了解决死循环，我们需要做一个简单的检查，在上面的setText方法我们可以看到，如果两次的text没有改变，则会直接return，这样就杜绝了无限循环调用的可能。在自己做自定义双向绑定的时候，需要注意这点。

目前双向绑定仅支持如text，checked，year，month，hour，rating，progress等绑定。

属性改变监听

如果除了更新Observable，我们还想做一些其他事情怎么办？比如根据输入内容更新标志位？
我们可以直接使用observable上的addOnPropertyChangedCallback方法:

mModel.addOnPropertyChangedCallback(new Observable.OnPropertyChangedCallback() {
    @Override
    public void onPropertyChanged(Observable observable, int i) {
        if (i == BR.name) {
            Toast.makeText(TwoWayActivity.this, "name changed",
                    Toast.LENGTH_SHORT).show();
        } else if (i == BR.password) {
            Toast.makeText(TwoWayActivity.this, "password changed",
                    Toast.LENGTH_SHORT).show();
        }
    }
});

表达式链

重复的表达式

1
2
3

<ImageView android:visibility=“@{user.isAdult ? View.VISIBLE : View.GONE}”/>
<TextView android:visibility=“@{user.isAdult ? View.VISIBLE : View.GONE}”/>
<CheckBox android:visibility="@{user.isAdult ? View.VISIBLE : View.GONE}"/>

可以简化为:

<ImageView android:id=“@+id/avatar”
 android:visibility=“@{user.isAdult ? View.VISIBLE : View.GONE}”/>
<TextView android:visibility=“@{avatar.visibility}”/>
<CheckBox android:visibility="@{avatar.visibility}"/>

隐式更新

1
2
3

<CheckBox android:id=”@+id/seeAds“/>
<ImageView android:visibility=“@{seeAds.checked ?
  View.VISIBLE : View.GONE}”/>

这样CheckBox的状态变更后ImageView会自动改变visibility。

Lambda表达式

除了直接使用方法引用，在Presenter中写和OnClickListener一样参数的方法，我们还能使用Lambda表达式:

1
2
3

android:onClick=“@{(view)->presenter.save(view, item)}”
android:onClick=“@{()->presenter.save(item)}”
android:onFocusChange=“@{(v, fcs)->presenter.refresh(item)}”

我们还可以在lambda表达式引用view id（像上面表达式链那样），以及context。

动画

transition

使用data binding后，我们还能自动去做transition动画:

binding.addOnRebindCallback(new OnRebindCallback() {
    @Override
    public boolean onPreBind(ViewDataBinding binding) {
        ViewGroup sceneRoot = (ViewGroup) binding.getRoot();
        TransitionManager.beginDelayedTransition(sceneRoot);
        return true;
    }
});

这样，当我们的view发生改变，比如visibility变化的时候，就能看到一些transition动画。

Component注入

如果我们想要利用data binding做一些测试功能怎么办？比如打点，记录一下东西:

public class MyBindingAdapter {
    @BindingAdapter(“android:text”)
    public static void setText(TextView view, String value) {
        if (isTesting) {
            doTesting(view, value);
        } else {
            TextViewBindingAdapter.setText(view, value)
        }
    }
}

但如此一来，我们就要给所有的方法都写上if/else，维护起来很困难，也影响美感。

那么我们就可以使用component:

public class TestBindingAdapter extends MyBindingAdapter {
    @Override
    public void setText(TextView view, String value) {
        doTesting(view, value);
    }
}

public interface DataBindingComponent {
    MyBindingAdapter getMyBindingAdapter();
}

public class TestComponent implements DataBindingComponent {
    private MyBindingAdapter mAdapter = new TestBindingAdapter();

    public MyBindingAdapter getMyBindingAdapter() {
        return mAdapter;
    }
}

静态的adapter怎么办呢，我们只需要把component作为第一个参数:

@BindingAdapter(“android:src”)
public static void loadImage(TestComponent component, ImageView view, String url) {
    /// ...
}

最后通过DataBindingUtil.setDefaultComponent(new TestComponent());就能让data binding使用该Component提供的adapter方法。

学习和使用建议

学习建议

尽量在项目中进行尝试，只有在不断碰到业务的需求时，才会在真正的场景下使用并发现Data Binding的强大之处。
摸索xml和java的界限，不要以为Data Binding是万能的，而想尽办法把逻辑写在xml中，如果你的同事没法一眼看出这个表达式是做什么的，那可能它就应该放在Java代码中，以ViewModel的形式去承担部分逻辑。
Lambda表达式/测试时注入等Data Binding的高级功能也可以自己多试试，尤其是注入，相当强大。

使用建议

对新项目，不要犹豫，直接上。
对于老的项目，可以替换ButterKnife这种库，从findViewById开始改造，逐渐替换老代码。
callback绑定只做事件传递，NO业务逻辑，比如转账
保持表达式简单（不要做过于复杂的字符串、函数调用操作）

对于老项目，可以进行以下的逐步替换:

Level 1 - No more findViewById

逐步替换findViewById，取而代之地，使用binding.name, binding.age直接访问View。

Level 2 - SetVariable

引入variable，把手动在代码对View进行set替换为xml直接引用variable。

Level 3 - Callback

使用Presenter/Handler类来做事件的绑定。

Level 4 - Observable

创建ViewModel类来进行即时的属性更新触发UI刷新。

Level 5 - 双向绑定

运用双向绑定来简化表单的逻辑，将form data变成ObservableField。这样我们还可以在xml做一些酷炫的事情，比如button仅在所有field非空才为enabled（而过去要做到这个得加上好几个EditText的OnTextChange监听）。

总结

本文上下两篇介绍了大部分data binding现存的特性及部分的实现原理，大家如果纯看而不实践的话，可能会觉得有些头大，建议还是通过项目进行一下实践，才能真正体会到data binding的强大之处。欢迎加入我们的QQ群（568863373）进行讨论，你也可以加我的微信（shin_87224330）一起学习。

Data Binding Component详解 - 换肤什么的只是它的一个小应用！

上一篇从零开始的Android新项目8 - Data Binding高级篇中，我们提到了使用Component来进行注入，以方便进行测试的功能，有一些朋友说写的不够清楚，还有些疑惑，所以本篇就来详细说说Component。

作为例子，我们的实现目标是使用Data Binding Component，让应用全局的TextView的文本都能随时变成test，还能进行全局换肤。

代码位于DataBindingSample里面的component包下。

DataBindingComponent接口

在build/intermediates/classes下面，可以找到DataBindingComponent类，包名为android.databinding，全局只会有一个该类——此接口在编译时生成，包含了所有用到的实例BindingAdapters的getter方法。

当一个BindingAdapter是一个实例方法（instance method），一个实现该方法的类的实例必须被实例化。这个生成的接口会包含每个声明BindingAdapter的类/接口的get方法。命名冲突会简单地加一个数字前缀到get方法前来解决。

如果使用Dagger 2，开发者可以继承这个接口，并把继承的接口注解为Component。

对应的接口有：

setDefaultComponent(DataBindingComponent))
inflate(LayoutInflater, int, ViewGroup, boolean, DataBindingComponent)), inflate一个binding layout并返回新创建的binding
bind(View, DataBindingComponent)), 根据给定的layout root返回binding，如果没有则创建

第一个接口全局起作用，后两个接口仅对该语句inflate的布局起作用。

创建Component

声明抽象adapter

如果不需要实现多个Component，可以直接跳过这一步。

我们声明一个抽象的adapter，在其中写上抽象方法来设置我们想要做data binding的属性，这里我们直接干掉了TextView的android命名空间下的text和textColor两个属性。

这里的@BindingAdapter注解会让data binding在component中生成我们这个adapter的get方法（必须是非静态的）。

public abstract class MyBindingAdapter {

    @BindingAdapter("android:text")
    public abstract void setText(TextView view, String value);

    @BindingAdapter("android:textColor")
    public abstract void setTextColor(TextView view, int value);
}

实现adapter

我们继承MyBindingAdapter分别实现两个adapter:

ProductionBindingAdapter.java:

public class ProductionBindingAdapter extends MyBindingAdapter {

    @Override
    public void setText(TextView view, String value) {
        TextViewBindingAdapter.setText(view, value);
    }

    @Override
    public void setTextColor(TextView view, int value) {
        view.setTextColor(value);
    }
}

TestBindingAdapter.java:

public class TestBindingAdapter extends MyBindingAdapter {

    @Override
    public void setText(TextView view, String value) {
        view.setText(value + " test");
    }

    @Override
    public void setTextColor(TextView view, int value) {
        if (value == view.getContext()
                .getResources()
                .getColor(R.color.textColorDay)) {
            view.setTextColor(view.getContext()
                    .getResources()
                    .getColor(R.color.textColorNight));
        }
    }
}

前者使用的是原来的设置，后者则分别给text加上了” test”后缀，并做了color的转换，实现了字体颜色的“换肤”功能。

实现component

在写了上面的代码后，再看看DataBindingComponent，会发现里面多了一个接口方法，遂实现之:

生产环境Component:

public class ProductionComponent implements DataBindingComponent {

    private MyBindingAdapter mAdapter = new ProductionBindingAdapter();

    @Override
    public MyBindingAdapter getMyBindingAdapter() {
        return mAdapter;
    }
}

测试环境Component:

public class TestComponent implements DataBindingComponent {

    private MyBindingAdapter mAdapter = new TestBindingAdapter();

    @Override
    public MyBindingAdapter getMyBindingAdapter() {
        return mAdapter;
    }
}

使用

layout

原先的text和textColor属性并没有通过data binding设置，我们要给它们套上@{}:

<Button
    android:layout_width="match_parent"
    android:layout_height="50dp"
    android:onClick="@{presenter.onClickSimpleDemo}"
    android:text="@{@string/demo_simple}"
    android:textColor="@{@color/textColorDay}"/>

注入component

注入Component很简单，我们做全局的注入只需要调用:

if (DemoApplication.isTest) {
    DataBindingUtil.setDefaultComponent(new ProductionComponent());
} else {
    DataBindingUtil.setDefaultComponent(new TestComponent());
}

重新创建activity

由于点击事件在MainActivity创建后才触发，所以这个activity上并不会起作用，我们需要重新创建它:

public void onClickInjectDemo(View view) {
    if (DemoApplication.isTest) {
        DataBindingUtil.setDefaultComponent(new ProductionComponent());
    } else {
        DataBindingUtil.setDefaultComponent(new TestComponent());
    }
    DemoApplication.isTest = !DemoApplication.isTest;
    recreate();
}

设置后recreate()即可。可以看demo工程的效果，点击最后的按钮后，字体颜色发生变化，textview的text后面都加上了test字符串。

静态adapter方法

那么静态的BindingAdapter方法怎么去和Component做关联呢？很简单，只需要作为方法的第一个参数就可以了：

@BindingAdapter("android:src")
public static void loadImage(TestComponent component,
                             ImageView view, String url) {
    /// ...
}