DataBinding的基本使用

xuyin1204

已于 2023-08-29 15:52:38 修改

阅读量845

点赞数

文章标签： Kotlin DataBinding

于 2023-08-28 09:30:11 首次发布

本文链接：https://blog.csdn.net/xuyin1204/article/details/132531640

版权

一、DataBinding的应用场景

DataBinding是谷歌15年推出的Library。DataBinding支持双向绑定，能大大减少绑定app逻辑与layout文件的“胶水代码”，例如setText、findViewById等代码。双向绑定，指的是将数据与界面绑定起来，当数据发生变化时体现再界面上，反过来界面内容变化也会同步更新到数据上，使用DataBinding能轻松实现MVVM模式。MVVM模式中ViewModel(VM)表示数据，View(V)表示界面。

为什么之前很少人使用DataBinding?
答：因为它之前非常卡顿，而且项目布局越多越大，越卡

二、MVC、MVP和MVVM框架的使用场景

MVC：适用于小型项目，够灵活，
缺点：Activity不仅要做View的事情还要做控制和模型的处理，导致Activity太过臃肿，管理混乱，没有单一职责，耦合度、扩展性都不太好
MVP：适用于大型项目、业务很重、项目很大，必须分层清楚，因为开发的人太好
优点：分层特别清晰
缺点：出现接口过多、接口地狱问题
MVVM: 适用于界面更新很频繁，比如网易云音乐、腾讯视频
DataBinding 是一个工具集，不属于哪个框架，在MVVM框架中用于完成View层与ViewModel层的双向绑定
大部分情况下，MVVM框架都会使用DataBinding；小部分情况下，MVP框架也可以使用

新的开发模块：数据驱动开发（DataBinding + ViewModel + LiveData）

特别注意：MVVM模式下的ViewModel（VM）和 Jetpack的ViewModel 不是同一东西，MVVM中的ViewModel是层次结构，而Jetpack的ViewModel是组件库。

永远没有哪个模式最好，只有哪个模式适合你的项目才是最好的

三、DataBinding的使用

1. Java版本的使用

app目录下的build.gradle文件中开启DataBinding

apply plugin: 'com.android.application'

android {
    compileSdkVersion 30
    buildToolsVersion "30.0.3"

    defaultConfig {
        applicationId "com.example.mydatabinding_java"
        minSdkVersion 26
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

    // 打开DataBinding开关
    // 第一种方式
    /*dataBinding {
        enabled true
    }*/

    // 第二种方式
    dataBinding.enabled = true
}

dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar"])
    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

}

User.java

package com.example.mydatabinding_java.model;

import com.example.mydatabinding_java.BR;

import androidx.databinding.BaseObservable;
import androidx.databinding.Bindable;
// Model
public class User extends BaseObservable {
    private String name;
    private String pwd;

    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    @Bindable // BR里面标记生成 name数值标记
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        notifyPropertyChanged(BR.name);  // ART注解处理器技术 生成BR文件
    }

    @Bindable // BR里面标记生成 pwd数值标记
    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
        notifyPropertyChanged(BR.pwd);   // ART注解处理器技术 生成BR文件
    }
}

activity_main.xml布局文件：

<?xml version="1.0" encoding="utf-8"?>
<!-- layout是DataBinding管理了 我们整个布局 -->
<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>
        <!-- 这里面type写全路径 不是用于反射 -->
        <!--这里的name="user"，则会生成setUser函数 -->
        <variable
            name="user"
            type="com.example.mydatabinding.model.User">
        </variable>
    </data>

    <!-- 上面的是DataBinding 内部用的，注意：Android View体系不认识-->

    <!-- Android View体系的 下面的所有内容 会给Android绘制 -->


    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <!-- @=表示 View -> Model 数据传输（一向） -->
        <EditText
            android:id="@+id/et1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:hint="Hello World!"
            android:text="@={user.name}"
            android:textSize="50sp"
            />

        <EditText
            android:id="@+id/et2"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:hint="Hello World!"
            android:text="@={user.pwd}"
            android:textSize="50sp"
            />

    </LinearLayout>
</layout>

编译之后会生成两个布局文件

在 app/build/intermediates/data_binding_layout_info_type_merge/debug/out/ 目录下生成 activity_main-layout.xml文件
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.example.mydatabinding" rootNodeType="android.widget.LinearLayout">
    <Variables name="user" declared="true" type="com.example.mydatabinding.model.User">
        <location endLine="10" endOffset="18" startLine="7" startOffset="8" />
    </Variables>
    <Targets>
        <Target tag="layout/activity_main_0" view="LinearLayout">
            <Expressions />
            <location endLine="42" endOffset="18" startLine="18" startOffset="4" />
        </Target>
        <Target id="@+id/et1" tag="binding_1" view="EditText">
            <Expressions>
                <Expression attribute="android:text" text="user.name">
                    <Location endLine="29" endOffset="39" startLine="29" startOffset="12" />
                    <TwoWay>true</TwoWay>
                    <ValueLocation endLine="29" endOffset="37" startLine="29" startOffset="29" />
                </Expression>
            </Expressions>
            <location endLine="31" endOffset="13" startLine="24" startOffset="8" />
        </Target>
        <Target id="@+id/et2" tag="binding_2" view="EditText">
            <Expressions>
                <Expression attribute="android:text" text="user.pwd">
                    <Location endLine="38" endOffset="38" startLine="38" startOffset="12" />
                    <TwoWay>true</TwoWay>
                    <ValueLocation endLine="38" endOffset="36" startLine="38" startOffset="29" />
                </Expression>
            </Expressions>
            <location endLine="40" endOffset="13" startLine="33" startOffset="8" />
        </Target>
    </Targets>
