Android DataBinding 双向绑定的原理与注意事项(13)

一、Android DataBinding 双向绑定概述

1.1 双向绑定的基本概念

在传统的 Android 开发中，数据和视图的更新通常需要手动编写大量的代码。例如，当用户在 EditText 中输入内容时，需要为其设置 TextWatcher 来监听文本变化，并更新对应的数据模型；而当数据模型发生变化时，又需要手动更新 UI。这种方式不仅繁琐，还容易出错。

双向绑定（Two-Way Binding）则提供了一种更简洁、高效的方式来实现数据和视图的同步。它允许数据的变化自动更新到视图，同时视图的变化也能自动更新到数据，实现了数据和视图的双向自动同步。

在 Android DataBinding 中，双向绑定通过特殊的语法（如 @={}）来实现。例如：

<!-- activity_main.xml -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="user"
            type="com.example.databindingdemo.User" />
    </data>
    <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@={user.name}" /> <!-- 双向绑定语法 -->
</layout>

当用户在 EditText 中输入内容时，User 对象的 name 属性会自动更新；反之，当 User 对象的 name 属性发生变化时，EditText 的文本也会自动更新。

1.2 双向绑定的优势

使用 Android DataBinding 的双向绑定具有以下优势：

1. 减少样板代码：无需手动编写大量的事件监听器和数据更新代码，降低了代码复杂度。

2. 提高开发效率：双向绑定自动处理数据和视图的同步，开发者可以更专注于业务逻辑。

3. 代码更清晰：双向绑定使数据流动更加明确，代码结构更加清晰，易于维护。

4. 降低错误率：减少了手动操作，降低了因疏忽导致的数据和视图不同步的风险。

1.3 双向绑定的应用场景

双向绑定适用于以下场景：

1. 表单输入：如登录表单、注册表单等，用户输入的数据需要实时更新到数据模型。

2. 设置界面：用户对设置选项的修改需要立即反映到应用状态中。

3. 实时数据展示与编辑：如联系人信息编辑、商品信息修改等场景。

4. 需要用户交互并实时更新的场景：如滑块、开关等控件的状态与数据模型的同步。

二、DataBinding 基础架构回顾

2.1 DataBinding 组件概览

Android DataBinding 是一个支持将布局文件中的视图与应用程序中的数据绑定的框架。它主要由以下几个核心组件组成：

1. Binding 类：DataBinding 编译器为每个布局文件生成的类，负责将布局中的视图与数据绑定。

2. DataBinderMapper：负责映射布局文件与对应的 Binding 类。

3. Observable 数据类：实现了 Observable 接口的数据类，当数据发生变化时会通知观察者。

4. LiveData：一种可观察的数据持有者类，具有生命周期感知能力。

5. ViewModel：用于存储和管理与 UI 相关的数据，具有生命周期感知能力。

2.2 DataBinding 工作流程

DataBinding 的工作流程主要包括以下几个步骤：

1. 编译时处理：在编译时，DataBinding 编译器会分析布局文件，生成对应的 Binding 类。

2. 运行时初始化：在 Activity 或 Fragment 中，通过 DataBindingUtil 类加载布局并获取 Binding 实例。

3. 数据绑定：将数据模型设置到 Binding 实例中，实现数据与视图的绑定。

4. 数据更新：当数据发生变化时，通过 Observable 机制通知视图更新；当视图发生变化时，通过事件监听器更新数据。

下面是一个简单的 DataBinding 示例：

// MainActivity.java
public class MainActivity extends AppCompatActivity {
    private ActivityMainBinding binding; // 布局对应的 Binding 类

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 加载布局并获取 Binding 实例
        binding = ActivityMainBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());

        // 创建数据模型
        User user = new User("John", "Doe");

        // 设置数据模型到 Binding 实例
        binding.setUser(user);
    }
}

<!-- activity_main.xml -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="user"
            type="com.example.databindingdemo.User" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{user.firstName}" /> <!-- 单向绑定 -->
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{user.lastName}" /> <!-- 单向绑定 -->
    </LinearLayout>
</layout>

2.3 单向绑定与双向绑定的区别

在 DataBinding 中，单向绑定和双向绑定是两种不同的数据流动方式：

1. 单向绑定：数据的流动是单向的，即从数据模型到视图。当数据模型发生变化时，视图会自动更新，但视图的变化不会影响数据模型。单向绑定使用 @{} 语法。

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@{user.name}" /> <!-- 单向绑定 -->

2. 双向绑定：数据的流动是双向的，即数据模型的变化会更新视图，视图的变化也会更新数据模型。双向绑定使用 @={} 语法。

<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="@={user.name}" /> <!-- 双向绑定 -->

三、双向绑定的实现机制

3.1 双向绑定的基本原理

双向绑定的核心原理是通过事件监听和数据观察机制实现数据和视图的双向同步。具体来说：

1. 视图到数据的更新：通过为视图设置事件监听器（如 TextWatcher、OnCheckedChangeListener 等），当视图状态发生变化时，触发监听器更新数据模型。

2. 数据到视图的更新：通过让数据模型实现 Observable 接口或使用 LiveData，当数据发生变化时，通知视图更新。

在 Android DataBinding 中，双向绑定是通过特殊的 BindingAdapter 和 InverseBindingAdapter 实现的。

3.2 双向绑定的核心组件

双向绑定的核心组件包括：

1. InverseBindingAdapter：用于将视图的变化转换为数据的更新。每个支持双向绑定的属性都需要一个对应的 InverseBindingAdapter。

2. InverseBindingListener：用于监听视图属性的变化，并触发数据更新。

3. BindingAdapter：与单向绑定中的 BindingAdapter 类似，但在双向绑定中，它还需要设置 InverseBindingListener。

下面是一个双向绑定的示例代码：

// User.java
public class User extends BaseObservable {
    private String name;

