【Android Jetpack高手日志】DataBinding 从入门到精通

前言

DataBinding 数据绑定库是 Android Jetpack 的一部分，借助该库可以使用声明性格式（而非程序化地）将布局中的界面组件绑定到应用中的数据源。我个人觉得，使用 DataBinding 时不要在 xml 布局文件中写复杂的逻辑，只负责绑定数据。只是负责将最终的数据和 UI 直接绑定，只是一个末端赋值而已，不涉及复杂的 UI 逻辑，而且避免了代码中大量冗余代码的判空处理，同时避免了那些常见的 setVisible 等样板方法的调用，简化开发流程，统一 UI 的数据来源。

基本使用

简单使用入门

xml布局如下：

<?xml version="1.0" encoding="utf-8"?>

<layout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools">

    <data>

        <import type="com.jackie.jetpackdemo.data.TestInfo"/>

        <variable

            name="userInfo"

            type="TestInfo" />

    </data>

    <androidx.constraintlayout.widget.ConstraintLayout

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        tools:context=".MainActivity">

        <Button

            android:id="@+id/btnGetUserInfo"

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:text="获取用户信息"

            app:layout_constraintBottom_toBottomOf="parent"

            app:layout_constraintLeft_toLeftOf="parent"

            app:layout_constraintRight_toRightOf="parent"

            app:layout_constraintTop_toTopOf="parent" />

        <TextView

            android:id="@+id/txtUserName"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:gravity="center"

            android:text="@{userInfo.age}"

            app:layout_constraintTop_toBottomOf="@+id/btnGetUserInfo"

            android:layout_marginTop="30dp"

            android:textSize="30dp"

            />

        <TextView

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:text="text"

            android:gravity="center"

            app:layout_constraintTop_toBottomOf="@+id/txtUserName"

            />

    </androidx.constraintlayout.widget.ConstraintLayout>

</layout>

Activity 中调用代码如下：

override fun onCreate(savedInstanceState: Bundle?) {

     super.onCreate(savedInstanceState)

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

        activityBinding.lifecycleOwner = this

        activityBinding.userInfo = TestInfo("lsm","lsj")

}

TestInfo 的定义如下：

public class TestInfo extends BaseObservable { //继承 BaseObservable

    private String age;

    private String name;

    public TestInfo(String age,String name){

        this.name = name;

        this.age = age;

    }

    public void setAge(String age) {

        this.age = age;

        notifyPropertyChanged(BR.age);  //需要变更的变量的 set 方法中加上 notifyPropertyChanged

    }

    public void setName(String name) {

        this.name = name;

        notifyPropertyChanged(BR.name); //需要变更的变量的 set 方法中加上 notifyPropertyChanged

    }

    @Bindable											//需要变更的变量还要加上 @Bindable 注解

    public String getAge() {

        return age;

    }

    @Bindable										 //需要变更的变量还要加上 @Bindable 注解

    public String getName() {

        return name;

    }

}

TestInfo需要继承BaseObservable，同时对于需要监听变化的变量加上@Bindable 注解，同时该变量的set方法还要加上notifyPropertyChanged，BR.xxx 是注解生成的。

数据的双向绑定

使用单向数据绑定时，您可以为特性设置值，并设置对该特性的变化作出反应的监听器：

<CheckBox

        android:id="@+id/rememberMeCheckBox"

        android:checked="@{viewmodel.rememberMe}"

        android:onCheckedChanged="@{viewmodel.rememberMeChanged}"

    />

双向数据绑定为此过程提供了一种快捷方式：

<CheckBox

        android:id="@+id/rememberMeCheckBox"

        android:checked="@={viewmodel.rememberMe}"

    />

@={} 表示法（其中重要的是包含“=”符号）可接收属性的数据更改并同时监听用户更新。其他的设置和前面的单向数据绑定一致。

结合 LiveData 使用

内容参考自这里，我们上面在使用 DataBinding 时，TestInfo 还要继承 BaseObserble，使用注解、notifyPropertyChanged()，使用起来其实挺复杂，而且还有侵入性。LiveData 结合 DataBinding 的使用步骤如下：