</Layout>

这个xml文件就相当于activity_main.xml布局文件中的这一截里面的内容。
可以看到，这里定义了多个Target标签，这些Target的定义，其实就是定义对应的tag，将tag与activity_main.xml布局中的对应的View的id对应起来经过DataBinding变化后的布局，会多出tag。

在 app/build/intermediates/incremental/mergeDebugResources/stripped.dir/layout/ 目录下生成 activity_main.xml文件，这个xml就相当于原activity_main.xml布局文件中的这一截里面的内容
activity_main.xml

<?xml version="1.0" encoding="utf-8"?><!-- layout是DataBinding管理了 我们整个布局 -->


<!-- 上面的是DataBinding 内部用的，注意：Android View体系不认识-->

<!-- Android View体系的 下面的所有内容 会给Android绘制 -->


<LinearLayout 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"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:tag="layout/activity_main_0">

    <!-- @=表示 View -> Model 数据传输（一向） -->
    <EditText
        android:id="@+id/et1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="Hello World!"
        android:tag="binding_1"
        android:textSize="50sp" />

    <EditText
        android:id="@+id/et2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="Hello World!"
        android:tag="binding_2"
        android:textSize="50sp" />

</LinearLayout>

MainActivity.java

package com.example.mydatabinding_java;

import androidx.appcompat.app.AppCompatActivity;
import androidx.databinding.DataBindingUtil;

import android.os.Bundle;

import com.example.mydatabinding_java.databinding.ActivityMainBinding;
import com.example.mydatabinding_java.model.User;

public class MainActivity extends AppCompatActivity {

    User user;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);

        user = new User("admin", "123456");
        binding.setUser(user);  // 必须建立绑定关系，否则没有任何效果，这里的setUser函数是在activity_main.xml布局文件中layout里面写了name="user"而生成的

        // Model(修改Model数据) -> View(UI的控件 DataBinding自动刷选)  一向 更新
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(1000);
                        user.setName(user.getName() + "啊");
                        user.setPwd(user.getPwd() + "啊");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

    }
}

2、Kotlin版本的使用

StudentInfo.kt

package com.example.mydatabinding.model

import androidx.databinding.BaseObservable
import androidx.databinding.ObservableField

class StudentInfo : BaseObservable() {
    // 第一种方式 未修复 KT放弃第一种方式
    var name : String? = null
        get() {
            return field
        }
        set(value) {
            field = value
            // notifyPropertyChanged(BR.name)
        }
    var pwd : String? = null
        get() {
            return field
        }
        set(value : String?) {
            field = value
        }

    // 第二种方式 已修复 懒加载
    val nameF : ObservableField<String> by lazy { ObservableField<String>() }
    val pwdF : ObservableField<String> by lazy { ObservableField<String>()  }
}

Kotlin目前只能采用第二种方式

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- DataBinding的编译标准 -->
<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">

    <!-- 定义View(布局)需要绑定的数据来源 -->
    <data>
        <variable
            name="studentInfo"
            type="com.example.mydatabinding.model.StudentInfo">
        </variable>
    </data>

    <!-- 上面的是DataBinding 内部用的，注意：Android View体系不认识-->

    <!-- Android 常规布局 View体系的 下面的所有内容 会给Android绘制 -->
    <!-- 布局常规代码如下 -->

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <!-- 类似Java  未修复 -->
        <EditText
            android:id="@+id/et_name1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{studentInfo.name}"
            />

        <EditText
            android:id="@+id/et_pwd1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{studentInfo.pwd}"
            />

        <!-- 修复后 -->
        <EditText
            android:id="@+id/et_name2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@{studentInfo.nameF}"
            />
        <EditText
            android:id="@+id/et_pwd2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@{studentInfo.pwdF}"
            />


        <!-- 双向绑定 @=：View -> Model 一向 -->
        <EditText
            android:id="@+id/et_name3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@={studentInfo.nameF}"
            />
        <EditText
            android:id="@+id/et_pwd3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@={studentInfo.pwdF}"
            />

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@={studentInfo.nameF}" />
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@={studentInfo.pwdF}" />
    </LinearLayout>
</layout>

MainActivity.kt

package com.example.mydatabinding

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.os.Handler
import android.util.Log
import androidx.databinding.DataBindingUtil
import com.example.mydatabinding.databinding.ActivityMainBinding
import com.example.mydatabinding.model.StudentInfo

class MainActivity : AppCompatActivity() {
    private val TAG = MainActivity::class.java.simpleName

    private val studentInfo : StudentInfo = StudentInfo()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // setContentView(R.layout.activity_main)
        // 这里必须要指定类型为ActivityMainBinding
        val binding = DataBindingUtil.setContentView<ActivityMainBinding>(this, R.layout.activity_main);

        // TODO 单向绑定第一种方式: Model -> View
        studentInfo.name = "admin"
        studentInfo.pwd = "123456"
        binding.studentInfo = studentInfo

        // 数据的刷选 发现界面没有效果 目前：界面不会根据Model的变化而变化
        // 未修复
        Log.d(TAG, "name:${studentInfo.name}, pwd:${studentInfo.pwd}")
        Handler().postDelayed({
            studentInfo.name = "test1"
            studentInfo.pwd = "11111"
        }, 2000)

        // 修复后： Model -> View 一向
        Log.d(TAG, "name:${studentInfo.name}, pwd:${studentInfo.pwd}")
        Handler().postDelayed({
            studentInfo.nameF.set("test2")
            studentInfo.pwdF.set("22222");
        }, 2000)


