Android--MVVM之DataBinding(一)

1. 目录

1–目录
2–DataBinding的疑惑
3–设置页面布局
4–获取view引用
5–更新(界面)流程

2.DataBinding的疑惑

假设你已经会用databinding，不会就去看一下怎么用，很简单，

下面是新建一个xml，名字叫layout_test1根布局是layout，你重新编译一下项目之后系统就会生成LayoutTest1Binding，以你的xml的名字加binding驼峰命名
AgeData类两个属性，一个名字，一个年龄。

databinding方法图.png

如上图所示，我们只要按照DataBinding规定的写法，我们通过获取到的引用就能拿到布局里面的控件，设置完数据，就能更新页面。

我们平常页面更新的三个流程：

在onCreate生命周期方法里面通过setContentView设置页面布局
通过findViewById获取到控件的引用
通过控件的引用调用对应的方法TextView的就是setText方法去更新

到DataBinding这里怎么就什么都不需要做了，就直接可以用了呢？

欢迎大家步入DataBinding的神奇世界，我来为大家一一解惑。

3.设置页面布局

这个其实最简单，我们先来看一下它的用法，调用的一个工具类的setContentView方法，传递了一个泛型，如下代码：

val binding =
            DataBindingUtil.setContentView<LayoutTest1Binding>(this, R.layout.layout_test1)
binding.ageData = AgeData("张三","18岁")

那么，为什么按照它这个调用方式就能设置布局呢？我们来看一下它的setContentView方法：

//我们调用的这个方法，它又调用的一个setContentView重载方法
public static <T extends ViewDataBinding> T setContentView(@NonNull Activity activity,
            int layoutId) {
    return setContentView(activity, layoutId, sDefaultComponent);
}

//内部调用这个方法
public static <T extends ViewDataBinding> T setContentView(@NonNull Activity activity,
            int layoutId, @Nullable DataBindingComponent bindingComponent) {
    //看到了嘛？等于说它实际上还是调用的activity的setContentView方法，只不过这里，它做了额外处理，拿到了传递的view
    activity.setContentView(layoutId);
    //decorView不是我们的重点，可以简单说一下，我们所写的布局只是我们自己的内容的根布局。decorView是整个界面的根布局
    View decorView = activity.getWindow().getDecorView();
    ViewGroup contentView = (ViewGroup) decorView.findViewById(android.R.id.content);
    //看整个名字，绑定views
    return bindToAddedViews(bindingComponent, contentView, 0, layoutId);
}

上面，我们看到了实际上，他还是调用的activity的setContentView方法去设置的布局。

4.获取view引用

我们平时设置布局，findViewById找到控件，然后通过调用控件的方法去设置内容，从而达到更新页面的功能。那么，databinding是怎么获取到控件的呢？我们接着上面的方法往下看：

//这里的parent就是我们的内容布局，也就是我们写的布局的上一层
private static <T extends ViewDataBinding> T bindToAddedViews(DataBindingComponent component,
            ViewGroup parent, int startChildren, int layoutId) {
    //获取全部子view的个数
    final int endChildren = parent.getChildCount();
    final int childrenAdded = endChildren - startChildren;
    //判断当前获取的子view是不是一个
    if (childrenAdded == 1) {
        //如果是一个，就直接获取
        final View childView = parent.getChildAt(endChildren - 1);
        //开始绑定
        return bind(component, childView, layoutId);
    } else {
        //如果不是一个，就看有多少个，创建一个数据
        //for循环把子view的引用全部放进数据里面
        final View[] children = new View[childrenAdded];
        for (int i = 0; i < childrenAdded; i++) {
            children[i] = parent.getChildAt(i + startChildren);
        }
        //开始绑定
        return bind(component, children, layoutId);
    }
}

我们再来看看这里绑定的方法，这里调用的方法其实都是差不多的，都是重载方法，一个是传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);
}



public abstract class DataBinderMapper {
    public abstract ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View view,
            int layoutId);
    public abstract ViewDataBinding getDataBinder(DataBindingComponent bindingComponent,
            View[] view, int layoutId);
    public abstract int getLayoutId(String tag);
    public abstract String convertBrIdToString(int id);
    @NonNull
    public List<DataBinderMapper> collectDependencies() {
        // default implementation for backwards compatibility.
        return Collections.emptyList();
    }
}

我们点进去发现跳转到了一个抽象类的方法。然后，怎么办呢？方法调用，不是静态的，肯定得看对象呀。静态的是类.方法名，不是静态的，变量.方法名。我们回过头来看这个调用的对象的类型。

