Android databinding 原理浅析

程序员文章站 2022-03-03 22:01:55

通过一个demo来分析下 databinding的原理通过此文章，希望能明白以下问题：1.dataBinding 是如何将生成的 impl 实现类返回给我们的？2.当视图有变化时（通过 EditText 输入），为什么跟其绑定的 bean 的属性会改变？3.当设置了 bean 类的某个属性时，为什么跟其绑定的视图会更新？demo如下：首先配置开启 databinding ：android { ... dataBinding { enabl...

通过一个demo来分析下 databinding的原理

通过此文章，希望能明白以下问题：

1.dataBinding 是如何将生成的 impl 实现类返回给我们的？

2.当视图有变化时（通过 EditText 输入），为什么跟其绑定的 bean 的属性会改变？

3.当设置了 bean 类的某个属性时，为什么跟其绑定的视图会更新？

demo如下：

首先配置开启 databinding ：

android {
     ...

    dataBinding {
        enabled true
    }
}

新建 SearchActivity.kt :

package com.example.myapplication.databindingTes

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.databinding.DataBindingUtil
import com.example.myapplication.R
import com.example.myapplication.databinding.ActivitySearchBinding
import com.example.myapplication.databinding.ActivitySearchBindingImpl

class SearchActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        var binding = DataBindingUtil.setContentView<ActivitySearchBinding>(
            this,
            R.layout.activity_search
        )

        var searchBean = SearchBean().apply {
            content.set("Google")
        }

        binding.searchBean = searchBean
    }
}

activity_search.xml :

注意这里绑定用的是 @={} ， @{}为单向绑定，@={}为双向绑定。

为某个模块启用视图绑定功能后，系统会为该模块中包含的每个 XML 布局文件生成一个绑定类。每个绑定类均包含对根视图以及具有 ID 的所有视图的引用。系统会通过以下方式生成绑定类的名称：将 XML 文件的名称转换为驼峰式大小写，并在末尾添加“Binding”一词，如我们的 xml 布局名称叫做 activity_search.xml ,生成的绑定类的名称就为 ActivitySearchBinding，所有生成的绑定类都是从 ViewDataBinding 类继承而来的，具体实现类是其名称后加 Impl ,如上面的就是 ActivitySearchBindingImpl。

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:app="http://schemas.android.com/apk/res-auto">
    <data>
        <variable
            name="searchBean"
            type="com.example.myapplication.databindingTes.SearchBean" />
    </data>
    <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".databindingTes.SearchActivity">
        <EditText
            android:id="@+id/et_search"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="@={searchBean.content}"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
        <TextView
            android:id="@+id/tv_search"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:text="@={searchBean.content}"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

这里是给 EditText 和 TextView 都设置了和 searchBean.content 进行了双向绑定，当通过 EditText 编辑的时候 TextView 会同步改变。

SearchBean :

package com.example.myapplication.databindingTes

import androidx.databinding.ObservableField

class SearchBean() {
    var content: ObservableField<String> = ObservableField("搜索内容")
}

通过新建以上文件之后在 AndroidStudio 进行如下操作来生成文件：

Build -> Make Module 'app'

通过 make 操作，会生成一系列文件，如下图所示：

Android databinding 原理浅析

这里主要看图示箭头标注的三个类（注意一下包名，

有一个 androidx.databinding.DataBinderMapperImpl

和com.xeample.myapplication.DataBinderMapperImpl）。

先看第一个问题：

1.dataBinding 是如何将生成的 impl 实现类返回给我们的？

在 SearchActivity.kt 中通过调用 DataBindingUtil.setContentView() 方法，