使用 LiveData 对象作为数据绑定来源，需要设置 LifecycleOwner。
xml 中定义变量 ViewModel，并使用 ViewModel。
binding 设置变量 ViewModel。

    //结合DataBinding使用的ViewModel

    //1\. 要使用LiveData对象作为数据绑定来源，需要设置LifecycleOwner

    binding.setLifecycleOwner(this);

    ViewModelProvider viewModelProvider = new ViewModelProvider(this);

    mUserViewModel = viewModelProvider.get(UserViewModel.class);

    //3\. 设置变量ViewModel

    binding.setVm(mUserViewModel);

xml 文件的定义如下：

        <!-- 2\. 定义ViewModel 并绑定-->

	<variable

            name="vm"

            type="com.hfy.demo01.module.jetpack.databinding.UserViewModel" />

        <TextView

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:text="@{vm.userLiveData.name}"/>

        <TextView

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:text="@{vm.userLiveData.level}"/>

这样就ok了，你会发现我们不需要在 Activity 中拿到 LivaData 去 observe(owner，observer)了，DataBinding 自动生成的代码，会帮我们去做这操作，所以需要设置LifecycleOwner。

使用自定义特性的双向数据绑定

例如，如果要在名为 MyView 的自定义视图中对 "time" 特性启用双向数据绑定，请完成以下步骤：

使用 @BindingAdapter，对用来设置初始值并在值更改时进行更新的方法进行注释：

    @BindingAdapter("time")

    @JvmStatic fun setTime(view: MyView, newValue: Time) {

        // Important to break potential infinite loops.

        if (view.time != newValue) {

            view.time = newValue

        }

    }

使用 @InverseBindingAdapter 对从视图中读取值的方法进行注释：

    @InverseBindingAdapter("time")

    @JvmStatic fun getTime(view: MyView) : Time {

        return view.getTime()

    }

更多内容请参考这里。

源码分析

我们在路径app/build/intermediates/data_binding_layout_info_type_merge/debug/out/activity_main-layout.xml查看文件

<?xml version="1.0" encoding="utf-8" standalone="yes"?>

<Layout directory="layout" filePath="app/src/main/res/layout/activity_main.xml"

    isBindingData="true" isMerge="false" layout="activity_main"

    modulePackage="com.jackie.jetpackdemo" rootNodeType="androidx.constraintlayout.widget.ConstraintLayout">

    <Variables name="userInfo" declared="true" type="TestInfo">

        <location endLine="9" endOffset="29" startLine="7" startOffset="8" />

    </Variables>

    <Imports name="TestInfo" type="com.jackie.jetpackdemo.data.TestInfo">

        <location endLine="6" endOffset="60" startLine="6" startOffset="8" />

    </Imports>

    <Targets>

        <Target tag="layout/activity_main_0"

            view="androidx.constraintlayout.widget.ConstraintLayout">

            <Expressions />

            <location endLine="47" endOffset="55" startLine="12" startOffset="4" />

        </Target>

        <Target id="@+id/txtUserName" tag="binding_1" view="TextView">

            <Expressions>

                <Expression attribute="android:text" text="userInfo.age">

                    <Location endLine="32" endOffset="41" startLine="32" startOffset="12" />

                    <TwoWay>false</TwoWay>

                    <ValueLocation endLine="32" endOffset="39" startLine="32" startOffset="28" />

                </Expression>

            </Expressions>

            <location endLine="37" endOffset="13" startLine="27" startOffset="8" />

        </Target>

        <Target id="@+id/btnGetUserInfo" view="Button">

            <Expressions />

            <location endLine="25" endOffset="55" startLine="17" startOffset="8" />

        </Target>

    </Targets>

</Layout>

可以看到<Targets>标签下面的就是我们布局，分成具体的子<Target>标签对应具体的 ConstraintLayout、TextView等，activity_main_0 对应我们的ConstraintLayout，再来路径app/build/intermediates/incremental/mergeDebugResources/stripped.dir/layout/activity_main.xml下

<?xml version="1.0" encoding="utf-8"?>

    <androidx.constraintlayout.widget.ConstraintLayout

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        tools:context=".MainActivity" android:tag="layout/activity_main_0" 		xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools">

        <Button

            android:id="@+id/btnGetUserInfo"

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:text="获取用户信息"

            app:layout_constraintBottom_toBottomOf="parent"

            app:layout_constraintLeft_toLeftOf="parent"

            app:layout_constraintRight_toRightOf="parent"

            app:layout_constraintTop_toTopOf="parent" />

        <TextView

            android:id="@+id/txtUserName"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:gravity="center"

            android:tag="binding_1"

            app:layout_constraintTop_toBottomOf="@+id/btnGetUserInfo"

            android:layout_marginTop="30dp"

            android:textSize="30dp"

            />

        <TextView

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:text="text"

            android:gravity="center"

            app:layout_constraintTop_toBottomOf="@+id/txtUserName"

            />

    </androidx.constraintlayout.widget.ConstraintLayout>