    @Bindable // 标记该属性为可观察的
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        notifyPropertyChanged(BR.name); // 通知属性变化
    }
}

<!-- activity_main.xml -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="user"
            type="com.example.databindingdemo.User" />
    </data>
    <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@={user.name}" /> <!-- 双向绑定 -->
</layout>

3.3 双向绑定的实现流程

双向绑定的实现流程主要包括以下几个步骤：

1. 编译时处理：DataBinding 编译器解析布局文件中的双向绑定表达式（如 @={user.name}），生成对应的 Binding 类代码。

2. 运行时初始化：在 Binding 类的初始化过程中，设置视图属性和数据的双向绑定关系。

3. 视图到数据的绑定：通过 InverseBindingAdapter 设置视图属性变化的监听器，当视图属性变化时，触发数据更新。

4. 数据到视图的绑定：通过 BindingAdapter 设置数据变化的监听器，当数据变化时，触发视图更新。

下面我们将深入分析每个步骤的源码实现。

四、编译时处理机制

4.1 布局文件解析

在编译时，DataBinding 编译器会解析布局文件，识别其中的双向绑定表达式。解析过程主要由 LayoutFileParser 类完成。

以下是 LayoutFileParser 类的关键源码分析：

// LayoutFileParser.java (DataBinding 编译器内部类)
public class LayoutFileParser {
    // 解析布局文件
    public ProcessedResource parseResourceFile(ResourceFile resourceFile) {
        // ... 其他代码 ...
        
        // 解析布局文件中的每个标签
        for (Element element : elements) {
            // 处理布局标签
            if (isLayoutTag(element)) {
                processLayoutTag(layoutTag, layoutInfo);
            } else {
                // 处理普通视图标签
                processViewTag(element, layoutInfo);
            }
        }
        
        // ... 其他代码 ...
    }
    
    // 处理普通视图标签
    private void processViewTag(Element element, LayoutInfo layoutInfo) {
        // ... 其他代码 ...
        
        // 解析标签的属性
        NamedNodeMap attributes = element.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Node attribute = attributes.item(i);
            String attrName = attribute.getNodeName();
            String attrValue = attribute.getNodeValue();
            
            // 检查是否是双向绑定表达式
            if (isTwoWayBindingExpression(attrValue)) {
                // 处理双向绑定表达式
                processTwoWayBindingAttribute(element, attrName, attrValue, layoutInfo);
            } else {
                // 处理普通绑定表达式
                processBindingAttribute(element, attrName, attrValue, layoutInfo);
            }
        }
        
        // ... 其他代码 ...
    }
    
    // 判断是否是双向绑定表达式
    private boolean isTwoWayBindingExpression(String expression) {
        // 检查表达式是否以 @={ 开头并以 } 结尾
        return expression != null && expression.startsWith("@={") && expression.endsWith("}");
    }
    
    // 处理双向绑定属性
    private void processTwoWayBindingAttribute(Element element, String attrName, String attrValue, LayoutInfo layoutInfo) {
        // 提取双向绑定表达式中的实际表达式
        String expression = attrValue.substring(3, attrValue.length() - 1);
        
        // 解析表达式，提取变量和属性
        Expression parsedExpression = parseExpression(expression, layoutInfo);
        
        // 创建双向绑定信息
        TwoWayBinding twoWayBinding = new TwoWayBinding(attrName, parsedExpression);
        
        // 将双向绑定信息添加到布局信息中
        layoutInfo.addTwoWayBinding(element, twoWayBinding);
    }
    
    // ... 其他代码 ...
}

4.2 双向绑定代码生成

在解析完布局文件后，DataBinding 编译器会生成对应的 Binding 类代码。双向绑定的代码生成主要由 BindingClass 类完成。

以下是 BindingClass 类的关键源码分析：

// BindingClass.java (DataBinding 编译器内部类)
public class BindingClass {
    // 生成绑定类代码
    public void generateCode() {
        // ... 其他代码 ...
        
        // 生成双向绑定相关代码
        generateTwoWayBindingCode();
        
        // ... 其他代码 ...
    }
    
    // 生成双向绑定相关代码
    private void generateTwoWayBindingCode() {
        // 遍历所有双向绑定信息
        for (TwoWayBinding twoWayBinding : mTwoWayBindings) {
            // 获取双向绑定的属性名和表达式
            String attrName = twoWayBinding.getAttrName();
            Expression expression = twoWayBinding.getExpression();
            
            // 获取属性对应的 InverseBindingAdapter 方法
            Method inverseBindingAdapterMethod = findInverseBindingAdapterMethod(attrName);
            
            // 获取属性对应的 BindingAdapter 方法
            Method bindingAdapterMethod = findBindingAdapterMethod(attrName);
            
            // 生成双向绑定的初始化代码
            generateTwoWayBindingInitializationCode(attrName, expression, bindingAdapterMethod, inverseBindingAdapterMethod);
        }
    }
    
    // 生成双向绑定的初始化代码
    private void generateTwoWayBindingInitializationCode(String attrName, Expression expression, 
                                                         Method bindingAdapterMethod, Method inverseBindingAdapterMethod) {
        // ... 其他代码 ...
        
        // 生成设置 BindingAdapter 的代码
        codeGenerator.generateBindingAdapterCall(
                bindingAdapterMethod,
                viewReference,
                expression,
                inverseBindingListenerReference);
        
        // 生成设置 InverseBindingListener 的代码
        codeGenerator.generateInverseBindingListenerSetup(
                inverseBindingAdapterMethod,
                viewReference,
                expression,
                inverseBindingListenerReference);
        
        // ... 其他代码 ...
    }
    
    // ... 其他代码 ...
}

4.3 双向绑定相关类的生成

除了 Binding 类，DataBinding 编译器还会生成一些辅助类，如 BR 类（用于属性变更通知）和 BindingAdapters 类（包含各种 BindingAdapter 和 InverseBindingAdapter 方法）。