        // TODO 双向绑定 （一向：Model -> View   一向：View -> Model）
        studentInfo.nameF.set("zhangsan")
        studentInfo.pwdF.set("123456")
        binding.studentInfo = studentInfo
        Log.d(TAG, "name:${studentInfo.name}, pwd:${studentInfo.pwd}")

        Handler().postDelayed({
            Log.d(TAG, "name:${studentInfo.name}, pwd:${studentInfo.pwd}")
        }, 4000)
    }
}

四、DataBinding源码分析

1. DataBindingUtil.setContentView的原理

MainActivity.java

ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);

（1）DataBindingUtil.setContentView()
其实DataBindingUtil的setContentView()方法，主要就是调用activity的setContentView设置布局，并且绑定添加对应的View

DataBindingUtil.java

	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设置布局
        activity.setContentView(layoutId);
        View decorView = activity.getWindow().getDecorView();
        // 获取DecorView中的content
        ViewGroup contentView = (ViewGroup) decorView.findViewById(android.R.id.content);
        return bindToAddedViews(bindingComponent, contentView, 0, layoutId);
    }

（2）DataBindingUtil.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;
        // 如果childAdded ==1, 则就只有一个子view
        // 如果不等于1，则有多个
        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);
        }
    }

（3）DataBindingUtil.bind()

DataBindingUtil.java

    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是一个DataBinderMapper对象，其实现类是DataBinderMapperImpl，DataBinderMapperImpl是通过apt注解处理器生成的。这里的sMapper.getDataBinder()其实就是调用的MergedDataBinderMapper的getDataBinder()方法，而sMapper中的数据，其实就是DataBinderMapperImpl的构造器中调用其父类MergedDataBinderMapper的appMapper()方法添加的对象。

DataBinderMapperImpl.java

public class DataBinderMapperImpl extends MergedDataBinderMapper {
  DataBinderMapperImpl() {
    addMapper(new com.example.mydatabinding_java.DataBinderMapperImpl());
  }
}

在DataBinding中有两个DataBinderMapperImpl类，一个是上面这个在androidx.databinding包下，继承了MergedDataBinderMapper的，另一个是在com.example.mydatabinding_java应用包下，直接继承DataBinderMapper。其实MergedDataBindermaper也是继承自DataBinderMapper。

（4）MergedDataBinderMapper.getDataBinder()
MergedDataBinderMapper.java

    @Override
    public ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View[] view,
            int layoutId) {
        // mMapperrs集合中的数据就是来源于androidx.databinding.DataBinderMapperImpl的构造器中调用addMapper方法传入的对象添加的
        // 所以这里的mapper就是com.exmaple.mydatabinding_java.DataBinderMapperImpl对象
        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;
    }

（5）app/build/generated/ap_generated_sources/debug/out/目录下com.exmaple.mydatabinding_java.DataBinderMapperImpl.getDataBinder
这里需要注意两点，就是如果是布局的顶层View，比如tag为layout/activity_main_0，那么就会new一个ActivityMainBindingImpl对象，这个tag，其实可以从前面看到的app/build/intermediates/incremental/mergeDebugResources/stripped.dir/layout/activity_main.xml布局总的LinearLayout的tag知道

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

（6）ActivityMainBindingImpl的构造器
在new出ActivityMainBindingImpl对象后，则进行一些View的绑定操作，将通过tag取出的View与ActivityMainBindingImpl中对应的View属性进行绑定。
ActivityMainBindingImpl.java

    public ActivityMainBindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
        this(bindingComponent, root, mapBindings(bindingComponent, root, 3, sIncludes, sViewsWithIds));
    }

在这里，会调用一个mapBindings方法，第三个参数是一个3，表示activity_main.xml布局文件中有3个节点

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

mapBindings就会返回一个Object[] bindings数组，保存所有控件的内存信息，这个就是第一个内存消耗过大的地方，它会参考activity_main-layout.xml和activity_main.xml布局做大量的解析工作，从而产生Object数组，保存控件。布局越大，所耗的内存越多

第二个耗内存的地方是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) {
                }
            };
        }
    }

每次变动都会执行onAttachStateChangeListener()方法，从而执行回调方法onViewAttachedToWindow()方法来触发binding.mRebindRunnable.run()方法进行处理，这是非常耗内存的