这个文件其实就是移除了<layout>、<data>标签的布局文件，里面的 tag 就是我们上面对应<Target>标签中的tag，Expression attribute="android:text" text="userInfo.age" <Expression>中的具体属性对应具体的值。

初始化

再来从val activityBinding: ActivityMainBinding = DataBindingUtil.setContentView(this,R.layout.activity_main)来分析源码，

//DataBindingUtil.java

public static <T extends ViewDataBinding> T setContentView(@NonNull Activity activity,

            int layoutId, @Nullable DataBindingComponent bindingComponent) {

        activity.setContentView(layoutId); //还是需要setContentView

        View decorView = activity.getWindow().getDecorView();

        ViewGroup contentView = (ViewGroup) decorView.findViewById(android.R.id.content);

        return bindToAddedViews(bindingComponent, contentView, 0, layoutId);

    }

我们设置的activity_xxx.xml其实是在android.R.id.content下面的，继续来看bindToAddedViews方法

//DataBindingUtil.java

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); //调用bind

        } 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); //调用bind

        }

    }

}

最终会调到bind方法

//DataBindingUtil.java

static <T extends ViewDataBinding> T bind(DataBindingComponent bindingComponent, View root,

            int layoutId) {

        return (T) sMapper.getDataBinder(bindingComponent, root, layoutId);

    }

sMapper是DataBinderMapper，其真正实现类是通过 APT 生成的DataBinderMapperImpl（app/build/generated/ap_generated_sources/debug/out/com/jackie/jetpackdemo/DataBinderMapperImpl.java）

public class DataBinderMapperImpl extends DataBinderMapper {

···

  @Override