以下是 BR 类的生成源码分析：

// BR.java (DataBinding 生成的类)
public class BR {
    public static final int _all = 0;
    public static final int name = 1; // 对应 User 类的 name 属性
    public static final int age = 2;  // 对应 User 类的 age 属性
    
    // ... 其他属性 ...
}

以下是 BindingAdapters 类的部分源码分析：

// BindingAdapters.java (DataBinding 生成的类)
public class BindingAdapters {
    // EditText 的双向绑定 BindingAdapter
    @BindingAdapter(value = {"android:text", "android:textAttrChanged"}, requireAll = false)
    public static void setText(EditText view, String text, final InverseBindingListener attrChange) {
        // 获取当前文本
        String currentText = view.getText().toString();
        
        // 如果当前文本与新文本不同，则更新文本
        if (!currentText.equals(text) || (text == null && view.length() > 0)) {
            view.setText(text);
        }
        
        // 设置文本变化监听器
        TextWatcher textWatcher = new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
            
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {}
            
            @Override
            public void afterTextChanged(Editable s) {
                // 当文本变化时，触发 InverseBindingListener
                if (attrChange != null) {
                    attrChange.onChange();
                }
            }
        };
        
        // 获取并保存之前的监听器
        TextWatcher oldWatcher = ListenerUtil.trackListener(view, textWatcher, R.id.textWatcher);
        
        // 如果之前有监听器，则移除
        if (oldWatcher != null) {
            view.removeTextChangedListener(oldWatcher);
        }
        
        // 添加新的监听器
        view.addTextChangedListener(textWatcher);
    }
    
    // EditText 的双向绑定 InverseBindingAdapter
    @InverseBindingAdapter(attribute = "android:text", event = "android:textAttrChanged")
    public static String getText(EditText view) {
        return view.getText().toString();
    }
    
    // ... 其他 BindingAdapter 和 InverseBindingAdapter 方法 ...
}

五、运行时绑定机制

5.1 Binding 类的初始化

在运行时，当我们调用 DataBindingUtil.inflate() 或 DataBindingUtil.setContentView() 方法时，会创建并初始化对应的 Binding 类。

以下是 DataBindingUtil 类的关键源码分析：

// DataBindingUtil.java
public class DataBindingUtil {
    // 从布局资源加载并创建 Binding 实例
    public static <T extends ViewDataBinding> T inflate(LayoutInflater inflater,
                                                         int layoutId,
                                                         ViewGroup parent,
                                                         boolean attachToParent) {
        // 获取布局 inflater
        LayoutInflater layoutInflater = inflater.cloneInContext(inflater.getContext());
        
        // 创建 Binding 实例
        return DataBindingUtil.<T>bindToAddedViews(
                layoutInflater,
                layoutId,
                parent,
                attachToParent);
    }
    
    // 绑定到已添加的视图
    private static <T extends ViewDataBinding> T bindToAddedViews(LayoutInflater inflater,
                                                                     int layoutId,
                                                                     ViewGroup parent,
                                                                     boolean attachToParent) {
        // 获取布局文件的资源 ID
        int layoutResource = ResourceIdReader.getLayoutResource(inflater.getContext(), layoutId);
        
        // 通过反射获取布局对应的 Binding 类
        Class<? extends ViewDataBinding> bindingClass = DataBinderMapperImpl.getBindingClass(layoutResource);
        
        if (bindingClass != null) {
            try {
                // 创建 Binding 实例
                Constructor<? extends ViewDataBinding> constructor = bindingClass.getConstructor(
                        LayoutInflater.class,
                        ViewGroup.class,
                        boolean.class);
                return constructor.newInstance(inflater, parent, attachToParent);
            } catch (Exception e) {
                throw new RuntimeException("Could not instantiate binding class", e);
            }
        }
        
        // 如果没有找到 Binding 类，则使用普通的布局加载方式
        return null;
    }
    
    // ... 其他方法 ...
}

5.2 双向绑定的初始化

在 Binding 类的初始化过程中，会设置双向绑定的相关监听器。

以下是生成的 Binding 类的初始化代码分析：

// ActivityMainBinding.java (生成的 Binding 类)
public class ActivityMainBindingImpl extends ActivityMainBinding {
    // 绑定类的构造函数
    public ActivityMainBindingImpl(LayoutInflater inflater, ViewGroup root, boolean attachToParent) {
        super(inflater, root, attachToParent);
        
        // 初始化视图引用
        mBoundView0 = root;
        mEditText = findViewById(root, R.id.editText);
        
        // 初始化双向绑定
        initializeTwoWayBindings();
    }
    
    // 初始化双向绑定
    private void initializeTwoWayBindings() {
        // 获取 User 对象
        User user = mUser;
        
        // 设置 EditText 的双向绑定
        if (user != null) {
            // 获取 user.name 的值
            String user_name = user.getName();
            
            // 设置 EditText 的文本和监听器
            BindingAdapters.setText(mEditText, user_name, new InverseBindingListener() {
                @Override
                public void onChange() {
                    // 当 EditText 的文本变化时，更新 User 对象的 name 属性
                    String newValue = BindingAdapters.getText(mEditText);
                    if (mUser != null) {
                        mUser.setName(newValue);
                    }
                }
            });
        }
    }
    
    // ... 其他方法 ...
    
    // 设置 User 对象
    @Override
    public void setUser(User user) {
        mUser = user;
        synchronized (this) {
            mDirtyFlags |= 0x1L;
        }
        notifyPropertyChanged(BR.user);
        super.requestRebind();
    }
    