public class DataBindingUtil {
    //他的实际类是DataBinderMapperImpl，我们点到这个类里面去看一下
    private static DataBinderMapper sMapper = new DataBinderMapperImpl();
    //省略掉不需要的
    ...
}

public class DataBinderMapperImpl extends MergedDataBinderMapper {
  DataBinderMapperImpl() {
    //熟悉嘛？这里有我们的包名，还有一个实现类，我们点到这个实现类里面去看,放到后面再说
    addMapper(new com.haichenyi.hcy.DataBinderMapperImpl());
  }
}

//这个方法addMapper里面 干什么了呢？
public void addMapper(DataBinderMapper mapper) {
    Class<? extends DataBinderMapper> mapperClass = mapper.getClass();
    //判断有没有添加过
    if (mExistingMappers.add(mapperClass)) {
        //然后把这个mapper放进mMappers遍历里面
        mMappers.add(mapper);
        final List<DataBinderMapper> dependencies = mapper.collectDependencies();
        for(DataBinderMapper dependency : dependencies) {
            addMapper(dependency);
        }
    }
}

回到最开始的位置sMapper.getDataBinder方法，其中sMapper是DataBinderMapperImpl类型的，但是，它的类里面并没有getDataBinder方法，所以，这里调用的就是DataBinderMapperImpl父类的getDataBinder方法。也就是MergedDataBinderMapper。我们来看一下

public class MergedDataBinderMapper extends DataBinderMapper {
    ...
    @Override
    public ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View view,
            int layoutId) {
        //这里遍历mMappers获取里面的每一项，然后调用getDataBinder方法。这个list从哪里赋值的呢？这个遍历不眼熟吗？
        for(DataBinderMapper mapper : mMappers) {
            ViewDataBinding result = mapper.getDataBinder(bindingComponent, view, layoutId);
            if (result != null) {
                return result;
            }
        }
        if (loadFeatures()) {
            return getDataBinder(bindingComponent, view, layoutId);
        }
        return null;
    }
    ...
}

没错，就是这里上面构造方法里面添加的addMapper(new com.haichenyi.hcy.DataBinderMapperImpl())，我们再来看看这个DataBinderMapperImpl，看看它的getDataBinder，因为前面sMapper.getDataBinder调用的就是它

//简单的贴我们需要的
public class DataBinderMapperImpl extends DataBinderMapper {
  private static final int LAYOUT_LAYOUTTEST1 = 1;

  private static final SparseIntArray INTERNAL_LAYOUT_ID_LOOKUP = new SparseIntArray(1);
  //首先是有一个静态的SparseIntArray，不知道是啥，反正，我基本上没用过这个东西，通过他这个存数据的方式来看，类似于map，应该是优化过后的，用在这里性能比较高，不然为啥不用map？
  static {
    //以我们的布局id为key，以他自己定义的对应的int数据为值，来存
    INTERNAL_LAYOUT_ID_LOOKUP.put(com.haichenyi.hcy.R.layout.layout_test1, LAYOUT_LAYOUTTEST1);
  }

  //这里我直接贴出来了一个类型的，就是传view的，那个传view类型数组的，实际上就是循环调用的这个方法。
  //可以看DataBinderMapperImpl的父类MergedDataBinderMapper里面有逻辑
  @Override
  public ViewDataBinding getDataBinder(DataBindingComponent component, View view, int layoutId) {
    //这里，就能够获取到值了，就是全局变量1
    int localizedLayoutId = INTERNAL_LAYOUT_ID_LOOKUP.get(layoutId);
    //1>0，判断就进去了
    if(localizedLayoutId > 0) {
      //到这里，view.getTag，我们逻辑走到这里，我们没有设置tag啊？这里岂不是判断一直都是空？就抛异常了？
      //我们可以打断点看一下，就会发现这里是能拿到值的，以我这个为例，这里获取到的tag是：layout/layout_test1_0，为什么呢？
      final Object tag = view.getTag();
      if(tag == null) {
        throw new RuntimeException("view must have a tag");
      }
      switch(localizedLayoutId) {
        case  LAYOUT_LAYOUTTEST1: {
          if ("layout/layout_test1_0".equals(tag)) {
            return new LayoutTest1BindingImpl(component, view);
          }
          throw new IllegalArgumentException("The tag for layout_test1 is invalid. Received: " + tag);
        }
      }
    }
    return null;
  }
  //省略
  ...
}