在 DataBindingUtil 中经过一系列的调用，

    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) {
        ...
        ...
        return bindToAddedViews(bindingComponent, contentView, 0, layoutId);
    }

    private static <T extends ViewDataBinding> T bindToAddedViews(DataBindingComponent component,
            ViewGroup parent, int startChildren, int layoutId) {
        final int endChildren = parent.getChildCount();
        final int childrenAdded = endChildren - startChildren;
        if (childrenAdded == 1) {
            final View childView = parent.getChildAt(endChildren - 1);
            return bind(component, childView, layoutId); // 最终调用此方法
        } else {
            final View[] children = new View[childrenAdded];
            for (int i = 0; i < childrenAdded; i++) {
                children[i] = parent.getChildAt(i + startChildren);
            }
            return bind(component, children, layoutId);
        }
    }

最终调用了 DataBindingUtil 的 bind() 方法，看一下此方法的实现，

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

发现这里是调用了 sMapper 的 getDataBinder 方法进行了返回，

先看下 sMapper 类：

package androidx.databinding;

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

注意这里是 androidx.databinding.DataBinderMapperImpl ,

androidx.databinding.DataBinderMapperImpl 继承了 androidx.databinding.MergedDataBinderMapper ,

在其构造方法里调用了父类的 addMapper() 方法，添加了一个 com.example.myapplication.DataBinderMapperImpl 对象，

注意这里的 DataBinderMapperImpl 类名一样，包名不一样。

我们之前看到 DataBindingUtil 的 bind() 方法是调用了 sMapper.getDataBinder() 方法，也就是调用了 androidx.databinding.DataBinderMapperImpl 的 getDataBinder() 方法，然而， androidx.databinding.DataBinderMapperImpl 中并没有这个方法，但是其继承了 androidx.databinding.MergedDataBinderMapper 类，也就是说其是调用了父类的方法，我们去看下其父类 androidx.databinding.MergedDataBinderMapper 里的 getDataBinder() 的实现，

androidx.databinding.MergedDataBinderMapper.getDataBinder() :

package androidx.databinding;

...
...
@SuppressWarnings("unused")
public class MergedDataBinderMapper extends DataBinderMapper {
    ...
    ...
    private List<DataBinderMapper> mMappers = new CopyOnWriteArrayList<>();
    ...
    ...
    // 其子类构造方法通过此方法添加了 com.example.myapplication.DataBinderMapperImpl 对象
    @SuppressWarnings("WeakerAccess")
    public void addMapper(DataBinderMapper mapper) { 
        Class<? extends DataBinderMapper> mapperClass = mapper.getClass();
        if (mExistingMappers.add(mapperClass)) {
            mMappers.add(mapper);
            final List<DataBinderMapper> dependencies = mapper.collectDependencies();
            for(DataBinderMapper dependency : dependencies) {
                addMapper(dependency);
            }
        }
    }
    ...
    ...
    @Override
    public ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View view,
            int layoutId) {
         // 拿到上面添加过的 com.example.myapplication.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;
    }
    ...
    ...
}

这里可以看到是遍历了 mMappers，然后调用了 DataBinderMapper 的getDataBinder() ,那 mMappers 是什么时候添加了对象呢？就是在其子类 androidx.databinding.DataBinderMapperImpl 的构造方法里，在其子类 androidx.databinding.DataBinderMapperImpl 的构造方法里，添加了一个 com.example.myapplication.DataBinderMapperImpl 对象，

也就是说最终 androidx.databinding.MergedDataBinderMapper 的 getDataBinder() 方法是调用了 com.example.myapplication.DataBinderMapperImpl 的 getDataBinder() 方法在 DataBindingUtil.bind() 里进行了返回。

看一下 com.example.myapplication.DataBinderMapperImpl.getDataBinder()

package com.example.myapplication;
...
...
public class DataBinderMapperImpl extends DataBinderMapper {
    ...
    ...
  @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_ACTIVITYSEARCH: {
          if ("layout/activity_search_0".equals(tag)) {
            return new ActivitySearchBindingImpl(component, view); // 返回了 ViewDataBinding 的具体实现。
          }
          throw new IllegalArgumentException("The tag for activity_search is invalid. Received: " + tag);
        }
      }
    }
    return null;
  }
    ...
    ...
}

在这里返回了 ViewDataBinding 的具体实现。