    // 执行绑定
    @Override
    protected void executeBindings() {
        long dirtyFlags = 0;
        synchronized (this) {
            dirtyFlags = mDirtyFlags;
            mDirtyFlags = 0;
        }
        
        User user = mUser;
        String user_name = null;
        
        // 如果 User 对象不为空，则获取 name 属性
        if ((dirtyFlags & 0x1L) != 0) {
            if (user != null) {
                user_name = user.getName();
            }
        }
        
        // 更新 EditText 的文本
        if ((dirtyFlags & 0x1L) != 0) {
            BindingAdapters.setText(mEditText, user_name, null);
        }
    }
}

5.3 数据观察机制

为了实现数据到视图的更新，DataBinding 使用了观察机制。当数据发生变化时，会通知所有观察者更新视图。

以下是 BaseObservable 类的关键源码分析：

// BaseObservable.java
public abstract class BaseObservable implements Observable {
    // 存储所有的属性变更监听器
    private transient PropertyChangeRegistry mCallbacks;
    
    // 添加属性变更监听器
    @Override
    public synchronized void addOnPropertyChangedCallback(OnPropertyChangedCallback callback) {
        if (mCallbacks == null) {
            mCallbacks = new PropertyChangeRegistry();
        }
        mCallbacks.add(callback);
    }
    
    // 移除属性变更监听器
    @Override
    public synchronized void removeOnPropertyChangedCallback(OnPropertyChangedCallback callback) {
        if (mCallbacks != null) {
            mCallbacks.remove(callback);
        }
    }
    
    // 通知所有监听器某个属性发生了变化
    public void notifyPropertyChanged(int fieldId) {
        PropertyChangeRegistry callbacks;
        synchronized (this) {
            if (mCallbacks == null) {
                return;
            }
            callbacks = mCallbacks.copy();
        }
        callbacks.notifyCallbacks(this, fieldId, null);
    }
}

以下是 PropertyChangeRegistry 类的关键源码分析：

// PropertyChangeRegistry.java
public class PropertyChangeRegistry extends
        CopyOnWriteArrayList<Observable.OnPropertyChangedCallback> {
    // 通知所有监听器属性发生了变化
    public void notifyCallbacks(Observable observable, int propertyId, Object arg) {
        // 遍历所有监听器并通知
        for (int i = size() - 1; i >= 0; i--) {
            get(i).onPropertyChanged(observable, propertyId);
        }
    }
}

六、双向绑定的核心组件

6.1 InverseBindingAdapter 解析

InverseBindingAdapter 是实现双向绑定的关键组件之一，它用于将视图的变化转换为数据的更新。

以下是 InverseBindingAdapter 注解的源码分析：

// InverseBindingAdapter.java
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InverseBindingAdapter {
    /**
     * 指定对应的属性名
     */
    String attribute();
    
    /**
     * 指定用于监听属性变化的事件
     */
    String event() default "android:attrChanged";
    
    /**
     * 指定适配器的优先级
     */
    int requireAll() default 1;
}

以下是 EditText 的 InverseBindingAdapter 方法的源码分析：

// BindingAdapters.java
@InverseBindingAdapter(attribute = "android:text", event = "android:textAttrChanged")
public static String getText(EditText view) {
    return view.getText().toString();
}

6.2 InverseBindingListener 解析

InverseBindingListener 是一个接口，用于监听视图属性的变化，并触发数据更新。

以下是 InverseBindingListener 接口的源码分析：

// InverseBindingListener.java
public interface InverseBindingListener {
    /**
     * 当视图属性发生变化时调用
     */
    void onChange();
}

在双向绑定中，InverseBindingListener 的实现通常会更新数据模型的值。

6.3 BindingAdapter 解析

在双向绑定中，BindingAdapter 不仅要设置视图的属性值，还要设置 InverseBindingListener 来监听视图属性的变化。

以下是 EditText 的双向绑定 BindingAdapter 方法的源码分析：

// BindingAdapters.java
@BindingAdapter(value = {"android:text", "android:textAttrChanged"}, requireAll = false)
public static void setText(EditText view, String text, final InverseBindingListener attrChange) {
    // 获取当前文本
    String currentText = view.getText().toString();
    
    // 如果当前文本与新文本不同，则更新文本
    if (!currentText.equals(text) || (text == null && view.length() > 0)) {
        view.setText(text);
    }
    
    // 设置文本变化监听器
    TextWatcher textWatcher = new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
        
        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {}
        
        @Override
        public void afterTextChanged(Editable s) {
            // 当文本变化时，触发 InverseBindingListener
            if (attrChange != null) {
                attrChange.onChange();
            }
        }
    };
    
    // 获取并保存之前的监听器
    TextWatcher oldWatcher = ListenerUtil.trackListener(view, textWatcher, R.id.textWatcher);
    
    // 如果之前有监听器，则移除
    if (oldWatcher != null) {
        view.removeTextChangedListener(oldWatcher);
    }
    
    // 添加新的监听器
    view.addTextChangedListener(textWatcher);
}

七、双向绑定的工作流程

7.1 视图到数据的更新流程

当用户在视图中进行操作（如在 EditText 中输入文本）时，会触发视图到数据的更新流程。

以下是视图到数据更新流程的详细步骤：

1. 用户在 EditText 中输入文本，触发 TextWatcher 的 afterTextChanged() 方法。

2. 在 afterTextChanged() 方法中，调用 InverseBindingListener 的 onChange() 方法。

// BindingAdapters.java
@Override
public void afterTextChanged(Editable s) {
    // 当文本变化时，触发 InverseBindingListener
    if (attrChange != null) {
        attrChange.onChange();
    }
}

3. InverseBindingListener 的 onChange() 方法实现中，会调用 InverseBindingAdapter 方法获取视图的当前值。

// ActivityMainBindingImpl.java
@Override
public void onChange() {
    // 当 EditText 的文本变化时，更新 User 对象的 name 属性
    String newValue = BindingAdapters.getText(mEditText);
    if (mUser != null) {
        mUser.setName(newValue);
    }
}

4. 调用数据模型的 setter 方法更新数据。

