DataBinding做了什么

没有MVVM！没有MVVM！没有MVVM！

一、dataBinding用法

1. app的build.gradle中添加依赖：

apply plugin: 'com.android.application'

android {
    ...
    // 引入DataBinding依赖
    dataBinding{
        enabled = true
    }
}

dependencies {
    ...
}

2. 定义一个mode，两种写法是一样的l：

public class UserInfo {

public class UserInfo {

//    // 第一种方式  需要集成BaseObservable
//    private String username;
//
//    private String password;
//
//    @Bindable
//    public String getUsername() {
//        return username;
//    }
//
//    public void setUsername(String username) {
//        this.username = username;
//        notifyPropertyChanged(BR.username);
//    }
//
//    @Bindable
//    public String getPassword() {
//        return password;
//    }
//
//    public void setPassword(String password) {
//        this.password = password;
//        notifyPropertyChanged(BR.password);
//    }

    // 第二种方式
    public ObservableField<String> username = new ObservableField<>();
    public ObservableField<String> password = new ObservableField<>();
}

3. 布局的写法要在外面包一层layout，并且配置data标签，配置要绑定的model对象

<?xml version="1.0" encoding="utf-8"?>
<!-- DataBinding编码规范 -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- 定义该View（布局）需要绑定的数据来源 -->
    <data>
        <variable
            name="user"
            type="com.yu.databinding.model.UserInfo" />
    </data>

    <!-- 布局常规编码 -->
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:orientation="vertical">

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

        <EditText
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="30dp"
            android:text="@={user.password}" />
    </LinearLayout>
</layout>

name就类似一个别名、简称，type是要绑定的类的全名，用@={}进行双向绑定。

4. 在Activity设置布局之前，要先build一下工程

public class MainActivity extends AppCompatActivity {

    private UserInfo userInfo = new UserInfo();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
        userInfo.username.set("123");
        userInfo.password.set("456");
        binding.setUser(userInfo);

这样就完成了双向绑定，model数据修改会直接影响到view，view数据修改直接影响model。
用法完事，问题来了

1. ActivityMainBinding是什么？
2. DataBindingUtil.setContentView(xxx)做了什么，怎么实现的双向绑定？

二、dataBinding做了什么？

首先dataBinding会扫描布局文件，使用了dataBinding的布局会根据我们自己写的生成另外两个XML文件：

上图目录下这俩文件，注意是要build之后才生成的：
image.png
这俩文件是这样的，一个是用来布局的，只是多加了tag属性：
activity_main
第二个是把布局文件分解成了不同的Tag:
activity_mian-layout

然后看上面两个问题，先看DataBindingUtil.setContentView(xxx)做了什么，点进去追一下代码，在DataBindingUtil.java里：

    public static <T extends ViewDataBinding> T setContentView(@NonNull Activity activity,
            int layoutId, @Nullable 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);
    }

这里先用activity.setContentView(layoutId);跟我们常规设置的没区别，然后用activity找到了decorView用于更新页面，关于DecorView看这里，然后继续跟bindToAddedViews:

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

这里都调用了一个叫bind的方法，不同的是一个传递的是View，一个传递的是View数组，继续跟：

    static <T extends ViewDataBinding> T bind(DataBindingComponent bindingComponent, View[] roots,
            int layoutId) {
        return (T) sMapper.getDataBinder(bindingComponent, roots, layoutId);
    }

    static <T extends ViewDataBinding> T bind(DataBindingComponent bindingComponent, View root,
            int layoutId) {
        return (T) sMapper.getDataBinder(bindingComponent, root, layoutId);
    }

继续跟sMapper.getDataBinder发现这是个抽象类，看看在哪里实现了（方法是按option+command+B）：

寻找实现类
很显然应该去我们自己的类里跟，那这里奇怪了，我们并没有写这个类，这个是Databinding里用APT技术自动生成的类：
APT生成文件目录
APT生成的文件都在这里，APT在这里简单介绍过，这里知道是自动生成文件的一种技术就行，跟进去这个getDataBinder方法，同样是两个实现，一个单个View的，一个View数组的：

@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);
          }
          throw new IllegalArgumentException("The tag for activity_main is invalid. Received: " + tag);
        }
      }
    }
    return null;
  }

  @Override
  public ViewDataBinding getDataBinder(DataBindingComponent component, View[] views, int layoutId) {
    if(views == null || views.length == 0) {
      return null;
    }
    int localizedLayoutId = INTERNAL_LAYOUT_ID_LOOKUP.get(layoutId);
    if(localizedLayoutId > 0) {
      final Object tag = views[0].getTag();
      if(tag == null) {
        throw new RuntimeException("view must have a tag");
      }
      switch(localizedLayoutId) {
      }
    }
    return null;
  }