现在梳理一下整个流程：

1. 在 SearchActivity.kt 中调用了 DataBindingUtil.setContentView() 方法。

2.在 DataBindingUtil 中经过一系列调用，最终调用了 DataBindingUtil.bind() 方法。

3.在 DataBindingUtil.bind() 中调用了 sMapper.getDataBinder() 进行了返回。

4. sMapper 对象其实就是 androidx.databinding.DataBinderMapperImpl 对象，其在构造方法里添加了 com.example.myapplication.DataBinderMapperImpl 对象。

5.sMapper.getDataBinder() 其实是调用 androidx.databinding.DataBinderMapperImpl 的父类androidx.databinding.MergedDataBinderMapper 的 getDataBinder()

6.androidx.databinding.MergedDataBinderMapper 的 getDataBinder() 是调用的 androidx.databinding.DataBinderMapperImpl 的构造方法中添加的 com.example.myapplication.DataBinderMapperImpl 的 getDataBinder()。

7.SearchActivity.kt 中最终返回的是 com.example.myapplication.DataBinderMapperImpl.getDataBinder()。

8. com.example.myapplication.DataBinderMapperImpl.getDataBinder() 返回了具体实现 ActivitySearchBindingImpl 对象。

2.当视图有变化时（通过 EditText 输入），为什么跟其绑定的 bean 的属性会改变？

解答这个问题，需要先从 SearchActivity.kt 中说起，

SearchActivity 中最后一句调用了 binding.searchBean = searchBean ，

先去看下这句话都做了些什么操作，

我们知道模块中启用视图绑定之后，系统会为该模块中的每个 XML 布局文件生成一个绑定类，所有生成的绑定类都是从 ViewDataBinding 类继承而来的，类名称是基于布局文件的名称，它会转换为 Pascal 大小写形式并在末尾添加 Binding 后缀，并会生成一个后缀为 Impl 的具体实现类，如 demo 里生成的具体实现类是 ActivitySearchBindingImpl, 我们在 SearchActivity 中调用的 binding.searchBean = searchBean ，其实就是调用的 ActivitySearchBindingImpl 中的 setSearchBean(),然后在 setSearchBean() 里面调用了 ViewDataBinding.requestRebind()，在 ViewDataBinding.requestRebind() 中会判断 SDK 版本，不过最终都是执行了一个 Runnable 对象，如下图所示：

package androidx.databinding;

public abstract class ViewDataBinding extends BaseObservable {
    ...
    private static final boolean USE_CHOREOGRAPHER = SDK_INT >= 16;
    ...
    ...
    private final Runnable mRebindRunnable = new Runnable() {
        @Override
        public void run() {
            ...
            ...
            executePendingBindings();
        }
    };
    public void executePendingBindings() {
        if (mContainingBinding == null) {
            executeBindingsInternal();
        } else {
            mContainingBinding.executePendingBindings();
        }
    }    
    private void executeBindingsInternal() {
        ...
        ...
        if (!mRebindHalted) {
            executeBindings(); // 最后走到这里回调 ActivitySearchBindingImpl.executeBindings()。
            ...
        }
        mIsExecutingPendingBindings = false;
    }
    protected void requestRebind() {
        if (mContainingBinding != null) {
            mContainingBinding.requestRebind();
        } else {
            ...
            ...
            // 这里判断 SDK 版本号是否大于 16 , 最终都是执行了 mRebindRunnable。
            if (USE_CHOREOGRAPHER) {
                mChoreographer.postFrameCallback(mFrameCallback);
            } else {
                mUIThreadHandler.post(mRebindRunnable);
            }
        }
    }  
}

然后在 mRebindRunnable 里经过 executePendingBindings() -> executeBindingsInternal() -> executeBindings() 最终调用了 executeBindings() 抽象方法，该抽象方法就是 ActivitySearchBindingImpl.executeBindings() ，所以就是说具体是在 ActivitySearchBindingImpl.executeBindings() 里面完成了视图和 bean 绑定的操作，