// User.java
public void setName(String name) {
    this.name = name;
    notifyPropertyChanged(BR.name); // 通知属性变化
}

7.2 数据到视图的更新流程

当数据模型发生变化时，会触发数据到视图的更新流程。

以下是数据到视图更新流程的详细步骤：

1. 数据模型的 setter 方法被调用，更新数据值。

// User.java
public void setName(String name) {
    this.name = name;
    notifyPropertyChanged(BR.name); // 通知属性变化
}

2. notifyPropertyChanged() 方法通知所有注册的监听器属性发生了变化。

// BaseObservable.java
public void notifyPropertyChanged(int fieldId) {
    PropertyChangeRegistry callbacks;
    synchronized (this) {
        if (mCallbacks == null) {
            return;
        }
        callbacks = mCallbacks.copy();
    }
    callbacks.notifyCallbacks(this, fieldId, null);
}

3. Binding 类作为监听器，收到属性变化通知后，标记为需要重新绑定。

// ActivityMainBindingImpl.java
@Override
public void onPropertyChanged(Observable sender, int propertyId) {
    synchronized (this) {
        mDirtyFlags |= 0x1L;
    }
    notifyPropertyChanged(BR.user);
    super.requestRebind();
}

4. 在下次布局更新时，执行重新绑定操作，更新视图。

// ActivityMainBindingImpl.java
@Override
protected void executeBindings() {
    long dirtyFlags = 0;
    synchronized (this) {
        dirtyFlags = mDirtyFlags;
        mDirtyFlags = 0;
    }
    
    User user = mUser;
    String user_name = null;
    
    // 如果 User 对象不为空，则获取 name 属性
    if ((dirtyFlags & 0x1L) != 0) {
        if (user != null) {
            user_name = user.getName();
        }
    }
    
    // 更新 EditText 的文本
    if ((dirtyFlags & 0x1L) != 0) {
        BindingAdapters.setText(mEditText, user_name, null);
    }
}

八、双向绑定的常见应用场景

8.1 表单输入处理

双向绑定在表单输入处理中非常有用，可以大大简化代码。

以下是一个登录表单的示例：

// LoginViewModel.java
public class LoginViewModel extends ViewModel {
    private MutableLiveData<String> username = new MutableLiveData<>("");
    private MutableLiveData<String> password = new MutableLiveData<>("");
    
    // 获取用户名
    public LiveData<String> getUsername() {
        return username;
    }
    
    // 获取密码
    public LiveData<String> getPassword() {
        return password;
    }
    
    // 设置用户名
    public void setUsername(String username) {
        this.username.setValue(username);
    }
    
    // 设置密码
    public void setPassword(String password) {
        this.password.setValue(password);
    }
    
    // 登录方法
    public void login() {
        String username = this.username.getValue();
        String password = this.password.getValue();
        
        // 执行登录逻辑
        // ...
    }
}

<!-- activity_login.xml -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.databindingdemo.LoginViewModel" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:padding="16dp">
        <EditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="用户名"
            android:text="@={viewModel.username}" />
        <EditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="密码"
            android:inputType="textPassword"
            android:text="@={viewModel.password}" />
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="登录"
            android:onClick="@{() -> viewModel.login()}" />
    </LinearLayout>
</layout>

8.2 开关控件处理

双向绑定也适用于开关控件（如 Switch、CheckBox 等）。

以下是一个开关控件的示例：

// SettingsViewModel.java
public class SettingsViewModel extends ViewModel {
    private MutableLiveData<Boolean> notificationsEnabled = new MutableLiveData<>(true);
    
    // 获取通知启用状态
    public LiveData<Boolean> getNotificationsEnabled() {
        return notificationsEnabled;
    }
    
    // 设置通知启用状态
    public void setNotificationsEnabled(Boolean enabled) {
        notificationsEnabled.setValue(enabled);
    }
    
    // 处理通知设置变化
    public void onNotificationsChanged(Boolean enabled) {
        // 保存设置
        // ...
    }
}

<!-- activity_settings.xml -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.databindingdemo.SettingsViewModel" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:padding="16dp">
        <Switch
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="启用通知"
            android:checked="@={viewModel.notificationsEnabled}"
            android:onCheckedChanged="@{(buttonView, isChecked) -> viewModel.onNotificationsChanged(isChecked)}" />
    </LinearLayout>
</layout>

8.3 滑块控件处理

双向绑定还适用于滑块控件（如 SeekBar）。

以下是一个滑块控件的示例：

// SeekBarViewModel.java
public class SeekBarViewModel extends ViewModel {
    private MutableLiveData<Integer> progress = new MutableLiveData<>(50);
    
    // 获取进度
    public LiveData<Integer> getProgress() {
        return progress;
    }
    
    // 设置进度
    public void setProgress(Integer progress) {
        this.progress.setValue(progress);
    }
    
    // 处理进度变化
    public void onProgressChanged(Integer progress) {
        // 处理进度变化
        // ...
    }
}

<!-- activity_seekbar.xml -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.databindingdemo.SeekBarViewModel" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:padding="16dp">
        <SeekBar
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:max="100"
            android:progress="@={viewModel.progress}"
            android:onProgressChanged="@{(seekBar, progress, fromUser) -> viewModel.onProgressChanged(progress)}" />
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{String.valueOf(viewModel.progress)}" />
    </LinearLayout>
</layout>

九、双向绑定的性能优化

9.1 减少不必要的更新

双向绑定可能会导致一些不必要的更新，特别是在数据频繁变化的情况下。可以通过以下方式减少不必要的更新：

1. 使用 equals() 方法比较数据：在 setter 方法中，先比较新值与旧值是否相同，只有不同时才更新数据并通知变化。

// User.java
private String name;

public void setName(String name) {
    if (!Objects.equals(this.name, name)) { // 比较新旧值
        this.name = name;
        notifyPropertyChanged(BR.name);
    }
}