（7）ViewDataBinding.mapBinding()
ViewDataBinding.java

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

    private static void mapBindings(DataBindingComponent bindingComponent, View view,
            Object[] bindings, IncludedLayouts includes, SparseIntArray viewsWithIds,
            boolean isRoot) {
        final int indexInIncludes;
        // 判断View是否已经存在绑定，如果已经绑定，则直接return
        final ViewDataBinding existingBinding = getBinding(view);
        if (existingBinding != null) {
            return;
        }
        // 获取view的tag标签
        Object objTag = view.getTag();
        final String tag = (objTag instanceof String) ? (String) objTag : null;
        boolean isBound = false;
        // 如果tag是根布局，并且是以layout开头的tag
        if (isRoot && tag != null && tag.startsWith("layout")) {
            final int underscoreIndex = tag.lastIndexOf('_');
            if (underscoreIndex > 0 && isNumeric(tag, underscoreIndex + 1)) {
                final int index = parseTagInt(tag, underscoreIndex + 1);
                // 将根布局标签对应的view放在bindings数组中
                if (bindings[index] == null) {
                    bindings[index] = view;
                }
                indexInIncludes = includes == null ? -1 : index;
                isBound = true;
            } else {
                indexInIncludes = -1;
            }
        } else if (tag != null && tag.startsWith(BINDING_TAG_PREFIX)) {
            int tagIndex = parseTagInt(tag, BINDING_NUMBER_START);
            if (bindings[tagIndex] == null) {
                bindings[tagIndex] = view;
            }
            isBound = true;
            indexInIncludes = includes == null ? -1 : tagIndex;
        } else {
            // Not a bound view
            indexInIncludes = -1;
        }
        if (!isBound) {
            final int id = view.getId();
            if (id > 0) {
                int index;
                if (viewsWithIds != null && (index = viewsWithIds.get(id, -1)) >= 0 &&
                        bindings[index] == null) {
                    bindings[index] = view;
                }
            }
        }

        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;
                if (indexInIncludes >= 0 && child.getTag() instanceof String) {
                    String childTag = (String) child.getTag();
                    if (childTag.endsWith("_0") &&
                            childTag.startsWith("layout") && childTag.indexOf('/') > 0) {
                        // This *could* be an include. Test against the expected includes.
                        int includeIndex = findIncludeIndex(childTag, minInclude,
                                includes, indexInIncludes);
                        if (includeIndex >= 0) {
                            isInclude = true;
                            minInclude = includeIndex + 1;
                            final int index = includes.indexes[indexInIncludes][includeIndex];
                            final int layoutId = includes.layoutIds[indexInIncludes][includeIndex];
                            int lastMatchingIndex = findLastMatching(viewGroup, i);
                            if (lastMatchingIndex == i) {
                                bindings[index] = DataBindingUtil.bind(bindingComponent, child,
                                        layoutId);
                            } else {
                                final int includeCount =  lastMatchingIndex - i + 1;
                                final View[] included = new View[includeCount];
                                for (int j = 0; j < includeCount; j++) {
                                    included[j] = viewGroup.getChildAt(i + j);
                                }
                                bindings[index] = DataBindingUtil.bind(bindingComponent, included,
                                        layoutId);
                                i += includeCount - 1;
                            }
                        }
                    }
                }
                if (!isInclude) {
                    mapBindings(bindingComponent, child, bindings, includes, viewsWithIds, false);
                }
            }
        }
    }

ActivityMainBindingImpl的父类ActivityMainBinding是在app/build/generated/ap_generated_sources/debug/out/com/example/mydatabinding_java/databinding包下

ActivityMainBinding.java

// Generated by data binding compiler. Do not edit!
package com.example.mydatabinding_java.databinding;

import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.EditText;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.databinding.Bindable;
import androidx.databinding.DataBindingUtil;
import androidx.databinding.ViewDataBinding;
import com.example.mydatabinding_java.R;
import com.example.mydatabinding_java.model.User;
import java.lang.Deprecated;
import java.lang.Object;

public abstract class ActivityMainBinding extends ViewDataBinding {
  @NonNull
  public final EditText et1;

  @NonNull
  public final EditText et2;

  @Bindable
  protected User mUser;

  protected ActivityMainBinding(Object _bindingComponent, View _root, int _localFieldCount,
      EditText et1, EditText et2) {
    super(_bindingComponent, _root, _localFieldCount);
    this.et1 = et1;
    this.et2 = et2;
  }

  public abstract void setUser(@Nullable User user);

  @Nullable
  public User getUser() {
    return mUser;
  }

  @NonNull
  public static ActivityMainBinding inflate(@NonNull LayoutInflater inflater,
      @Nullable ViewGroup root, boolean attachToRoot) {
    return inflate(inflater, root, attachToRoot, DataBindingUtil.getDefaultComponent());
  }

  /**
   * This method receives DataBindingComponent instance as type Object instead of
   * type DataBindingComponent to avoid causing too many compilation errors if
   * compilation fails for another reason.
   * https://issuetracker.google.com/issues/116541301
   * @Deprecated Use DataBindingUtil.inflate(inflater, R.layout.activity_main, root, attachToRoot, component)
   */
  @NonNull
  @Deprecated
  public static ActivityMainBinding inflate(@NonNull LayoutInflater inflater,
      @Nullable ViewGroup root, boolean attachToRoot, @Nullable Object component) {
    return ViewDataBinding.<ActivityMainBinding>inflateInternal(inflater, R.layout.activity_main, root, attachToRoot, component);
  }

  @NonNull
  public static ActivityMainBinding inflate(@NonNull LayoutInflater inflater) {
    return inflate(inflater, DataBindingUtil.getDefaultComponent());
  }

  /**
   * This method receives DataBindingComponent instance as type Object instead of
   * type DataBindingComponent to avoid causing too many compilation errors if
   * compilation fails for another reason.
   * https://issuetracker.google.com/issues/116541301
   * @Deprecated Use DataBindingUtil.inflate(inflater, R.layout.activity_main, null, false, component)
   */
  @NonNull
  @Deprecated
  public static ActivityMainBinding inflate(@NonNull LayoutInflater inflater,
      @Nullable Object component) {
    return ViewDataBinding.<ActivityMainBinding>inflateInternal(inflater, R.layout.activity_main, null, false, component);
  }

  public static ActivityMainBinding bind(@NonNull View view) {
    return bind(view, DataBindingUtil.getDefaultComponent());
  }

  /**
   * This method receives DataBindingComponent instance as type Object instead of
   * type DataBindingComponent to avoid causing too many compilation errors if
   * compilation fails for another reason.
   * https://issuetracker.google.com/issues/116541301
   * @Deprecated Use DataBindingUtil.bind(view, component)
   */
  @Deprecated
  public static ActivityMainBinding bind(@NonNull View view, @Nullable Object component) {
    return (ActivityMainBinding)bind(component, view, R.layout.activity_main);
  }
}