具体看下 ActivitySearchBindingImpl.java ：

package com.example.myapplication.databinding;

@SuppressWarnings("unchecked")
public class ActivitySearchBindingImpl extends ActivitySearchBinding {
    ...
    ...
    // 生成一个 EditText 监听器。
    private androidx.databinding.InverseBindingListener etSearchandroidTextAttrChanged = new androidx.databinding.InverseBindingListener() {
        @Override
        public void onChange() {
            java.lang.String callbackArg_0 = androidx.databinding.adapters.TextViewBindingAdapter.getTextString(etSearch);
            boolean searchBeanJavaLangObjectNull = false;
            boolean searchBeanContentJavaLangObjectNull = false;
            java.lang.String searchBeanContentGet = null;
            com.example.myapplication.databindingTes.SearchBean searchBean = mSearchBean;
            androidx.databinding.ObservableField<java.lang.String> searchBeanContent = null;
            searchBeanJavaLangObjectNull = (searchBean) != (null);
            if (searchBeanJavaLangObjectNull) {
                searchBeanContent = searchBean.getContent();
                searchBeanContentJavaLangObjectNull = (searchBeanContent) != (null);
                if (searchBeanContentJavaLangObjectNull) {
                    // 当 EditText 内容改变时，给绑定的 bean 属性设置值。
                    searchBeanContent.set(((java.lang.String) (callbackArg_0)));
                }
            }
        }
    };
    // 跟上面EditText 一样，省略 TextView 的变化监听器
    private androidx.databinding.InverseBindingListener tvSearchandroidTextAttrChanged = new androidx.databinding.InverseBindingListener() {
        @Override
        public void onChange() {
            ...
            ...
        }
    };
    ...
    ...
    // 在 activity 中设置会调用此方法。
    public void setSearchBean(@Nullable com.example.myapplication.databindingTes.SearchBean SearchBean) {
        this.mSearchBean = SearchBean;
        synchronized (this) {
            mDirtyFlags |= 0x2L;
        }
        notifyPropertyChanged(BR.searchBean);
        super.requestRebind(); // 调用父类实现。
    }
    ...
    ...
    // 最终回调此方法，在此方法中完成绑定。
    @Override
    protected void executeBindings() {
        long dirtyFlags = 0;
        ...
        if ((dirtyFlags & 0x7L) != 0) {
            if (searchBean != null) {               
                searchBeanContent = searchBean.getContent();
            }
            updateRegistration(0, searchBeanContent); // 注册 bean 属性变化监听。
            if (searchBeanContent != null) {
                searchBeanContentGet = searchBeanContent.get();
            }
        }
        ...
        if ((dirtyFlags & 0x7L) != 0) { // 在此处设置数据。
            androidx.databinding.adapters.TextViewBindingAdapter.setText(this.etSearch, searchBeanContentGet);
            androidx.databinding.adapters.TextViewBindingAdapter.setText(this.tvSearch, searchBeanContentGet);
        }
        if ((dirtyFlags & 0x4L) != 0) { // 在此处视图变化设置监听器。
            androidx.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.etSearch,
                    (androidx.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged) null,
                    (androidx.databinding.adapters.TextViewBindingAdapter.OnTextChanged) null,
                    (androidx.databinding.adapters.TextViewBindingAdapter.AfterTextChanged) null,
                    etSearchandroidTextAttrChanged); // 给 EditText 设置监听器。
            androidx.databinding.adapters.TextViewBindingAdapter.setTextWatcher(this.tvSearch,
                    (androidx.databinding.adapters.TextViewBindingAdapter.BeforeTextChanged) null,
                    (androidx.databinding.adapters.TextViewBindingAdapter.OnTextChanged) null,
                    (androidx.databinding.adapters.TextViewBindingAdapter.AfterTextChanged) null,
                    tvSearchandroidTextAttrChanged); // 给 TextView 设置监听器。
        }
    }
    ...
}

总结一下：

