个人博客:haichenyi.com。感谢关注
假设你已经会用databinding,不会就去看一下怎么用,很简单,
如上图所示,我们只要按照DataBinding规定的写法,我们通过获取到的引用就能拿到布局里面的控件,设置完数据,就能更新页面。
我们平常页面更新的三个流程:
到DataBinding这里怎么就什么都不需要做了,就直接可以用了呢?
欢迎大家步入DataBinding的神奇世界,我来为大家一一解惑。
这个其实最简单,我们先来看一下它的用法,调用的一个工具类的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方法去设置的布局。
我们平时设置布局,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传进来的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>
对比一下我们自己的布局:就会发现规律
结合总结的这两条规律,对比一下上面的两个。
我们再返回到上面,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类型的数组返回回去。如下图所示:
从上面循环也看出来了,优先通过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,就全部串起来了。
可以先说结论,用的就是观察者模式。绑定view的后面它他先注册监听,我们设置数据的时候,触发回调,更新界面。
文章有点长了,更新流程放到下一章吧。这个view的绑定东西还是比较长的。最后总结一下绑定view的流程图