2. binding.setUser(user) 解析

BR文件
生成的路径：app/build/generated/ap_generated_sources/debug/out/com.example.mydatabinding_java/databinding/BR.java
BR的作用：就用BR中的属性值来标记不同的操作需要的监听在mLocalFieldObservers数组中的位置

// binding.setVariable(BR.name, "21341234123")
// binding.setUser(user)
// 这里的BR，其实代表的含义不同，如果是BR.user，则也是会修改整个User数据
// 如果是binding.setUser()，此时就是修改了整个DataBinding的数据
// 如果是BR.name，则是修改了name的数据

package com.example.mydatabinding_java;

public class BR {
  public static final int _all = 0;

  public static final int name = 1;

  public static final int pwd = 2;

  public static final int user = 3;
}

（1）ActivityMainBindingImpl.setUser()

app/build/generated/ap_generated_sources/debug/out/com.example.mydatabinding_java/databinding/databinding/ActivityMainBindingImpl.java

ActivityMainBinding类是抽象类，具体实现类是ActivityMainBindingImpl类

ActivityMainBindingImpl.java

    public void setUser(@Nullable com.example.mydatabinding_java.model.User User) {
       // 更新注册
        updateRegistration(0, User);
        this.mUser = User;
        synchronized(this) {
            mDirtyFlags |= 0x1L;
        }
        notifyPropertyChanged(BR.user);
        super.requestRebind();
    }

（2）ViewDataBinding.updateRegistration()

ViewDataBinding.java

    // 使用BR属性的值做index，存储每个BR的属性对应的监听器
    private WeakListener[] mLocalFieldObservers;
    
    // 创建属性的监听器
    /**
     * 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();
        }
    };


    /**
     * @hide
     */
    protected boolean updateRegistration(int localFieldId, Observable observable) {
        return updateRegistration(localFieldId, observable, CREATE_PROPERTY_LISTENER);
    }

这里的localFieldId = 0，这个id其实就是BR文件中的id，就是BR文件中对应的静态final属性的值。而第二个就是观察者对象，比如传入的ViewModel对象。

ViewDataBinding.java

    private boolean updateRegistration(int localFieldId, Object observable,
            CreateWeakListener listenerCreator) {
        if (observable == null) {
            return unregisterFrom(localFieldId);
        }
        // 根据BR的每个属性的属性值做index，存储每个BR属性对应的监听器
        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;
    }

	// 这个registerTo方法，其实就是将Activity这个观察者和User这个观察者统一添加到OnservableReference中
    protected void registerTo(int localFieldId, Object observable,
            CreateWeakListener listenerCreator) {
        if (observable == null) {
            return;
        }
        WeakListener listener = mLocalFieldObservers[localFieldId];
        if (listener == null) {
        	// 通过属性监听器的创建器创建一个BR属性值对应的监听器
        	// listener就是WeakPropertyListener对象的getListener返回的
        	// 就是WeakListener对象
        	// 在创建WeakPropertyListener的时候，其构造器内部就会创建
        	// WeakListener对象，并且将WeakPropertyListener对象传给WeakListener
        	// 这样WeakListener和WeakPropertyListener就相互持有
            listener = listenerCreator.create(this, localFieldId);
            mLocalFieldObservers[localFieldId] = listener;
            // 将监听器与观察者做绑定，这里的观察者其实就是Activity
            if (mLifecycleOwner != null) {
                listener.setLifecycleOwner(mLifecycleOwner);
            }
        }
        // 将该监听器与被观察者做绑定
        // 比如这里的被观察者就是User
        listener.setTarget(observable);
    }

这里
通过WeakListener监听器中的ObservableReference对象保存观察者与被观察者，当被观察者发生改变的时候，就会找到对应的WeakListener监听器，然后通知观察者做修改。而ObservableReference方法的实现，有多个，比如：WeakPropertyListener。这里让WeakListener.setTarget()其实就是通过WeakPropertyListener给被观察者添加callback，然后当被观察者数据发生改变的时候，被观察者通过遍历其内部的PropertyChangeRegistry中的OnPropertyChangedCallback回调（其实就是WeakPropertyListener），然后通过WeakPropertyListener监听通知给ViewDataBinding以及其实现类ActivityMainBindingImpl具体进行数据的处理和设置。

（3）WeakListener.setTarget()给Observable添加回调
这里的mTarget其实是一个泛型T对象，而这个泛型是在WeakPropertyListener初始化WeakListener的时候传入的一个Observable，这个是databinding中的Observable，其子类实现就是BaseObservable

ViewDataBinding.java

   // 这里的mObservable就是weakPropertyListener对象
   private final ObservableReference<T> mObservable;

   public void setTarget(T object) {
       unregister();
       mTarget = object;
       if (mTarget != null) {
           mObservable.addListener(mTarget);
       }
   }

WeakPropertyListener中的addListener方法，就会给Observable添加一个callback回调，向Observable这个观察者中添加callback的目的，就是在Observable数据发生变化的时候，遍历Observable中的mCallbacks这个callback集合，通知观察者进行修改。