当我们在 activity_search.xml 中声明了数据对象，数据绑定库会自动生成将布局中的视图与数据对象绑定所需的类 ActivitySearchBindingImpl.java，当我们在 SearchActivity.kt 中设置数据对象( binding.searchBean = searchBean )的时候,会经过一系列的方法调用 :

ActivitySearchBindingImpl.setSearchBean() -> ViewDataBinding.requestRebind() -> ViewDataBinding.executePendingBindings() -> ViewDataBinding.executeBindingsInternal() -> ActivitySearchBindingImpl.executeBindings()

最终在 ActivitySearchBindingImpl.executeBindings() 中完成绑定操作，具体操作就是为给设置了数据对象属性绑定的视图(EditText 和 TextView ) 设置监听器，在视图据发生改变的时候进行数据( searchBean.content )的设置。

3.当设置了 bean 类的某个属性时，为什么跟其绑定的视图会更新？

通过上面我们知道，当我们在 SearchActivity.kt 中执行 binding.searchBean = searchBean 时，经过一系列调用，最后会调用 ActivitySearchBindingImpl.executeBindings()，在此方法中有一个刚才没提到的方法 updateRegistration()，这个方法就是设置数据对象改变时的监听，传入了需要监听的属性对象 searchBeanContent，如下图所示：

package com.example.myapplication.databinding;
public class ActivitySearchBindingImpl extends ActivitySearchBinding {
    ...
    ...
    // 最终回调此方法，在此方法中完成绑定。
    @Override
    protected void executeBindings() {
        ...
        ...
        androidx.databinding.ObservableField<java.lang.String> searchBeanContent = null;
        if ((dirtyFlags & 0x7L) != 0) {
            if (searchBean != null) {               
                searchBeanContent = searchBean.getContent();
            }
            // 注册 bean 属性变化监听，此处传入了需要监听的属性对象 searchBeanContent。
            updateRegistration(0, searchBeanContent);
            if (searchBeanContent != null) {
                searchBeanContentGet = searchBeanContent.get();
            }
        }
        ...
        ...
}

跟着 updateRegistration() 方法进去，发现调用的是 ViewDataBinding 的 updateRegistration() 方法，看一下这个方法：

     protected boolean updateRegistration(int localFieldId, Observable observable) {
        // CREATE_PROPERTY_LISTENER 是上面的 WeakPropertyListener 对象。
        return updateRegistration(localFieldId, observable, CREATE_PROPERTY_LISTENER);
    }

这里有一个 CREATE_PROPERTY_LISTENER 对象，我们来看下这个对象是什么，

    private static final CreateWeakListener CREATE_PROPERTY_LISTENER = new CreateWeakListener() {
        @Override
        public WeakListener create(ViewDataBinding viewDataBinding, int localFieldId) {
            return new WeakPropertyListener(viewDataBinding, localFieldId).getListener();
        }
    };

通过上面代码可以看出，CREATE_PROPERTY_LISTENER 是通过创建一个 WeakPropertyListener 对象，然后调用其 getListener() 方法进行了返回，我们继续去看下 WeakPropertyListener 这个类的实现，

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); // 和 weakListener 互相引用
        }
        ...
    }

这里可以看到，

1.WeakPropertyListener 对象实现了 ObservableReference<Observable>

2.在 WeakPropertyListener 构造方法里新建了一个 WeakListener<Observable>，并传入了 this 来和 WeakListener<Observable> 进行互相引用，即 WeakPropertyListener 和 WeakListener 互相持有对方。

WeakPropertyListener 看完了，我们继续接着刚才的流程往下看 updateRegistration() 方法，

    private boolean updateRegistration(int localFieldId, Object observable,
            CreateWeakListener listenerCreator) {
        ...
        WeakListener listener = mLocalFieldObservers[localFieldId];
        if (listener == null) {
            registerTo(localFieldId, observable, listenerCreator); // 这里调用了下面的 registerTo() 方法
            return true;
        }
       ...
    }

    protected void registerTo(int localFieldId, Object observable,
            CreateWeakListener listenerCreator) {
        ...
        WeakListener listener = mLocalFieldObservers[localFieldId];
        ...
        // listener 是 WeakListener 对象。
        // observable 是刚才的 searchBeanContent 对象。
        listener.setTarget(observable); // 最终调用到此。
    }