到这里，我们来聊一下，为什么他这里获取到的tag有值呢？项目重新编译的时候，databinding会根据xml的根布局是否是layout布局来重新生成xml。如下图：

databinding生成xml的图.png

如上图所示，databinding传进来的layout其实就是这个layout，并不是我们自己写的布局。所以，这个位置getTag能获取到值。

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

    <data>

        <variable
            name="ageData"
            type="com.haichenyi.hcy.data.AgeData" />
    </data>

    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <TextView
            android:id="@+id/tvName"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="30dp"
            android:text="@{ageData.name}"
            android:textColor="@color/black"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent" />

        <TextView
            android:id="@+id/tvAge"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="30dp"
            android:text="@{ageData.age}"
            android:textColor="@color/black"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toBottomOf="@id/tvName" />

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center_horizontal"
            android:orientation="vertical"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toBottomOf="@id/tvAge">

            <ImageView
                android:id="@+id/img"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:src="@mipmap/ic_launcher_round" />

            <ImageView
                android:layout_marginTop="10dp"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:src="@mipmap/ic_launcher_round" />

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@{ageData.name}"/>
        </LinearLayout>
    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

对比一下我们自己的布局：就会发现规律

在我们写的根布局会加上tag，名字叫：layout/(你的layout)_0
在你有用bean类属性(@{ageData.name}之类)的位置，他会给你的view加上tag，名字叫：binding_i,这个i，从1开始，依次+1

结合总结的这两条规律，对比一下上面的两个。

我们再返回到上面，switch语句里面，就返回了LayoutTest1BindingImpl类，这个是不是很眼熟？没错，我们调用databinding的时候传递了一个泛型LayoutTest1Binding，他俩什么关系呢？Impl结尾，一看就知道是实现类。我们点到LayoutTest1BindingImpl看一下。

我们从前面获取到布局的实现类LayoutTest1BindingImpl，上面的流程就走完了，我们还是没有看到怎么获取view的方法，一个类的创建先走的它自己的构造方法，那我们就来看一下这个实现类构造方法里面是什么，或许就有答案了。

public class LayoutTest1BindingImpl extends LayoutTest1Binding  {
    //表示布局里面有没有include标签，我们布局里面没有
    @Nullable
    private static final androidx.databinding.ViewDataBinding.IncludedLayouts sIncludes;
    //这个变量是干什么的呢？
    @Nullable
    private static final android.util.SparseIntArray sViewsWithIds;
    static {
        sIncludes = null;
        sViewsWithIds = new android.util.SparseIntArray();
        //为什么要把这个id叫img的控件这样放呢？为啥其他的不放在这里？
        //这里就可以把答案给出来，我们这个img并没有在xml里面用bean类的属性，所以就单独这样放的。
        //只要是在xml里面用了bean的属性，不管你有没有id，都是通过tag去获取的
        //有个印象就行，下面还会说这个view的获取流程
        sViewsWithIds.put(R.id.img, 4);
    }
    // views
    @NonNull
    private final androidx.constraintlayout.widget.ConstraintLayout mboundView0;
    @NonNull
    private final android.widget.TextView mboundView3;
    // variables
    // values
    // listeners
    // Inverse Binding Event Handlers

    public LayoutTest1BindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
        //正常的调用自己的三个参数的构造方法，主要，看一下第三个参数，获取的是Object[]，下面贴出来了这个方法
        this(bindingComponent, root, mapBindings(bindingComponent, root, 5, sIncludes, sViewsWithIds));
    }
    private LayoutTest1BindingImpl(androidx.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) {
        //调用父类的构造方法
        super(bindingComponent, root, 0
            , (android.widget.ImageView) bindings[4]
            , (android.widget.TextView) bindings[2]
            , (android.widget.TextView) bindings[1]
            );
        this.mboundView0 = (androidx.constraintlayout.widget.ConstraintLayout) bindings[0];
        this.mboundView0.setTag(null);
        this.mboundView3 = (android.widget.TextView) bindings[3];
        this.mboundView3.setTag(null);
        this.tvAge.setTag(null);
        this.tvName.setTag(null);
        setRootTag(root);
        // listeners
        invalidateAll();
    }

    @Override
    public void invalidateAll() {
        synchronized(this) {
                mDirtyFlags = 0x2L;
        }
        requestRebind();
    }
    ...
    public void setAgeData(@Nullable com.haichenyi.hcy.data.AgeData AgeData) {
        this.mAgeData = AgeData;
        synchronized(this) {
            mDirtyFlags |= 0x1L;
        }
        notifyPropertyChanged(BR.ageData);
        super.requestRebind();
    }
    ...
}