这里发现了从view里取tag的操作，下面这个实现只是检查了view是否有tag，上面这个实现中有个layout/activity_main_0，没错，就是上面自动生成的XML中的tag，然后返回了个ActivityMainBindingImpl的实现，这个文件也是自动生成的，点这个类继续追：

 public ActivityMainBindingImpl(@Nullable android.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
        this(bindingComponent, root, mapBindings(bindingComponent, root, 3, sIncludes, sViewsWithIds));
    }
    private ActivityMainBindingImpl(android.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) {
        super(bindingComponent, root, 2
            );
        this.mboundView0 = (android.widget.LinearLayout) bindings[0];
        this.mboundView0.setTag(null);
        this.mboundView1 = (android.widget.EditText) bindings[1];
        this.mboundView1.setTag(null);
        this.mboundView2 = (android.widget.EditText) bindings[2];
        this.mboundView2.setTag(null);
        setRootTag(root);
        // listeners
        invalidateAll();
    }

这里发现调用了mapBindings得到一个数组，并且调用了重载函数，追一下这个mapBindings先，这个函数比较长，但是里面可以看出一些重点：

private static void mapBindings(DataBindingComponent bindingComponent, View view, Object[] bindings, ViewDataBinding.IncludedLayouts includes, SparseIntArray viewsWithIds, boolean isRoot) {
      ...
            if (isRoot && tag != null && tag.startsWith("layout")) {
               ...
            } else if (tag != null && tag.startsWith("binding_")) {
               ...

            if (!isBound) {
               ...
                    bindings[count] = view;
               ...
            }

           ...
    }

这里又发现一些熟悉的东西layout、binding_，正是刚才XML中View的Tag，看到这里我们得出这个函数是把刚才的XML文件解析出的控件放进一个数组中，然后继续看上面那个重载函数，从数组中取出了这些控件，个这些控件取出的控件点一下看看，就是我们定义的一些控件：

    // views
    @NonNull
    private final android.widget.LinearLayout mboundView0;
    @NonNull
    private final android.widget.EditText mboundView1;
    @NonNull
    private final android.widget.EditText mboundView2;

然后调用了invalidateAll()，继续跟这个函数：

    @Override
    public void invalidateAll() {
        synchronized(this) {
                mDirtyFlags = 0x8L;
        }
        requestRebind();
    }

继续跟requestRebind()：

    protected void requestRebind() {
       ...
            if (USE_CHOREOGRAPHER) {
                mChoreographer.postFrameCallback(mFrameCallback);
            } else {
                mUIThreadHandler.post(mRebindRunnable);
            }
        }
    }

这里的post(mRebindRunnable)跟下去会发现很多sendMessage的操作，这里就不贴了，
看看这个mRebindRunnable里做了什么，中间的过程不贴了，顺序跟下来是这样的：
executePendingBindings()->executeBindingsInternal()->executeBindings()，这个executeBindings是抽象的，需要看自己的实现：

    @Override
    protected void executeBindings() {

        ...

        // batch finished
        if ((dirtyFlags & 0xdL) != 0) {
            // api target 1

            android.databinding.adapters.TextViewBindingAdapter.setText(this.mboundView1, userUsernameGet);
        }
        if ((dirtyFlags & 0x8L) != 0) {
            // api target 1

            android.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.mboundView1, (android.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged)null, (android.databinding.adapters.TextViewBindingAdapter.OnTextChanged)null, (android.databinding.adapters.TextViewBindingAdapter.AfterTextChanged)null, mboundView1androidTextAttrChanged);
            android.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.mboundView2, (android.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged)null, (android.databinding.adapters.TextViewBindingAdapter.OnTextChanged)null, (android.databinding.adapters.TextViewBindingAdapter.AfterTextChanged)null, mboundView2androidTextAttrChanged);
        }
        if ((dirtyFlags & 0xeL) != 0) {
            // api target 1

            android.databinding.adapters.TextViewBindingAdapter.setText(this.mboundView2, userPasswordGet);
        }
    }

bulingbuling~~看到了什么？setText()和setTextWatcher()

这个代码跟完之后，还有个地方需要注意的，就是这个类的静态块：

    private static final OnAttachStateChangeListener ROOT_REATTACHED_LISTENER;

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

这里有个OnAttachStateChangeListener，也就是每个Activity都会有一个监听View变化的，一旦有view变化，会调用mRebindRunnable.run()，mRebindRunnable上面已经跟过，是做刷新用的，也就是每个Activity都会有一个Runnable去做刷新工作。

代码到这里看差不多了，有些没贴到没说到或者迷糊的地方进去点点，这里的代码量并不大。
但是看代码的过程也发现了一些问题，就是内存的开销，其中主要有这么几点：

1. 有一个数组去存储这些控件
2. ActivityMainBindingImpl这个类对应有个Runnable负责刷新
3. 还看到一行这样的代码mUIThreadHandler.post(mRebindRunnable)，这个mUIThreadHandler也是一个Handler，Handler内部的Looper也会维持一个线程

这个ActivityMainBindingImpl是根据使用了Databinding的布局文件生成的，每一个是用了Databinding的布局都会生成这么一个文件，也可以理解问每一个Activity就会对应一个数组和两个线程，数组的大小是该布局控件数量决定的。

随着项目越来越大，使用Databinding的缺点也就越来越明显：

1. APT需要生成的文件也越来越多，编译就会越来越慢
2. 内存消耗越来越大

项目地址