通过上图可以看到，在 updateRegistration() 中调用了 registerTo() 方法，

在 registerTo() 中，最终执行 listener.setTarget(observable) 结束，

其中 listener 是通过常量 CREATE_PROPERTY_LISTENER 创建的 WeakListener 对象，其持有一个 WeakPropertyListener 对象，observable 是刚才的 searchBeanContent 对象，

我们去看下 WeakListener 的 setTarget() 是怎么实现的

private static class WeakListener<T> extends WeakReference<ViewDataBinding> {
        private final ObservableReference<T> mObservable; // WeakPropertyListener 对象。
        protected final int mLocalFieldId;
        private T mTarget;
        public WeakListener(ViewDataBinding binder, int localFieldId,ObservableReference<T> observable) {
            super(binder, sReferenceQueue);
            mLocalFieldId = localFieldId;
            mObservable = observable; // 跟 WeakPropertyListener 双向绑定。
        }
        ...
        public void setTarget(T object) {
            unregister();
            mTarget = object;
            if (mTarget != null) {
                // mObservable 是 WeakPropertyListener 对象。
                // mTarget 是 searchBeanContent 对象。
                mObservable.addListener(mTarget); // 执行了此行。
            }
        }
        ...
    }

发现执行了 mObservable.addListener(mTarget);

其中 mObservable 就是双向持有的 WeakPropertyListener 对象，

即调用了 WeakPropertyListener 的 addListener() 方法，参数是我们之前传过来的 searchBeanContent 对象，

然后我们跟进去看下 WeakPropertyListener 的 addListener() 方法

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); // 这里和 WeakListener 双向绑定
        }
        ...
        @Override
        public void addListener(Observable target) { 
            target.addOnPropertyChangedCallback(this); // 添加属性变化监听器
        }
        ...
        @Override
        public void onPropertyChanged(Observable sender, int propertyId) { // 属性变化时回调。
            ViewDataBinding binder = mListener.getBinder();
            ...
            binder.handleFieldChange(mListener.mLocalFieldId, sender, propertyId); // 当属性有变化时，调用了此方法。
        }
    }

从上图可以看到，addListener() 方法就是给 target 添加了一个属性变化回调监听器，target 对象是从之前传过来的 searchBeanContent 对象，传入的值是 this , 也就是自身，由于 WeakPropertyListener 本身实现了 ObservableReference<Observable> ，所以当 target 属性发生变化的时候，会回调 WeakPropertyListener 的 onPropertyChanged() 方法。onPropertyChanged() 方法最后调用了 ViewDataBinding 的 handleFieldChange() 方法，先去看下这个方法的实现，这个方法是在 ViewDataBinding 中实现的：

ViewDataBinding.java :

    private void handleFieldChange(int mLocalFieldId, Object object, int fieldId) {
        ...
        boolean result = onFieldChange(mLocalFieldId, object, fieldId);
        if (result) {
            requestRebind();
        }
    }

可以看到最后还是调用了 requestRebind() 方法，通过问题2 我们可以知道，当我们调用 ActivitySearchBindingImpl 的 setSearchBean() 方法的时候，调用的就是 ViewDataBinding 的 requestRebind() 方法，requestRebind() 是将数据和视图绑定并设置视图监听器的方法，所以这里就是又设置了一次视图，到此，完成数据变更，视图更新的操作。

梳理一下过程：

1.在 ActivitySearchBindingImpl 的 executeBindings() 方法中，调用 updateRegistration(0, searchBeanContent);