2. 使用防抖机制：对于频繁变化的数据（如输入框的文本变化），可以使用防抖机制，只在用户停止输入一段时间后才更新数据。

9.2 优化 BindingAdapter 和 InverseBindingAdapter

优化 BindingAdapter 和 InverseBindingAdapter 可以提高双向绑定的性能：

1. 避免在 BindingAdapter 中执行耗时操作：BindingAdapter 应该只负责设置视图属性，避免执行耗时操作。

2. 重用监听器：避免在每次绑定过程中创建新的监听器，可以使用 ListenerUtil.trackListener() 方法重用监听器。

// BindingAdapters.java
@BindingAdapter(value = {"android:text", "android:textAttrChanged"}, requireAll = false)
public static void setText(EditText view, String text, final InverseBindingListener attrChange) {
    // ... 其他代码 ...
    
    // 设置文本变化监听器
    TextWatcher textWatcher = new TextWatcher() {
        // ... 监听器实现 ...
    };
    
    // 重用监听器
    TextWatcher oldWatcher = ListenerUtil.trackListener(view, textWatcher, R.id.textWatcher);
    
    // ... 其他代码 ...
}

9.3 使用合适的数据结构

选择合适的数据结构可以提高双向绑定的性能：

1. 使用 ObservableField 代替 BaseObservable：对于简单的数据模型，可以使用 ObservableField 代替 BaseObservable，减少样板代码。

// User.java
public class User {
    public final ObservableField<String> name = new ObservableField<>();
    public final ObservableField<Integer> age = new ObservableField<>();
}

2. 使用 LiveData 或 ObservableCollection：对于集合数据，使用 LiveData 或 ObservableCollection 可以更高效地处理数据变化。

// ViewModel.java
public class MyViewModel extends ViewModel {
    private MutableLiveData<List<Item>> itemList = new MutableLiveData<>();
    
    public LiveData<List<Item>> getItemList() {
        return itemList;
    }
    
    public void addItem(Item item) {
        List<Item> items = itemList.getValue();
        if (items == null) {
            items = new ArrayList<>();
        }
        items.add(item);
        itemList.setValue(items);
    }
}

十、双向绑定的常见问题与解决方案

10.1 无限循环问题

双向绑定可能会导致无限循环问题，即数据变化触发视图更新，视图更新又触发数据变化，如此循环。

解决方案：

1. 在 setter 方法中检查值是否变化：只有当值确实发生变化时才通知更新。

// User.java
private String name;

public void setName(String name) {
    if (!Objects.equals(this.name, name)) {
        this.name = name;
        notifyPropertyChanged(BR.name);
    }
}

2. 使用标志位控制更新：在更新视图时设置一个标志位，避免在视图更新过程中触发数据更新。

10.2 空指针异常问题

双向绑定可能会导致空指针异常，特别是在数据模型为空的情况下。

解决方案：

1. 在布局文件中设置默认值：使用 Elvis 操作符（?:）设置默认值。

<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="@={user.name ?: ``}" /> <!-- 设置默认空字符串 -->

2. 在代码中检查空值：在访问数据模型之前，先检查是否为空。

// ActivityMainBindingImpl.java
@Override
protected void executeBindings() {
    // ... 其他代码 ...
    
    User user = mUser;
    String user_name = null;
    
    // 检查 user 是否为空
    if ((dirtyFlags & 0x1L) != 0) {
        if (user != null) {
            user_name = user.getName();
        }
    }
    
    // ... 其他代码 ...
}

10.3 自定义视图的双向绑定问题

对于自定义视图，实现双向绑定可能会遇到一些问题。

解决方案：

1. 为自定义视图添加 BindingAdapter 和 InverseBindingAdapter：为自定义视图的属性添加相应的 BindingAdapter 和 InverseBindingAdapter。

// CustomViewBindingAdapters.java
public class CustomViewBindingAdapters {
    @BindingAdapter("customValue")
    public static void setCustomValue(CustomView view, int value) {
        if (view.getValue() != value) {
            view.setValue(value);
        }
    }
    
    @InverseBindingAdapter(attribute = "customValue", event = "customValueAttrChanged")
    public static int getCustomValue(CustomView view) {
        return view.getValue();
    }
    
    @BindingAdapter("customValueAttrChanged")
    public static void setCustomValueListener(CustomView view, final InverseBindingListener listener) {
        if (listener != null) {
            view.setOnValueChangedListener(new CustomView.OnValueChangedListener() {
                @Override
                public void onValueChanged(int value) {
                    listener.onChange();
                }
            });
        }
    }
}

2. 在自定义视图中提供属性变更事件：自定义视图需要提供属性变更事件，以便双向绑定能够监听属性变化。

// CustomView.java
public class CustomView extends View {
    private int value;
    private OnValueChangedListener listener;
    
    public interface OnValueChangedListener {
        void onValueChanged(int value);
    }
    
    public void setOnValueChangedListener(OnValueChangedListener listener) {
        this.listener = listener;
    }
    
    public int getValue() {
        return value;
    }
    
    public void setValue(int value) {
        if (this.value != value) {
            this.value = value;
            if (listener != null) {
                listener.onValueChanged(value);
            }
        }
    }
    
    // ... 其他代码 ...
}

十一、双向绑定的最佳实践

11.1 保持数据模型简单

保持数据模型简单，避免过度复杂的嵌套结构。数据模型应该只包含与 UI 相关的数据和业务逻辑。

11.2 使用 ViewModel 管理数据

使用 ViewModel 管理与 UI 相关的数据，ViewModel 具有生命周期感知能力，可以避免内存泄漏。

// MyViewModel.java
public class MyViewModel extends ViewModel {
    private MutableLiveData<String> username = new MutableLiveData<>();
    private MutableLiveData<String> password = new MutableLiveData<>();
    
    // 获取用户名
    public LiveData<String> getUsername() {
        return username;
    }
    
