个人博客:haichenyi.com。感谢关注
1. 目录
- 1--目录
- 2--DataBinding的疑惑
- 3--设置页面布局
- 4--获取view引用
- 5--更新(界面)流程
2.DataBinding的疑惑
假设你已经会用databinding,不会就去看一下怎么用,很简单,
- 下面是新建一个xml,名字叫layout_test1根布局是layout,你重新编译一下项目之后系统就会生成LayoutTest1Binding,以你的xml的名字加binding驼峰命名
- AgeData类两个属性,一个名字,一个年龄。
如上图所示,我们只要按照DataBinding规定的写法,我们通过获取到的引用就能拿到布局里面的控件,设置完数据,就能更新页面。
我们平常页面更新的三个流程:
- 在onCreate生命周期方法里面通过setContentView设置页面布局
- 通过findViewById获取到控件的引用
- 通过控件的引用调用对应的方法TextView的就是setText方法去更新
到DataBinding这里怎么就什么都不需要做了,就直接可以用了呢?
欢迎大家步入DataBinding的神奇世界,我来为大家一一解惑。
3.设置页面布局
这个其实最简单,我们先来看一下它的用法,调用的一个工具类的setContentView方法,传递了一个泛型,如下代码:
val binding =
DataBindingUtil.setContentView(this, R.layout.layout_test1)
binding.ageData = AgeData("张三","18岁")
那么,为什么按照它这个调用方式就能设置布局呢?我们来看一下它的setContentView方法:
//我们调用的这个方法,它又调用的一个setContentView重载方法
public static T setContentView(@NonNull Activity activity,
int layoutId) {
return setContentView(activity, layoutId, sDefaultComponent);
}
//内部调用这个方法
public static 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 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 bind(DataBindingComponent bindingComponent, View[] roots,
int layoutId) {
return (T) sMapper.getDataBinder(bindingComponent, roots, layoutId);
}
static 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 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 mapperClass = mapper.getClass();
//判断有没有添加过
if (mExistingMappers.add(mapperClass)) {
//然后把这个mapper放进mMappers遍历里面
mMappers.add(mapper);
final List 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能获取到值。
对比一下我们自己的布局:就会发现规律
- 在我们写的根布局会加上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类型的数组返回回去。如下图所示:
从上面循环也看出来了,优先通过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的流程图