ViewDataBinding.java

    private static class WeakPropertyListener extends Observable.OnPropertyChangedCallback
            implements ObservableReference<Observable> {
        final WeakListener<Observable> mListener;

        public WeakPropertyListener(ViewDataBinding binder, int localFieldId) {
            mListener = new WeakListener<Observable>(binder, localFieldId, this);
        }

        @Override
        public WeakListener<Observable> getListener() {
            return mListener;
        }

        @Override
        public void addListener(Observable target) {
            target.addOnPropertyChangedCallback(this);
        }

        @Override
        public void removeListener(Observable target) {
            target.removeOnPropertyChangedCallback(this);
        }

        @Override
        public void setLifecycleOwner(LifecycleOwner lifecycleOwner) {
        }

        @Override
        public void onPropertyChanged(Observable sender, int propertyId) {
        	// 当被观察者数据发生变化的时候，就会回调该方法说明属性发生变化
            ViewDataBinding binder = mListener.getBinder();
            if (binder == null) {
                return;
            }
            Observable obj = mListener.getTarget();
            if (obj != sender) {
                return; // notification from the wrong object?
            }
            binder.handleFieldChange(mListener.mLocalFieldId, sender, propertyId);
        }
    }

BaseObservable.java

    @Override
    public void addOnPropertyChangedCallback(@NonNull OnPropertyChangedCallback callback) {
        synchronized (this) {
            if (mCallbacks == null) {
            	// 这个PropertyChangeRegistry就是用来做属性修改的时候回调的
            	// 因为往被观察者中添加了callback
            	// 当被观察者发生修改的时候，就会遍历整个mCallbacks进行数据回调
                mCallbacks = new PropertyChangeRegistry();
            }
        }
        mCallbacks.add(callback);
    }

PropertyChangeRegistry.java

public class PropertyChangeRegistry extends
        CallbackRegistry<Observable.OnPropertyChangedCallback, Observable, Void> {

    private static final CallbackRegistry.NotifierCallback<Observable.OnPropertyChangedCallback, Observable, Void> NOTIFIER_CALLBACK = new CallbackRegistry.NotifierCallback<Observable.OnPropertyChangedCallback, Observable, Void>() {
        @Override
        public void onNotifyCallback(Observable.OnPropertyChangedCallback callback, Observable sender,
                int arg, Void notUsed) {
            callback.onPropertyChanged(sender, arg);
        }
    };

    public PropertyChangeRegistry() {
    	// 将静态属性NOTIFIER_CALLBACK设置给其父类的mNotifier
    	// 设置这个的目的，就是在被观察者数据发生改变的时候
    	// 能通过NOTIFIER_CALLBACK对象实现中的onNotifyCallback方法
    	// 接收回调处理，将处理过程回调给WeakPropertyListener
        super(NOTIFIER_CALLBACK);
    }

    /**
     * Notifies registered callbacks that a specific property has changed.
     *
     * @param observable The Observable that has changed.
     * @param propertyId The BR id of the property that has changed or BR._all if the entire
     *                   Observable has changed.
     */
    public void notifyChange(@NonNull Observable observable, int propertyId) {
        notifyCallbacks(observable, propertyId, null);
    }
}

从这第三步可以知道：
BaseObservable这个被观察者，会被WeakListener持有，而WeakListener会被WeakPropertyListener持有，从而BaseObservable会间接的被WeakPropertyListener持有。
而BaseObservable会通过mCallbacks持有Observable.OnPropertyChangedCallback对象，而Observable.OnPropertyChangedCallback的子类是WeakPropertyListener，所以BaseObservable也会持有WeakPropertyListener对象
而BaseObservable会持有一个mCallbacks对象，这是一个PropertyChangeRegistry对象，是CallbackRegistry的子类
而WeakPropertyListener和WeakListener是相互持有的对方的引用。
在完成监听的相互绑定关系，并且给Observable添加了回调之后，就会回到ActivityMainBindingImpl的setUser()方法继续执行notifyPropertyChanged()方法。但是这里的例子有个问题，就是监听是添加在User这个BaseObservable的子类中的，但是更新的时候，并不是通过这个User来进行通知，而是根据ActivityMainBindingImpl这个BaseObservable来通知，那么这个时候并不会通过ActivityMainBindingImpl的调用notifyPropertyChanged()最终拿到User中的PropertyChangeRegistry对象mCallbacks，所以起作用的并不是这句话，而最终ActivityMainBindingImpl在设置User起刷新作用，是因为super.requestRebind()的调用也触发了额mRebindRunnable任务的执行，其实就是没有通过PropertyChange来触发requestRebind()

（4）ActivityMainBindingImpl.notifyPropertyChanged()
这里其实就是调用的BaseObservable的notifyPropertyChanged()方法，因为ActivityMainBindingImpl是ViewDataBinding的子类，而ViewDataBinding继承了BaseObservable类