2.然后调用了 ViewDataBinding 的 updateRegistration(int localFieldId, Object observable,CreateWeakListener listenerCreator) 方法中，传入了 CREATE_PROPERTY_LISTENER 对象，这个对象是一个和 WeakPropertyListener 双向绑定的 WeakListener 对象。

3.之后调用 ViewDataBinding 的 registerTo(localFieldId, observable, listenerCreator); 在 registerTo() 中调用了 WeakListener 的 setTarget() 方法。

4.在 WeakListener 的 setTarget() 方法中，调用了与其双向绑定的 WeakPropertyListener 的 addListener() 方法。

5.在 WeakPropertyListener 的 addListener() 方法中给 searchBeanContent 对象添加了属性变化监听器,值就是其本身(其自身实现了 ObservableReference<Observable>)，这样就实现了当 searchBeanContent 对象发生变化时会回调其 onPropertyChanged() 方法。

6.当 searchBeanContent 对象发生变化时，回调 WeakPropertyListener 的 onPropertyChanged() 方法，在 onPropertyChanged() 中通过与其双向绑定的 WeakListener 的 getBinder() 方法，拿到 ViewDataBinding 对象，然后调用 ViewDataBinding 对象的 handleFieldChange() 方法。

7.ViewDataBinding 对象的 handleFieldChange() 方法最终调用了 requestRebind() 方法， requestRebind() 将视图和数据重新进行设置。

本文地址：https://blog.csdn.net/qq_31872881/article/details/108083972

相关标签：原理源码解析 android 安卓

上一篇： # Python语言基础教程(3) ------ Variable

下一篇： cf 33B string problem

Android databinding 原理浅析

通过一个demo来分析下 databinding的原理

1.dataBinding 是如何将生成的 impl 实现类返回给我们的？

2.当视图有变化时（通过 EditText 输入），为什么跟其绑定的 bean 的属性会改变？

3.当设置了 bean 类的某个属性时，为什么跟其绑定的视图会更新？

1.dataBinding 是如何将生成的 impl 实现类返回给我们的？

2.当视图有变化时（通过 EditText 输入），为什么跟其绑定的 bean 的属性会改变？

3.当设置了 bean 类的某个属性时，为什么跟其绑定的视图会更新？

Netty实现原理浅析

深入浅析ELK原理与简介

浅析PHP文件下载原理，_PHP教程

浅析PHP原理之变量(Variables inside PHP)_php技巧

编译器的原理浅析

Android TabLayout和ViewPager关联原理分析

Android的线程通信:消息机制原理(Message,Handler,MessageQueue,Looper),异步任务AsyncTask,使用JSON

Android Scroller及下拉刷新组件原理解析

深入浅析Android坐标系统

Android编程中Handler原理及用法实例分析

Android databinding 原理浅析

通过一个demo来分析下 databinding的原理

1.dataBinding 是如何将生成的 impl 实现类返回给我们的？

2.当视图有变化时（通过 EditText 输入），为什么 跟其绑定的 bean 的属性会改变？

3.当设置了 bean 类的某个属性时，为什么跟其绑定的视图会更新？

1.dataBinding 是如何将生成的 impl 实现类返回给我们的？

2.当视图有变化时（通过 EditText 输入），为什么 跟其绑定的 bean 的属性会改变？

3.当设置了 bean 类的某个属性时，为什么跟其绑定的视图会更新？

Netty实现原理浅析

深入浅析ELK原理与简介

浅析PHP文件下载原理，_PHP教程

浅析PHP原理之变量(Variables inside PHP)_php技巧

编译器的原理浅析

Android TabLayout和ViewPager关联原理分析

Android的线程通信:消息机制原理(Message,Handler,MessageQueue,Looper),异步任务AsyncTask,使用JSON

Android Scroller及下拉刷新组件原理解析

深入浅析Android坐标系统

Android编程中Handler原理及用法实例分析

2.当视图有变化时（通过 EditText 输入），为什么跟其绑定的 bean 的属性会改变？

2.当视图有变化时（通过 EditText 输入），为什么跟其绑定的 bean 的属性会改变？