重点就在这里了，mapBindings这个方法里面就是获取view的流程，我们，可以来看一下。

protected static Object[] mapBindings(DataBindingComponent bindingComponent, View root,
            int numBindings, IncludedLayouts includes, SparseIntArray viewsWithIds) {
    //这个numbindings的大小是你布局里面控件的个数
    Object[] bindings = new Object[numBindings];
    mapBindings(bindingComponent, root, bindings, includes, viewsWithIds, true);
    return bindings;
}

//来咯来咯，它来咯，本篇的重点
private static void mapBindings(DataBindingComponent bindingComponent, View view,
            Object[] bindings, IncludedLayouts includes, SparseIntArray viewsWithIds,
            boolean isRoot) {
    final int indexInIncludes;
    //这个getBinding方法可以点进去看一下，通过这个view的tag(R.id.dataBinding)，来获取ViewDataBinding对象。
    //这个设置tag是在绑定完这个view后面才设置的，可以回过头去看LayoutTest1BindingImpl的构造方法里面，有个setRootTag方法，就是设置tag的位置
    //所以，这里，我们还没有设置，这里获取到的就是空，这里判断就进不去，接着往下面走
    final ViewDataBinding existingBinding = getBinding(view);
    if (existingBinding != null) {
        return;
    }
    //就到了这里，这里这个tag就是前面说过的DataBinding自己生成的xml，添加的tag
    //就是我们前面说的那两点规律，跟布局是layout/xxx_0,控件是bind_i,i是累加的
    Object objTag = view.getTag();
    final String tag = (objTag instanceof String) ? (String) objTag : null;
    boolean isBound = false;
    //判断是不是根布局，并且tag不为空，并且tag是以layout开头。
    //结合我们的布局来看，layout/layout_test1_0满足这个条件
    if (isRoot && tag != null && tag.startsWith("layout")) {
        //最后一个下划线的下标，我们的这里是19
        final int underscoreIndex = tag.lastIndexOf('_');
        //19大于0，后面这个判断是判断下划线的后一位，是否是数字，我们这里是0，也满足
        if (underscoreIndex > 0 && isNumeric(tag, underscoreIndex + 1)) {
            //取出最后一位，我们这里是0
            final int index = parseTagInt(tag, underscoreIndex + 1);
            //这个数组里面0号位置之前没有放过，肯定是空的
            if (bindings[index] == null) {
                //所以，就把0号位置放这个根布局
                bindings[index] = view;
            }
            //includes,当前布局有没有include标签，我们布局没有，一直都是空，这里indexInIncludes就等于-1
            indexInIncludes = includes == null ? -1 : index;
            isBound = true;
        } else {
            indexInIncludes = -1;
        }
        //这个else 是判断当前tag是不是binding打头
    } else if (tag != null && tag.startsWith(BINDING_TAG_PREFIX)) {
        int tagIndex = parseTagInt(tag, BINDING_NUMBER_START);
        //并且取出tag的最后一位，也就是那个数字位，
        //判断这个位置有没有元素，没有元素，就把当前元素放到这个位置
        //也就是我们的bindings[1]=TextView等
        if (bindings[tagIndex] == null) {
            bindings[tagIndex] = view;
        }
        isBound = true;
        indexInIncludes = includes == null ? -1 : tagIndex;
    } else {
        // Not a bound view
        indexInIncludes = -1;
    }
    //isBound这个值，是在前面有tag的时候，判断进去了，才会赋值成true
    //可以理解成，没有自动生成tag的元素(也就是xml里面没有用@{}赋值)，前面判断进不去，这里判断会进去。
    if (!isBound) {
        //要判断当前这个view有没有id，没有id就不用管，有id也要赋值
        final int id = view.getId();
        if (id > 0) {
            int index;
            //viewsWithIds.get(id, -1)，在viewsWithIds这个数组里面通过id获取它的索引
            //我们再回过头去看一下LayoutTest1BindingImpl的static代码块，它那里提前就存好了对应的下标
            //它这个下标是怎么来的呢？为什么我们这里img对应的是4呢？
            //我个人理解是，它先循环完有tag元素的索引，我们这里到3了，然后，我们布局里面，有id没有设置用@{}赋值的，就依次累加，所以，我们这里img对应的索引是4
            if (viewsWithIds != null && (index = viewsWithIds.get(id, -1)) >= 0 &&
                    bindings[index] == null) {
                bindings[index] = view;
            }
        }
    }
    //判断当前这个元素是不是ViewGroup，如果是ViewGroup，它里面可能还有子元素
    if (view instanceof  ViewGroup) {
        final ViewGroup viewGroup = (ViewGroup) view;
        final int count = viewGroup.getChildCount();
        int minInclude = 0;
        //循环它的子元素，去获取
        for (int i = 0; i < count; i++) {
            final View child = viewGroup.getChildAt(i);
            boolean isInclude = false;
            //这里是表示我们的布局里面有没有嵌套include标签，如果DataBinding的布局可能存在嵌套的情况，先循环里层的，再循环外层的
            if (indexInIncludes >= 0 && child.getTag() instanceof String) {
                //不是本篇的重点就不说这里面了
                ...
            }
            //上面循环玩之后，就走到这里，绑定下一个子view
            if (!isInclude) {
                mapBindings(bindingComponent, child, bindings, includes, viewsWithIds, false);
            }
        }
    }
}

