前言
DataBinding 資料系結庫是 Android Jetpack 的一部分，借助該庫可以使用宣告性格式（而非程式化地）將布局中的界面組件系結到應用中的資料源，我個人覺得，使用 DataBinding 時不要在 xml 布局檔案中寫復雜的邏輯，只負責系結資料，只是負責將最終的資料和 UI 直接系結，只是一個末端賦值而已，不涉及復雜的 UI 邏輯，而且避免了代碼中大量冗余代碼的判空處理，同時避免了那些常見的 setVisible 等樣板方法的呼叫，簡化開發流程，統一 UI 的資料來源，
基本使用
簡單使用入門
xml布局如下：
<?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"
xmlns:tools="http://schemas.android.com/tools">
<data>
<import type="com.jackie.jetpackdemo.data.TestInfo"/>
<variable
name="userInfo"
type="TestInfo" />
</data>
<androidx.constraintlayout.widget.ConstraintLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<Button
android:id="@+id/btnGetUserInfo"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="獲取用戶資訊"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<TextView
android:id="@+id/txtUserName"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center"
android:text="@{userInfo.age}"
app:layout_constraintTop_toBottomOf="@+id/btnGetUserInfo"
android:layout_marginTop="30dp"
android:textSize="30dp"
/>
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="text"
android:gravity="center"
app:layout_constraintTop_toBottomOf="@+id/txtUserName"
/>
</androidx.constraintlayout.widget.ConstraintLayout>
</layout>
Activity 中呼叫代碼如下：
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val activityBinding: ActivityMainBinding = DataBindingUtil.setContentView(this,R.layout.activity_main)
activityBinding.lifecycleOwner = this
activityBinding.userInfo = TestInfo("lsm","lsj")
}
TestInfo 的定義如下：
public class TestInfo extends BaseObservable { //繼承 BaseObservable
private String age;
private String name;
public TestInfo(String age,String name){
this.name = name;
this.age = age;
}
public void setAge(String age) {
this.age = age;
notifyPropertyChanged(BR.age); //需要變更的變數的 set 方法中加上 notifyPropertyChanged
}
public void setName(String name) {
this.name = name;
notifyPropertyChanged(BR.name); //需要變更的變數的 set 方法中加上 notifyPropertyChanged
}
@Bindable //需要變更的變數還要加上 @Bindable 注解
public String getAge() {
return age;
}
@Bindable //需要變更的變數還要加上 @Bindable 注解
public String getName() {
return name;
}
}
TestInfo需要繼承BaseObservable，同時對于需要監聽變化的變數加上@Bindable 注解，同時該變數的set方法還要加上notifyPropertyChanged，BR.xxx 是注解生成的，
資料的雙向系結
使用單向資料系結時，您可以為特性設定值，并設定對該特性的變化作出反應的監聽器：
<CheckBox
android:id="@+id/rememberMeCheckBox"
android:checked="@{viewmodel.rememberMe}"
android:onCheckedChanged="@{viewmodel.rememberMeChanged}"
/>
雙向資料系結為此程序提供了一種快捷方式：
<CheckBox
android:id="@+id/rememberMeCheckBox"
android:checked="@={viewmodel.rememberMe}"
/>
@={} 表示法（其中重要的是包含“=”符號）可接收屬性的資料更改并同時監聽用戶更新，其他的設定和前面的單向資料系結一致，
結合 LiveData 使用
內容參考自這里，我們上面在使用 DataBinding 時，TestInfo 還要繼承 BaseObserble，使用注解、notifyPropertyChanged()，使用起來其實挺復雜，而且還有侵入性，LiveData 結合 DataBinding 的使用步驟如下：
- 使用 LiveData 物件作為資料系結來源，需要設定 LifecycleOwner，
- xml 中定義變數 ViewModel，并使用 ViewModel，
- binding 設定變數 ViewModel，
//結合DataBinding使用的ViewModel
//1\. 要使用LiveData物件作為資料系結來源，需要設定LifecycleOwner
binding.setLifecycleOwner(this);
ViewModelProvider viewModelProvider = new ViewModelProvider(this);
mUserViewModel = viewModelProvider.get(UserViewModel.class);
//3\. 設定變數ViewModel
binding.setVm(mUserViewModel);
xml 檔案的定義如下：
<!-- 2\. 定義ViewModel 并系結-->
<variable
name="vm"
type="com.hfy.demo01.module.jetpack.databinding.UserViewModel" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{vm.userLiveData.name}"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{vm.userLiveData.level}"/>
這樣就ok了，你會發現 我們不需要在 Activity 中拿到 LivaData 去 observe(owner，observer)了，DataBinding 自動生成的代碼，會幫我們去做這操作，所以需要設定LifecycleOwner，
使用自定義特性的雙向資料系結
例如，如果要在名為 MyView 的自定義視圖中對 "time" 特性啟用雙向資料系結，請完成以下步驟：
- 使用
@BindingAdapter，對用來設定初始值并在值更改時進行更新的方法進行注釋：
@BindingAdapter("time")
@JvmStatic fun setTime(view: MyView, newValue: Time) {
// Important to break potential infinite loops.
if (view.time != newValue) {
view.time = newValue
}
}
- 使用
@InverseBindingAdapter對從視圖中讀取值的方法進行注釋：
@InverseBindingAdapter("time")
@JvmStatic fun getTime(view: MyView) : Time {
return view.getTime()
}
更多內容請參考這里，
原始碼分析
我們在路徑app/build/intermediates/data_binding_layout_info_type_merge/debug/out/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.jackie.jetpackdemo" rootNodeType="androidx.constraintlayout.widget.ConstraintLayout">
<Variables name="userInfo" declared="true" type="TestInfo">
<location endLine="9" endOffset="29" startLine="7" startOffset="8" />
</Variables>
<Imports name="TestInfo" type="com.jackie.jetpackdemo.data.TestInfo">
<location endLine="6" endOffset="60" startLine="6" startOffset="8" />
</Imports>
<Targets>
<Target tag="layout/activity_main_0"
view="androidx.constraintlayout.widget.ConstraintLayout">
<Expressions />
<location endLine="47" endOffset="55" startLine="12" startOffset="4" />
</Target>
<Target id="@+id/txtUserName" tag="binding_1" view="TextView">
<Expressions>
<Expression attribute="android:text" text="userInfo.age">
<Location endLine="32" endOffset="41" startLine="32" startOffset="12" />
<TwoWay>false</TwoWay>
<ValueLocation endLine="32" endOffset="39" startLine="32" startOffset="28" />
</Expression>
</Expressions>
<location endLine="37" endOffset="13" startLine="27" startOffset="8" />
</Target>
<Target id="@+id/btnGetUserInfo" view="Button">
<Expressions />
<location endLine="25" endOffset="55" startLine="17" startOffset="8" />
</Target>
</Targets>
</Layout>
可以看到<Targets>標簽下面的就是我們布局，分成具體的子<Target>標簽對應具體的 ConstraintLayout、TextView等，activity_main_0 對應我們的ConstraintLayout，再來路徑app/build/intermediates/incremental/mergeDebugResources/stripped.dir/layout/activity_main.xml下
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" android:tag="layout/activity_main_0" 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">
<Button
android:id="@+id/btnGetUserInfo"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="獲取用戶資訊"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<TextView
android:id="@+id/txtUserName"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center"
android:tag="binding_1"
app:layout_constraintTop_toBottomOf="@+id/btnGetUserInfo"
android:layout_marginTop="30dp"
android:textSize="30dp"
/>
<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="text"
android:gravity="center"
app:layout_constraintTop_toBottomOf="@+id/txtUserName"
/>
</androidx.constraintlayout.widget.ConstraintLayout>
這個檔案其實就是移除了<layout>、<data>標簽的布局檔案，里面的 tag 就是我們上面對應<Target>標簽中的tag，Expression attribute="android:text" text="userInfo.age" <Expression>中的具體屬性對應具體的值，
初始化
再來從val activityBinding: ActivityMainBinding = DataBindingUtil.setContentView(this,R.layout.activity_main)來分析原始碼，
//DataBindingUtil.java
public static <T extends ViewDataBinding> T setContentView(@NonNull Activity activity,
int layoutId, @Nullable DataBindingComponent bindingComponent) {
activity.setContentView(layoutId); //還是需要setContentView
View decorView = activity.getWindow().getDecorView();
ViewGroup contentView = (ViewGroup) decorView.findViewById(android.R.id.content);
return bindToAddedViews(bindingComponent, contentView, 0, layoutId);
}
我們設定的activity_xxx.xml其實是在android.R.id.content下面的，繼續來看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;
if (childrenAdded == 1) {
final View childView = parent.getChildAt(endChildren - 1);
return bind(component, childView, layoutId); //呼叫bind
} 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); //呼叫bind
}
}
}
最侄訓調到bind方法
//DataBindingUtil.java
static <T extends ViewDataBinding> T bind(DataBindingComponent bindingComponent, View root,
int layoutId) {
return (T) sMapper.getDataBinder(bindingComponent, root, layoutId);
}
sMapper是DataBinderMapper，其真正實作類是通過 APT 生成的DataBinderMapperImpl（app/build/generated/ap_generated_sources/debug/out/com/jackie/jetpackdemo/DataBinderMapperImpl.java）
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_ACTIVITYMAIN: {
if ("layout/activity_main_0".equals(tag)) {
return new ActivityMainBindingImpl(component, view); //關鍵代碼，new ActivityMainBindingImpl
}
···
接下來我們來分析ActivityMainBindingImpl（app/build/generated/ap_generated_sources/debug/out/com/jackie/jetpackdemo/databinding/ActivityMainBindingImpl.java）這個類，它也是 APT 生成的，
//ActivityMainBindingImpl.java
public ActivityMainBindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
this(bindingComponent, root, mapBindings(bindingComponent, root, 3, sIncludes, sViewsWithIds));
}
private ActivityMainBindingImpl(androidx.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) {
super(bindingComponent, root, 1
, (android.widget.Button) bindings[2]
, (android.widget.TextView) bindings[1]
);
this.mboundView0 = (androidx.constraintlayout.widget.ConstraintLayout) bindings[0];
this.mboundView0.setTag(null);
this.txtUserName.setTag(null);
setRootTag(root);
// listeners
invalidateAll();
}
我們呼叫了第一個方法，里面的這個 3 代表著我們布局檔案中有三個節點（ConstraintLayout，Button，TextView），但是我們前面的布局中明明還有一個TextView，為什么沒有呢？因為我們這個TextView我們并沒有設定它的 Id，所以沒有生成，如果設定后重新 build 下 3 就會變成 4 了，
繼續來看mapBindings方法：
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;
}
它首先是 new 一個大小為 3 的物件陣列，然后把這三個標簽決議完放到該陣列中，上面的ActivityMainBindingImpl公有構造器會呼叫私有構造器，再回過頭來看
val activityBinding: ActivityMainBinding = DataBindingUtil.setContentView(this,R.layout.activity_main)
執行完這個代碼，activityBinding中已經有這 3 個物件了，所以可以進行這樣的呼叫
activityBinding.txtUserName
activityBinding.btnGetUserInfo
到目前為止，初始化已經完成了，
呼叫流程
接下來我們從這個呼叫開始分析
activityBinding.userInfo = TestInfo("lsm","lsj")
這個activityBinding.userInfo呼叫的實際上是ActivityMainBinding中的setUserInfo方法
//ActivityMainBinding.java
public void setUserInfo(@Nullable com.jackie.jetpackdemo.data.TestInfo UserInfo) {
updateRegistration(0, UserInfo);
this.mUserInfo = UserInfo;
synchronized(this) {
mDirtyFlags |= 0x1L;
}
notifyPropertyChanged(BR.userInfo);
super.requestRebind();
}
這里的updateRegistration方法如下
//localFieldId 為 BR 檔案中的Id，observable 就是觀察者
protected boolean updateRegistration(int localFieldId, Observable observable) {
return updateRegistration(localFieldId, observable, CREATE_PROPERTY_LISTENER);
}
/**
* 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();
}
};
CREATE_PROPERTY_LISTENER名字也很直白，表示創建一個屬性的監聽器，也就是說屬性發生變化的時候WeakPropertyListener監聽器會被回呼，
localFieldId 為 BR 檔案中的 Id，BR 檔案是什么呢？
public class BR {
public static final int _all = 0;
public static final int age = 1;
public static final int name = 2;
public static final int userInfo = 3;
}
因為我們的 xml 檔案中匯入了TestInfo(userInfo)，我們也在age和name屬性上加上了@Bindable注解，所以生成了上面的BR檔案，因為我們是上面呼叫的是setUserInfo方法，所以傳入的是 0，
用該方式設定name也可以
activityBinding.setVariable(BR.name,"Jackie")
而updateRegistration中的observable就是我們傳入的(TestInfo)UserInfo，再來看看updateRegistration方法
//ViewDataBinding
private boolean updateRegistration(int localFieldId, Object observable,
CreateWeakListener listenerCreator) {
if (observable == null) {
return unregisterFrom(localFieldId);
}
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;
}
mLocalFieldObservers陣列中系結了每一個屬性對應的監聽器，比如我們上面的 BR 中的四個值，
如果監聽器為空，呼叫registerTo創建監聽器并注冊
protected void registerTo(int localFieldId, Object observable,
CreateWeakListener listenerCreator) {
if (observable == null) {
return;
}
WeakListener listener = mLocalFieldObservers[localFieldId];
if (listener == null) {
listener = listenerCreator.create(this, localFieldId);
mLocalFieldObservers[localFieldId] = listener;
if (mLifecycleOwner != null) {
listener.setLifecycleOwner(mLifecycleOwner);
}
}
listener.setTarget(observable);
}
setTarget就是給被觀察者添加監聽器
public void setTarget(T object) {
unregister();
mTarget = object;
if (mTarget != null) {
mObservable.addListener(mTarget);
}
}
這里的mObservable的實作類是WeakPropertyListener，也就是每個屬性發生變化后都會進行回呼
@Override
public void addListener(Observable target) {
target.addOnPropertyChangedCallback(this);
}
而target的實作類是BaseObservable，這也就是我們的TestInfo為什么要繼承BaseObservable了，
public class BaseObservable implements Observable {
private transient PropertyChangeRegistry mCallbacks;
public BaseObservable() {
}
@Override
public void addOnPropertyChangedCallback(@NonNull OnPropertyChangedCallback callback) {
synchronized (this) {
if (mCallbacks == null) {
mCallbacks = new PropertyChangeRegistry();
}
}
mCallbacks.add(callback);
}
總的關系圖如下：
PropertryChangeRegistry中的add(ViewDataBinding)是將觀察者和被觀察者系結起來，ViewDataBinding中的WeakListener[] mLocalFieldObservers中的每個變數都有一個WeakListener，BaseObservable中的addOnPropertyChangedCallback(WeakPropertyListener)就是添加屬性變化回呼，
MainActivity 呼叫 setUserInfo 流程圖
如果上面的關系圖不清楚的話，我也把流程圖畫出來，你可以查看一下
ActivityMainBindingImpl繼承于ActivityMainBinding，而ActivityMainBinding繼承于ViewDataBinding
最終是在TextViewBindingAdapter中setText來實作，
@BindingAdapter("android:text")
public static void setText(TextView view, CharSequence text) {
final CharSequence oldText = view.getText();
if (text == oldText || (text == null && oldText.length() == 0)) {
return;
}
if (text instanceof Spanned) {
if (text.equals(oldText)) {
return; // No change in the spans, so don't set anything.
}
} else if (!haveContentsChanged(text, oldText)) {
return; // No content changes, so don't set anything.
}
view.setText(text);
}
沒呼叫 setUser 之前的資料系結是怎么做的？
前面我們講了初始化程序，因為ActivityMainBindingImpl繼承于ActivityMainBinding，而ActivityMainBinding繼承于ViewDataBinding，在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) {
}
};
}
}
會執行mRebindRunnable的run方法
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();
}
};
然后執行executePendingBindings方法，后面就和我們前面分析過的的流程一樣了，最侄訓會調到
@BindingAdapter("android:text")
public static void setText(TextView view, CharSequence text) {
final CharSequence oldText = view.getText();
if (text == oldText || (text == null && oldText.length() == 0)) {
return;
}
if (text instanceof Spanned) {
if (text.equals(oldText)) {
return; // No change in the spans, so don't set anything.
}
} else if (!haveContentsChanged(text, oldText)) {
return; // No content changes, so don't set anything.
}
view.setText(text);
}
我們一開始text為空，所以就直接回傳了，
為什么設計如此復雜，以前我們用的話觀察者和被觀察者都是單獨的類，現在因為可能有多個ViewModel(TestInfo、xxxInfo等)，同時也可能有多個Activity（分別進行系結），使用原來的方式消耗很大，BR 檔案會生成多個欄位，用一個mLocalFieldObservers進行處理，每個欄位有其具體的監聽，每個xxxInfo 有其具體的監聽，設計的還是挺合理的，
總結
本文先從 DataBinding 的簡單使用，單向/雙向系結，結合LiveData 使用，同時也可以使用一些自定義特性，最后是進行原始碼分析，最后一定要注意的是不要在 xml 中做復雜的邏輯判斷，只是將其看做是一個方便末端 UI 展示的支持庫即可，同時也避免了大量的判空處理，同時也統一了資料的來源，
獻給讀者
隨著互聯網企業的不斷發展，產品專案中的模塊越來越多，用戶體驗要求也越來越高，想實作小步快跑、快速迭代的目的越來越難，還有65535，應用之間的互相呼叫等等問題，插件化技術應用而生，如果沒有插件化技術，美團、淘寶這些集成了大量“app”的應用，可能會有幾個g那么大，
所以，當今的Android移動開發，不會熱修復、插件化、組件化，80%以上的面試都過不了，
Android熱修復框架、插件化框架、組件化框架、圖片加載框架、網路訪問框架、RxJava回應式編程框架、IOC依賴注入框架、最近架構組件Jetpack等等Android開源框架，系統教程知識筆記已整理成PDF電子書上傳在【GitHub】
1042頁完整版PDF點擊我就可以白嫖啦，記得給文章點個贊哦，
文末
感謝大家關注我，分享Android干貨，交流Android技術，
對文章有何見解，或者有何技術問題，都可以在評論區一起留言討論，我會虔誠為你解答，
也歡迎大家來我的B站找我玩，有各類Android架構師進階技術難點的視頻講解，助你早日升職加薪，
B站直通車：https://space.bilibili.com/544650554
轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/278108.html
標籤：其他
上一篇：Android MediaPlayer整體架構原始碼分析 -【MediaCodec編解碼器插件模塊化注冊和創建處理流程】【Part 1】