    // 获取密码
    public LiveData<String> getPassword() {
        return password;
    }
    
    // 登录方法
    public void login() {
        // 执行登录逻辑
        // ...
    }
}

11.3 使用合适的 Observable 类型

根据实际需求选择合适的 Observable 类型：

1. BaseObservable：适用于复杂的数据模型，需要手动管理属性变更通知。

2. ObservableField：适用于简单的数据模型，无需手动管理属性变更通知。

3. LiveData：具有生命周期感知能力，适用于与 UI 相关的数据。

11.4 避免在布局文件中编写复杂逻辑

避免在布局文件中编写复杂的逻辑，布局文件应该只负责数据绑定，复杂的逻辑应该放在 ViewModel 或其他业务类中。

11.5 合理使用双向绑定

双向绑定虽然方便，但不应该滥用。对于只需要单向数据流动的场景，使用单向绑定即可。

11.6 编写单元测试

编写单元测试确保双向绑定的正确性，测试数据变化是否能正确更新视图，视图变化是否能正确更新数据。

// ViewModelTest.java
@RunWith(AndroidJUnit4.class)
public class ViewModelTest {
    @Test
    public void testUsernameChange() {
        MyViewModel viewModel = new MyViewModel();
        MutableLiveData<String> username = viewModel.getUsername();
        
        // 设置用户名
        viewModel.setUsername("testuser");
        
        // 验证用户名是否正确更新
        assertEquals("testuser", username.getValue());
    }
    
    @Test
    public void testViewToDataUpdate() {
        MyViewModel viewModel = new MyViewModel();
        MutableLiveData<String> username = viewModel.getUsername();
        
        // 模拟视图更新
        // ...
        
        // 验证数据是否正确更新
        assertEquals("newusername", username.getValue());
    }
}

十二、双向绑定的高级技巧

12.1 自定义双向绑定属性

除了使用 Android 提供的双向绑定属性，还可以自定义双向绑定属性。

以下是一个自定义双向绑定属性的示例：

// CustomBindingAdapters.java
public class CustomBindingAdapters {
    @BindingAdapter(value = {"customText", "customTextAttrChanged"}, requireAll = false)
    public static void setCustomText(TextView view, String text, final InverseBindingListener listener) {
        // 设置文本
        view.setText(text);
        
        // 设置文本变化监听器
        view.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
            
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {}
            
            @Override
            public void afterTextChanged(Editable s) {
                // 文本变化时通知
                if (listener != null) {
                    listener.onChange();
                }
            }
        });
    }
    
    @InverseBindingAdapter(attribute = "customText", event = "customTextAttrChanged")
    public static String getCustomText(TextView view) {
        return view.getText().toString();
    }
}

在布局文件中使用自定义双向绑定属性：

<TextView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:customText="@={viewModel.customText}" />

12.2 双向绑定与自定义视图

对于自定义视图，实现双向绑定需要提供相应的 BindingAdapter 和 InverseBindingAdapter。

以下是一个自定义开关视图的双向绑定示例：

// CustomSwitch.java
public class CustomSwitch extends View {
    private boolean isChecked;
    private OnCheckedChangeListener listener;
    
    public interface OnCheckedChangeListener {
        void onCheckedChanged(CustomSwitch view, boolean isChecked);
    }
    
    public CustomSwitch(Context context) {
        super(context);
        init();
    }
    
    public CustomSwitch(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }
    
    private void init() {
        // 初始化视图
        setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                toggle();
            }
        });
    }
    
    public boolean isChecked() {
        return isChecked;
    }
    
    public void setChecked(boolean checked) {
        if (isChecked != checked) {
            isChecked = checked;
            invalidate();
            if (listener != null) {
                listener.onCheckedChanged(this, isChecked);
            }
        }
    }
    
    public void toggle() {
        setChecked(!isChecked);
    }
    
    public void setOnCheckedChangeListener(OnCheckedChangeListener listener) {
        this.listener = listener;
    }
    
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 绘制开关
        // ...
    }
}

为自定义开关视图添加双向绑定支持：

// CustomSwitchBindingAdapters.java
public class CustomSwitchBindingAdapters {
    @BindingAdapter("checked")
    public static void setChecked(CustomSwitch view, boolean checked) {
        if (view.isChecked() != checked) {
            view.setChecked(checked);
        }
    }
    
    @InverseBindingAdapter(attribute = "checked", event = "checkedAttrChanged")
    public static boolean isChecked(CustomSwitch view) {
        return view.isChecked();
    }
    
    @BindingAdapter("checkedAttrChanged")
    public static void setCheckedChangeListener(CustomSwitch view, final InverseBindingListener listener) {
        view.setOnCheckedChangeListener(new CustomSwitch.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CustomSwitch view, boolean isChecked) {
                listener.onChange();
            }
        });
    }
}

在布局文件中使用自定义开关视图的双向绑定：

<com.example.databindingdemo.CustomSwitch
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:checked="@={viewModel.isSwitchOn}" />

12.3 双向绑定与集合数据

双向绑定也可以应用于集合数据，例如 ListView、RecyclerView 等。

以下是一个使用双向绑定的 RecyclerView 示例：

// Item.java
public class Item extends BaseObservable {
    private String name;
    private boolean selected;
    
    @Bindable
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
        notifyPropertyChanged(BR.name);
    }
    
    @Bindable
    public boolean isSelected() {
        return selected;
    }
    
    public void setSelected(boolean selected) {
        this.selected = selected;
        notifyPropertyChanged(BR.selected);
    }
}

// ItemAdapter.java
public class ItemAdapter extends RecyclerView.Adapter<ItemAdapter.ItemViewHolder> {
    private List<Item> items = new ArrayList<>();
    
    public void setItems(List<Item> items) {
        this.items = items;
        notifyDataSetChanged();
    }
    