经过上面这个方法的调用，就把布局里面定义了id的，生成了tag的view放进了binding里面，Object类型的数组返回回去。如下图所示：

databinding绑定后的数组.png

从上面循环也看出来了，优先通过tag找view，然后通过findViewById找view，两个都没有，就被丢弃了。所以，这里只有5个。我们布局一共7个view；LinearLayout和其中一个ImageView没有id，没有tag。循环的时候就没有找到。

再强调一遍DataBinding生成tag，是因为你再xml里面通过它规定的方式设置了值，即使，你没有给view设置id，这里也会绑定上，因为，它优先通过tag绑定view的。

流程走到这里，DataBinding已经把需要的view都找到了，并且放到了Object数组里面，接下来就是绑定引用了。我们再回过头去看重载的构造方法的代码：

public LayoutTest1BindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
    this(bindingComponent, root, mapBindings(bindingComponent, root, 5, sIncludes, sViewsWithIds));
}
//上面的mapBindings绑定好了view，传递到第三个参数，Object[] bindings。
private LayoutTest1BindingImpl(androidx.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) {
    //super调用父类的方法，我们发现代码点不过去，我们就看类上面的继承
    //CTRL+鼠标左键会直接指向xml，我们全局搜一下LayoutTest1Binding类，下面有图
    super(bindingComponent, root, 0
        //看这里获取view，强转，都是通过bindings前面绑定的
        , (android.widget.ImageView) bindings[4]
        , (android.widget.TextView) bindings[2]
        , (android.widget.TextView) bindings[1]
        );
    this.mboundView0 = (androidx.constraintlayout.widget.ConstraintLayout) bindings[0];
    this.mboundView0.setTag(null);
    this.mboundView3 = (android.widget.TextView) bindings[3];
    this.mboundView3.setTag(null);
    this.tvAge.setTag(null);
    this.tvName.setTag(null);
    setRootTag(root);
    // listeners
    invalidateAll();
}

就是这个类，点进去看

public abstract class LayoutTest1Binding extends ViewDataBinding {
  @NonNull
  public final ImageView img;

  @NonNull
  public final TextView tvAge;

  @NonNull
  public final TextView tvName;

  @Bindable
  protected AgeData mAgeData;

  protected LayoutTest1Binding(Object _bindingComponent, View _root, int _localFieldCount,
      ImageView img, TextView tvAge, TextView tvName) {
    super(_bindingComponent, _root, _localFieldCount);
    this.img = img;
    this.tvAge = tvAge;
    this.tvName = tvName;
  }

  public abstract void setAgeData(@Nullable AgeData ageData);

  @Nullable
  public AgeData getAgeData() {
    return mAgeData;
  }
  ...
}

这里只贴出来了几个我们想要知道的东西，我们从前面通过tag，id把view找到之后，传递到构造方法里面，然后，这里创建的全局的变量，分别赋值给这些变量。这样，就拿到了这些引用了。

一直到这里，获取view的引用，绑定流程就走完了。再回过头去看最开始的问题binding.tvName,binding.tvAge等等，就是拿的这里的引用，也可以看到我们最开始拿到的binding这个变量的类型就是ViewDataBinding，我们这里的LayoutTest1Binding继承的就是ViewDataBinding，就全部串起来了。

5.更新(界面)流程

可以先说结论，用的就是观察者模式。绑定view的后面它他先注册监听，我们设置数据的时候，触发回调，更新界面。

文章有点长了，更新流程放到下一章吧。这个view的绑定东西还是比较长的。最后总结一下绑定view的流程图

view绑定流程知识点.png