callbackRegister.java

    public synchronized void notifyCallbacks(T sender, int arg, A arg2) {
        mNotificationLevel++;
        notifyRecurse(sender, arg, arg2);
        mNotificationLevel--;
        if (mNotificationLevel == 0) {
            if (mRemainderRemoved != null) {
                for (int i = mRemainderRemoved.length - 1; i >= 0; i--) {
                    final long removedBits = mRemainderRemoved[i];
                    if (removedBits != 0) {
                        removeRemovedCallbacks((i + 1) * Long.SIZE, removedBits);
                        mRemainderRemoved[i] = 0;
                    }
                }
            }
            if (mFirst64Removed != 0) {
                removeRemovedCallbacks(0, mFirst64Removed);
                mFirst64Removed = 0;
            }
        }
    }

    private void notifyRecurse(T sender, int arg, A arg2) {
        final int callbackCount = mCallbacks.size();
        final int remainderIndex = mRemainderRemoved == null ? -1 : mRemainderRemoved.length - 1;

        // Now we've got all callbakcs that have no mRemainderRemoved value, so notify the
        // others.
        notifyRemainder(sender, arg, arg2, remainderIndex);

        // notifyRemainder notifies all at maxIndex, so we'd normally start at maxIndex + 1
        // However, we must also keep track of those in mFirst64Removed, so we add 2 instead:
        final int startCallbackIndex = (remainderIndex + 2) * Long.SIZE;

        // The remaining have no bit set
        notifyCallbacks(sender, arg, arg2, startCallbackIndex, callbackCount, 0);
    }

    private void notifyRemainder(T sender, int arg, A arg2, int remainderIndex) {
        if (remainderIndex < 0) {
            notifyFirst64(sender, arg, arg2);
        } else {
            final long bits = mRemainderRemoved[remainderIndex];
            final int startIndex = (remainderIndex + 1) * Long.SIZE;
            final int endIndex = Math.min(mCallbacks.size(), startIndex + Long.SIZE);
            notifyRemainder(sender, arg, arg2, remainderIndex - 1);
            notifyCallbacks(sender, arg, arg2, startIndex, endIndex, bits);
        }
    }

    private void notifyFirst64(T sender, int arg, A arg2) {
        final int maxNotified = Math.min(Long.SIZE, mCallbacks.size());
        notifyCallbacks(sender, arg, arg2, 0, maxNotified, mFirst64Removed);
    }

    private void notifyCallbacks(T sender, int arg, A arg2, final int startIndex,
            final int endIndex, final long bits) {
        long bitMask = 1;
        for (int i = startIndex; i < endIndex; i++) {
            if ((bits & bitMask) == 0) {
            	// mCallbacks是PropertyChangeRegistry对象
            	// mCallbacks持有的就是WeakPropertyListener对象
            	// mNotifier是静态对象，是由PropertyChangeRegistry中创建
            	// 并且由其构造器中传给其PropertyChangeRegistry的父类
                mNotifier.onNotifyCallback(mCallbacks.get(i), sender, arg, arg2);
            }
            bitMask <<= 1;
        }
    }

这里的mNotifier.notifyCallback其实就会调用到下面的PropertyChangeRegistry中定义的NOTIFIER_CALLBACK属性中的onNotifyCallback实现，而这里的callback其实就是WeakPropertyListener，因为WeakPropertyListener是OnPropertyChangedCallback的子类，这里其实会回调给mLocalFieldObservers数组中所有的WeakListener

PropertyChangeRegistry.java

public class PropertyChangeRegistry extends
        CallbackRegistry<Observable.OnPropertyChangedCallback, Observable, Void> {

    private static final CallbackRegistry.NotifierCallback<Observable.OnPropertyChangedCallback, Observable, Void> NOTIFIER_CALLBACK = new CallbackRegistry.NotifierCallback<Observable.OnPropertyChangedCallback, Observable, Void>() {
        @Override
        public void onNotifyCallback(Observable.OnPropertyChangedCallback callback, Observable sender,
                int arg, Void notUsed) {
            callback.onPropertyChanged(sender, arg);
        }
    };

    public PropertyChangeRegistry() {
        super(NOTIFIER_CALLBACK);
    }

    /**
     * Notifies registered callbacks that a specific property has changed.
     *
     * @param observable The Observable that has changed.
     * @param propertyId The BR id of the property that has changed or BR._all if the entire
     *                   Observable has changed.
     */
    public void notifyChange(@NonNull Observable observable, int propertyId) {
        notifyCallbacks(observable, propertyId, null);
    }
}

ViewDataBinding.java类内部静态类的WeakPropertyListener

    @Override
    public void onPropertyChanged(Observable sender, int propertyId) {
        ViewDataBinding binder = mListener.getBinder();
        if (binder == null) {
            return;
        }
        Observable obj = mListener.getTarget();
        if (obj != sender) {
            return; // notification from the wrong object?
        }
        // 从mListenerer中取出target，而这里的mListener其实就是WeakListener，
        // 而每个被观察者，其实都是有一个对应的LocalFieldId，这个id就是BR文件中定义的，
        // 刚才的流程中，我们传入的是0，所以这里的mLocalFieldId=0
        binder.handleFieldChange(mListener.mLocalFieldId, sender, propertyId);
    }

从mListener中取出target，而这里的mListener其实就是WeakListener，而每个被观察者，其实都是有一个对应的LocalFieldId，这个id就是BR文件中定义的，刚才的流程中，我们传入的是0，所以这里的mLocalFieldId = 0

ViewDataBinding.java

    private void handleFieldChange(int mLocalFieldId, Object object, int fieldId) {
        if (mInLiveDataRegisterObserver) {
            // We're in LiveData registration, which always results in a field change
            // that we can ignore. The value will be read immediately after anyway, so
            // there is no need to be dirty.
            return;
        }
        boolean result = onFieldChange(mLocalFieldId, object, fieldId);
        if (result) {
            requestRebind();
        }
    }

这里的onFieldChange的方法的实现，就是在ActivityMainBindingImpl.java中

ActivityMainBindingImpl.java

    @Override
    protected boolean onFieldChange(int localFieldId, Object object, int fieldId) {
        switch (localFieldId) {
            case 0 :
                return onChangeUser((com.example.mydatabinding_java.model.User) object, fieldId);
        }
        return false;
    }
    private boolean onChangeUser(com.example.mydatabinding_java.model.User User, int fieldId) {
    	// mDirtyFlags的初始值0xffffffffffffffffL
        if (fieldId == BR._all) {
            synchronized(this) {
                    mDirtyFlags |= 0x1L;
            }
            return true;
        }
        else if (fieldId == BR.name) {
            synchronized(this) {
                    mDirtyFlags |= 0x2L;
            }
            return true;
        }
        else if (fieldId == BR.pwd) {
            synchronized(this) {
                    mDirtyFlags |= 0x4L;
            }
            return true;
        }
        return false;
    }