  public ViewDataBinding getDataBinder(DataBindingComponent component, View view, int layoutId) {

    int localizedLayoutId = INTERNAL_LAYOUT_ID_LOOKUP.get(layoutId);

    if(localizedLayoutId > 0) {

      final Object tag = view.getTag();

      if(tag == null) {

        throw new RuntimeException("view must have a tag");

      }

      switch(localizedLayoutId) {

        case  LAYOUT_ACTIVITYMAIN: {

          if ("layout/activity_main_0".equals(tag)) {

            return new ActivityMainBindingImpl(component, view);  //关键代码，new ActivityMainBindingImpl

          }

			···

接下来我们来分析ActivityMainBindingImpl（app/build/generated/ap_generated_sources/debug/out/com/jackie/jetpackdemo/databinding/ActivityMainBindingImpl.java）这个类，它也是 APT 生成的，

//ActivityMainBindingImpl.java

		public ActivityMainBindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {

        this(bindingComponent, root, mapBindings(bindingComponent, root, 3, sIncludes, sViewsWithIds));

    }

    private ActivityMainBindingImpl(androidx.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) {

        super(bindingComponent, root, 1

            , (android.widget.Button) bindings[2]

            , (android.widget.TextView) bindings[1]

            );

        this.mboundView0 = (androidx.constraintlayout.widget.ConstraintLayout) bindings[0];

        this.mboundView0.setTag(null);

        this.txtUserName.setTag(null);

        setRootTag(root);

        // listeners

        invalidateAll();

    }

我们调用了第一个方法，里面的这个 3 代表着我们布局文件中有三个节点（ConstraintLayout，Button，TextView），但是我们前面的布局中明明还有一个TextView，为什么没有呢？因为我们这个TextView我们并没有设置它的 Id，所以没有生成，如果设置后重新 build 下 3 就会变成 4 了。

继续来看mapBindings方法：

    protected static Object[] mapBindings(DataBindingComponent bindingComponent, View root,

            int numBindings, IncludedLayouts includes, SparseIntArray viewsWithIds) {

        Object[] bindings = new Object[numBindings];

        mapBindings(bindingComponent, root, bindings, includes, viewsWithIds, true);

        return bindings;

    }

它首先是 new 一个大小为 3 的对象数组，然后把这三个标签解析完放到该数组中。上面的ActivityMainBindingImpl公有构造器会调用私有构造器，再回过头来看

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

执行完这个代码，activityBinding中已经有这 3 个对象了，所以可以进行这样的调用

        activityBinding.txtUserName

        activityBinding.btnGetUserInfo

到目前为止，初始化已经完成了。

调用流程

接下来我们从这个调用开始分析

activityBinding.userInfo = TestInfo("lsm","lsj")

这个activityBinding.userInfo调用的实际上是ActivityMainBinding中的setUserInfo方法

    //ActivityMainBinding.java

    public void setUserInfo(@Nullable com.jackie.jetpackdemo.data.TestInfo UserInfo) {

        updateRegistration(0, UserInfo);

        this.mUserInfo = UserInfo;

        synchronized(this) {

            mDirtyFlags |= 0x1L;

        }

        notifyPropertyChanged(BR.userInfo);

        super.requestRebind();

    }

这里的updateRegistration方法如下

//localFieldId 为 BR 文件中的Id，observable 就是观察者

protected boolean updateRegistration(int localFieldId, Observable observable) {

        return updateRegistration(localFieldId, observable, CREATE_PROPERTY_LISTENER);

    }

    /**

     * Method object extracted out to attach a listener to a bound Observable object.

     */

    private static final CreateWeakListener CREATE_PROPERTY_LISTENER = new CreateWeakListener() {

        @Override

        public WeakListener create(ViewDataBinding viewDataBinding, int localFieldId) {

            return new WeakPropertyListener(viewDataBinding, localFieldId).getListener();

        }

    };

CREATE_PROPERTY_LISTENER名字也很直白，表示创建一个属性的监听器，也就是说属性发生变化的时候WeakPropertyListener监听器会被回调。

localFieldId 为 BR 文件中的 Id，BR 文件是什么呢？

public class BR {

  public static final int _all = 0;

  public static final int age = 1;

  public static final int name = 2;

  public static final int userInfo = 3;

}

因为我们的 xml 文件中导入了TestInfo(userInfo)，我们也在age和name属性上加上了@Bindable注解，所以生成了上面的BR文件。因为我们是上面调用的是setUserInfo方法，所以传入的是 0。

用该方式设置name也可以

activityBinding.setVariable(BR.name,"Jackie")

而updateRegistration中的observable就是我们传入的(TestInfo)UserInfo，再来看看updateRegistration方法

//ViewDataBinding

private boolean updateRegistration(int localFieldId, Object observable,

            CreateWeakListener listenerCreator) {

        if (observable == null) {

            return unregisterFrom(localFieldId);

        }

        WeakListener listener = mLocalFieldObservers[localFieldId];

        if (listener == null) {

            registerTo(localFieldId, observable, listenerCreator);

            return true;

        }

        if (listener.getTarget() == observable) {

            return false;//nothing to do, same object

        }

        unregisterFrom(localFieldId);

        registerTo(localFieldId, observable, listenerCreator);

        return true;

    }

mLocalFieldObservers数组中绑定了每一个属性对应的监听器，比如我们上面的 BR 中的四个值。

如果监听器为空，调用registerTo创建监听器并注册

    protected void registerTo(int localFieldId, Object observable,

            CreateWeakListener listenerCreator) {

        if (observable == null) {

            return;

        }

        WeakListener listener = mLocalFieldObservers[localFieldId];

        if (listener == null) {

            listener = listenerCreator.create(this, localFieldId);

            mLocalFieldObservers[localFieldId] = listener;

            if (mLifecycleOwner != null) {

                listener.setLifecycleOwner(mLifecycleOwner);

            }

        }

        listener.setTarget(observable);

    }

setTarget就是给被观察者添加监听器

        public void setTarget(T object) {

            unregister();

            mTarget = object;

            if (mTarget != null) {

                mObservable.addListener(mTarget);

            }

        }

这里的mObservable的实现类是WeakPropertyListener，也就是每个属性发生变化后都会进行回调

@Override

public void addListener(Observable target) {

    target.addOnPropertyChangedCallback(this);

}

而target的实现类是BaseObservable，这也就是我们的TestInfo为什么要继承BaseObservable了。

public class BaseObservable implements Observable {

    private transient PropertyChangeRegistry mCallbacks;

    public BaseObservable() {

    }

    @Override

    public void addOnPropertyChangedCallback(@NonNull OnPropertyChangedCallback callback) {

        synchronized (this) {

            if (mCallbacks == null) {

                mCallbacks = new PropertyChangeRegistry();

            }

        }

        mCallbacks.add(callback);

    }

总的关系图如下：

PropertryChangeRegistry中的add(ViewDataBinding)是将观察者和被观察者绑定起来，ViewDataBinding中的WeakListener[] mLocalFieldObservers中的每个变量都有一个WeakListener，BaseObservable中的addOnPropertyChangedCallback(WeakPropertyListener)就是添加属性变化回调。

MainActivity 调用 setUserInfo 流程图

如果上面的关系图不清楚的话，我也把流程图画出来，你可以查看一下

ActivityMainBindingImpl继承于ActivityMainBinding，而ActivityMainBinding继承于ViewDataBinding

最终是在TextViewBindingAdapter中setText来实现。

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

    }

没调用 setUser 之前的数据绑定是怎么做的？

前面我们讲了初始化过程，因为ActivityMainBindingImpl继承于ActivityMainBinding，而ActivityMainBinding继承于ViewDataBinding，在ViewDataBinding中静态初始化块如下

    static {

        if (VERSION.SDK_INT < VERSION_CODES.KITKAT) {

            ROOT_REATTACHED_LISTENER = null;

        } else {

            ROOT_REATTACHED_LISTENER = new OnAttachStateChangeListener() {

                @TargetApi(VERSION_CODES.KITKAT)

                @Override

                public void onViewAttachedToWindow(View v) {

                    // execute the pending bindings.

                    final ViewDataBinding binding = getBinding(v);

                    binding.mRebindRunnable.run();

                    v.removeOnAttachStateChangeListener(this);

                }

                @Override

                public void onViewDetachedFromWindow(View v) {

                }

            };

        }

    }

会执行mRebindRunnable的run方法

    private final Runnable mRebindRunnable = new Runnable() {

        @Override

        public void run() {

            synchronized (this) {

                mPendingRebind = false;

            }

            processReferenceQueue();

            if (VERSION.SDK_INT >= VERSION_CODES.KITKAT) {

                // Nested so that we don't get a lint warning in IntelliJ

                if (!mRoot.isAttachedToWindow()) {

                    // Don't execute the pending bindings until the View

                    // is attached again.

                    mRoot.removeOnAttachStateChangeListener(ROOT_REATTACHED_LISTENER);

                    mRoot.addOnAttachStateChangeListener(ROOT_REATTACHED_LISTENER);

                    return;

                }

            }

            executePendingBindings();

        }

    };

然后执行executePendingBindings方法，后面就和我们前面分析过的的流程一样了。最终会会调到

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

    }

我们一开始text为空，所以就直接返回了。

为什么设计如此复杂，以前我们用的话观察者和被观察者都是单独的类，现在因为可能有多个ViewModel(TestInfo、xxxInfo等)，同时也可能有多个Activity（分别进行绑定），使用原来的方式消耗很大。BR 文件会生成多个字段，用一个mLocalFieldObservers进行处理，每个字段有其具体的监听，每个xxxInfo 有其具体的监听。设计的还是挺合理的。

总结

本文先从 DataBinding 的简单使用，单向/双向绑定，结合LiveData 使用，同时也可以使用一些自定义特性，最后是进行源码分析。最后一定要注意的是不要在 xml 中做复杂的逻辑判断，只是将其看做是一个方便末端 UI 展示的支持库即可，同时也避免了大量的判空处理，同时也统一了数据的来源。

献给读者

随着互联网企业的不断发展，产品项目中的模块越来越多，用户体验要求也越来越高，想实现小步快跑、快速迭代的目的越来越难，还有65535，应用之间的互相调用等等问题，插件化技术应用而生。如果没有插件化技术，美团、淘宝这些集成了大量“app”的应用，可能会有几个g那么大。

所以，当今的Android移动开发，不会热修复、插件化、组件化，80%以上的面试都过不了。

Android热修复框架、插件化框架、组件化框架、图片加载框架、网络访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android开源框架。系统教程知识笔记已整理成PDF电子书上传在【GitHub】

1042页完整版PDF点击我就可以白嫖啦，记得给文章点个赞哦。

文末

感谢大家关注我，分享Android干货，交流Android技术。

对文章有何见解，或者有何技术问题，都可以在评论区一起留言讨论，我会虔诚为你解答。

也欢迎大家来我的B站找我玩，有各类Android架构师进阶技术难点的视频讲解，助你早日升职加薪。

B站直通车：https://space.bilibili.com/544650554