    @NonNull
    @Override
    public ItemViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        LayoutInflater inflater = LayoutInflater.from(parent.getContext());
        ItemBinding binding = ItemBinding.inflate(inflater, parent, false);
        return new ItemViewHolder(binding);
    }
    
    @Override
    public void onBindViewHolder(@NonNull ItemViewHolder holder, int position) {
        Item item = items.get(position);
        holder.binding.setItem(item);
        holder.binding.executePendingBindings();
    }
    
    @Override
    public int getItemCount() {
        return items.size();
    }
    
    public static class ItemViewHolder extends RecyclerView.ViewHolder {
        private ItemBinding binding;
        
        public ItemViewHolder(@NonNull ItemBinding binding) {
            super(binding.getRoot());
            this.binding = binding;
        }
    }
}

<!-- item.xml -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="item"
            type="com.example.databindingdemo.Item" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:padding="8dp">
        <CheckBox
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:checked="@={item.selected}" />
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{item.name}"
            android:layout_marginStart="8dp" />
    </LinearLayout>
</layout>

十三、双向绑定的性能分析

13.1 性能测试方法

为了分析双向绑定的性能，可以使用以下方法：

1. Android Profiler：使用 Android Profiler 监控应用的 CPU、内存和 UI 性能。

2. TraceView：使用 TraceView 分析方法执行时间和调用栈。

3. 自定义性能测试：编写自定义性能测试代码，测量特定操作的执行时间。

13.2 双向绑定的性能特点

双向绑定的性能特点包括：

1. 初始绑定开销：双向绑定的初始绑定过程会有一定的开销，主要来自于 Binding 类的初始化和监听器的设置。

2. 数据更新开销：每次数据更新时，需要通过 Observable 机制通知所有监听器，可能会有一定的开销。

3. 视图更新开销：视图更新需要遍历视图树，可能会有一定的开销，特别是在视图层级较深的情况下。

13.3 性能优化建议

基于双向绑定的性能特点，可以提出以下优化建议：

1. 减少不必要的绑定：只绑定需要的属性，避免不必要的绑定。

2. 优化布局结构：减少视图层级，使用扁平的布局结构，提高视图更新效率。

3. 批量更新数据：对于频繁的数据更新，可以考虑批量更新，减少通知次数。

4. 使用合适的数据结构：选择合适的数据结构，提高数据处理效率。

5. 避免在绑定表达式中执行复杂操作：绑定表达式应该尽量简单，避免执行复杂操作。

十四、双向绑定的替代方案

14.1 手动实现双向绑定

除了使用 DataBinding 的双向绑定，还可以手动实现双向绑定。

以下是一个手动实现双向绑定的示例：

// ManualBindingActivity.java
public class ManualBindingActivity extends AppCompatActivity {
    private EditText editText;
    private TextView textView;
    private User user;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_manual_binding);
        
        // 初始化视图
        editText = findViewById(R.id.editText);
        textView = findViewById(R.id.textView);
        
        // 初始化数据模型
        user = new User("John");
        
        // 设置文本变化监听器（视图到数据）
        editText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
            
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {}
            
            @Override
            public void afterTextChanged(Editable s) {
                user.setName(s.toString());
            }
        });
        
        // 设置数据变化监听器（数据到视图）
        user.addOnPropertyChangedCallback(new Observable.OnPropertyChangedCallback() {
            @Override
            public void onPropertyChanged(Observable sender, int propertyId) {
                if (propertyId == BR.name) {
                    textView.setText(user.getName());
                }
            }
        });
        
        // 初始更新视图
        textView.setText(user.getName());
    }
}

14.2 使用 RxJava 实现双向绑定

使用 RxJava 也可以实现双向绑定。

以下是一个使用 RxJava 实现双向绑定的示例：

// RxJavaBindingActivity.java
public class RxJavaBindingActivity extends AppCompatActivity {
    private EditText editText;
    private TextView textView;
    private BehaviorSubject<String> nameSubject = BehaviorSubject.create();
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rxjava_binding);
        
        // 初始化视图
        editText = findViewById(R.id.editText);
        textView = findViewById(R.id.textView);
        
        // 视图到数据的绑定
        RxTextView.textChanges(editText)
                .map(CharSequence::toString)
                .subscribe(nameSubject);
        
        // 数据到视图的绑定
        nameSubject.subscribe(text -> {
            // 避免无限循环
            if (!text.equals(editText.getText().toString())) {
                editText.setText(text);
            }
            textView.setText(text);
        });
        
        // 初始化数据
        nameSubject.onNext("John");
    }
}

14.3 使用 LiveData 和 ViewModel 实现双向绑定

使用 LiveData 和 ViewModel 也可以实现双向绑定。

以下是一个使用 LiveData 和 ViewModel 实现双向绑定的示例：

// LiveDataViewModelBindingActivity.java
public class LiveDataViewModelBindingActivity extends AppCompatActivity {
    private ActivityLiveDataViewModelBinding binding;
    private MyViewModel viewModel;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        // 数据绑定
        binding = ActivityLiveDataViewModelBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());
        
        // 获取 ViewModel
        viewModel = new ViewModelProvider(this).get(MyViewModel.class);
        
        // 数据到视图的绑定
        viewModel.getName().observe(this, name -> {
            // 避免无限循环
            if (!name.equals(binding.editText.getText().toString())) {
                binding.editText.setText(name);
            }
            binding.textView.setText(name);
        });
        
        // 视图到数据的绑定
        binding.editText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
            
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {}
            
            @Override
            public void afterTextChanged(Editable s) {
                viewModel.setName(s.toString());
            }
        });
        
        // 初始化数据
        viewModel.setName("John");
    }
}

// MyViewModel.java
public class MyViewModel extends ViewModel {
    private MutableLiveData<String> name = new MutableLiveData<>();
    
    public LiveData<String> getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name.setValue(name);
    }
}