这里因为fieldId = 0，所以会进入第一个if条件（fieldId == BR._all），所以会返回true，所以就会返回到ViewDataBinding.java中的handleFieldChange方法中，继续执行requestRebind()

ViewDataBinding.java

    protected void requestRebind() {
        if (mContainingBinding != null) {
            mContainingBinding.requestRebind();
        } else {
            final LifecycleOwner owner = this.mLifecycleOwner;
            if (owner != null) {
                Lifecycle.State state = owner.getLifecycle().getCurrentState();
                if (!state.isAtLeast(Lifecycle.State.STARTED)) {
                    return; // wait until lifecycle owner is started
                }
            }
            synchronized (this) {
                if (mPendingRebind) {
                    return;
                }
                mPendingRebind = true;
            }
            if (USE_CHOREOGRAPHER) {
                mChoreographer.postFrameCallback(mFrameCallback);
            } else {
                mUIThreadHandler.post(mRebindRunnable);
            }
        }
    }

这里最终都会执行到mRebindRunnable的run()方法。只不过SDK版本大于等于16的时候，会采用Choreographer编舞者来处理，而之前的版本则是采用Handler来执行

ViewDataBinding.java

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


    public void executePendingBindings() {
        if (mContainingBinding == null) {
            executeBindingsInternal();
        } else {
            mContainingBinding.executePendingBindings();
        }
    }

    private void executeBindingsInternal() {
        if (mIsExecutingPendingBindings) {
            requestRebind();
            return;
        }
        if (!hasPendingBindings()) {
            return;
        }
        mIsExecutingPendingBindings = true;
        mRebindHalted = false;
        if (mRebindCallbacks != null) {
            mRebindCallbacks.notifyCallbacks(this, REBIND, null);

            // The onRebindListeners will change mPendingHalted
            if (mRebindHalted) {
                mRebindCallbacks.notifyCallbacks(this, HALTED, null);
            }
        }
        if (!mRebindHalted) {
            executeBindings();
            if (mRebindCallbacks != null) {
                mRebindCallbacks.notifyCallbacks(this, REBOUND, null);
            }
        }
        mIsExecutingPendingBindings = false;
    }

在这里最终就会执行到executeBindings()方法，而该方法的实现，又是在ActivityMainBindingImpl.java中

ActivityMainBindingImpl.java

    @Override
    protected void executeBindings() {
        long dirtyFlags = 0;
        synchronized(this) {
        	// mDirtyFlags在之前的onChangeUser方法中
        	// 因为fieldId = 0，所以会执行mDirtyFlags |=0x1L
        	// 而初始值为private  long mDirtyFlags = 0xffffffffffffffffL;
            dirtyFlags = mDirtyFlags;
            mDirtyFlags = 0;
        }
        java.lang.String userName = null;
        com.example.mydatabinding_java.model.User user = mUser;
        java.lang.String userPwd = null;

		// 因为mDirtyFlags或了一个0x1L，此时再执行一个与操作
		// 不为0
        if ((dirtyFlags & 0xfL) != 0) {

			// 0xbL为1011，与上0001，则不会为0
            if ((dirtyFlags & 0xbL) != 0) {

                    if (user != null) {
                        // read user.name
                        userName = user.getName();
                    }
            }
            // 0xdL=1101，与上0001，也不会为0
            if ((dirtyFlags & 0xdL) != 0) {

                    if (user != null) {
                        // read user.pwd
                        userPwd = user.getPwd();
                    }
            }
        }
        // batch finished
        // 这里最终再执行setText的操作，其实就是调用了页面布局的View的setText
        if ((dirtyFlags & 0xbL) != 0) {
            // api target 1
			// 最后还是执行setText()方法
            androidx.databinding.adapters.TextViewBindingAdapter.setText(this.et1, userName);
        }
        if ((dirtyFlags & 0x8L) != 0) {
            // api target 1

            androidx.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.et1, (androidx.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged)null, (androidx.databinding.adapters.TextViewBindingAdapter.OnTextChanged)null, (androidx.databinding.adapters.TextViewBindingAdapter.AfterTextChanged)null, et1androidTextAttrChanged);
            androidx.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.et2, (androidx.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged)null, (androidx.databinding.adapters.TextViewBindingAdapter.OnTextChanged)null, (androidx.databinding.adapters.TextViewBindingAdapter.AfterTextChanged)null, et2androidTextAttrChanged);
        }
        if ((dirtyFlags & 0xdL) != 0) {
            // api target 1
			// 最后还是执行setText()方法
            androidx.databinding.adapters.TextViewBindingAdapter.setText(this.et2, userPwd);
        }
    }

xuyin1204

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
DataBinding的基本使用

特别注意：MVVM模式下的ViewModel（VM）和 Jetpack的ViewModel 不是同一东西，MVVM中的ViewModel是层次结构，而Jetpack的ViewModel是组件库。缺点：Activity不仅要做View的事情还要做控制和模型的处理，导致Activity太过臃肿，管理混乱，没有单一职责，耦合度、扩展性都不太好。MVVM: 适用于界面更新很频繁，比如网易云音乐。MVP：适用于大型项目、业务很重、项目很大。MVC：适用于小型项目，够灵活，缺点：出现接口过多、接口地狱问题。
复制链接

扫一扫