// 启用DataBinding的build.gradle配置
android {...dataBinding {enabled = true}
}

<!-- 简单的数据绑定示例 -->
<layout xmlns:android="http://schemas.android.com/apk/res/android"><data><variablename="user"type="com.example.User" /></data><LinearLayoutandroid:layout_width="match_parent"android:layout_height="match_parent"><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{user.name}" /> <!-- 绑定到user对象的name属性 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{String.valueOf(user.age)}" /> <!-- 绑定到user对象的age属性 --></LinearLayout>
</layout>

// Observable接口定义
public interface Observable {// 添加属性变化回调void addOnPropertyChangedCallback(OnPropertyChangedCallback callback);// 移除属性变化回调void removeOnPropertyChangedCallback(OnPropertyChangedCallback callback);// 属性变化回调接口abstract class OnPropertyChangedCallback {// 当属性发生变化时调用public abstract void onPropertyChanged(Observable sender, int propertyId);}
}

// BaseObservable类实现
public abstract class BaseObservable implements Observable {// 存储所有注册的属性变化回调private transient PropertyChangeRegistry mCallbacks;@Overridepublic void addOnPropertyChangedCallback(OnPropertyChangedCallback callback) {synchronized (this) {if (mCallbacks == null) {mCallbacks = new PropertyChangeRegistry();}}mCallbacks.add(callback); // 添加回调到注册表}@Overridepublic void removeOnPropertyChangedCallback(OnPropertyChangedCallback callback) {synchronized (this) {if (mCallbacks == null) {return;}}mCallbacks.remove(callback); // 从注册表移除回调}// 通知所有注册的回调某个属性已更改public void notifyPropertyChanged(int fieldId) {synchronized (this) {if (mCallbacks == null) {return;}}mCallbacks.notifyCallbacks(this, fieldId, null); // 通知所有回调}// 通知所有属性已更改public void notifyChange() {synchronized (this) {if (mCallbacks == null) {return;}}mCallbacks.notifyCallbacks(this, BR._all, null); // 通知所有属性}
}

// ObservableField类定义
public class ObservableField<T> extends BaseObservable implements Parcelable {private T mValue; // 存储字段的值// 构造方法public ObservableField(T value) {mValue = value;}// 获取字段的值public T get() {return mValue;}// 设置字段的值，并通知变化public void set(T value) {if (value != mValue) {mValue = value;notifyChange(); // 通知所有观察者值已变化}}// Parcelable相关实现...
}

// ObservableCollection接口定义
public interface ObservableCollection {// 添加集合变化回调void addOnCollectionChangedCallback(OnCollectionChangedCallback callback);// 移除集合变化回调void removeOnCollectionChangedCallback(OnCollectionChangedCallback callback);// 集合变化回调接口interface OnCollectionChangedCallback {// 当集合内容发生变化时调用void onChanged(ObservableCollection collection);// 当集合中项被添加时调用void onItemRangeInserted(ObservableCollection collection, int positionStart, int itemCount);// 当集合中项被移除时调用void onItemRangeRemoved(ObservableCollection collection, int positionStart, int itemCount);// 当集合中项被移动时调用void onItemRangeMoved(ObservableCollection collection, int fromPosition, int toPosition, int itemCount);// 当集合中项被修改时调用void onItemRangeChanged(ObservableCollection collection, int positionStart, int itemCount);}
}

// 布局文件解析器的简化实现
public class LayoutFileParser {// 解析布局文件，提取数据绑定信息public BindingInfo parseLayoutFile(File layoutFile) throws XmlPullParserException, IOException {BindingInfo bindingInfo = new BindingInfo();// 创建XML解析器XmlPullParser parser = Xml.newPullParser();parser.setInput(new FileInputStream(layoutFile), null);int eventType = parser.getEventType();while (eventType != XmlPullParser.END_DOCUMENT) {if (eventType == XmlPullParser.START_TAG) {// 处理标签if (parser.getName().equals("layout")) {// 处理layout标签parseLayoutTag(parser, bindingInfo);} else if (parser.getName().equals("data")) {// 处理data标签parseDataTag(parser, bindingInfo);} else {// 处理普通视图标签parseViewTag(parser, bindingInfo);}}eventType = parser.next();}return bindingInfo;}// 解析layout标签private void parseLayoutTag(XmlPullParser parser, BindingInfo bindingInfo) {// 处理layout标签的属性for (int i = 0; i < parser.getAttributeCount(); i++) {String attrName = parser.getAttributeName(i);String attrValue = parser.getAttributeValue(i);// 处理属性...}}// 解析data标签private void parseDataTag(XmlPullParser parser, BindingInfo bindingInfo) throws XmlPullParserException, IOException {int eventType = parser.getEventType();while (eventType != XmlPullParser.END_TAG || !parser.getName().equals("data")) {if (eventType == XmlPullParser.START_TAG) {if (parser.getName().equals("variable")) {// 解析variable标签parseVariableTag(parser, bindingInfo);} else if (parser.getName().equals("import")) {// 解析import标签parseImportTag(parser, bindingInfo);}}eventType = parser.next();}}// 解析variable标签private void parseVariableTag(XmlPullParser parser, BindingInfo bindingInfo) {String name = parser.getAttributeValue(null, "name");String type = parser.getAttributeValue(null, "type");// 创建变量信息对象VariableInfo variableInfo = new VariableInfo();variableInfo.setName(name);variableInfo.setType(type);// 添加到绑定信息中bindingInfo.addVariable(variableInfo);}// 解析import标签private void parseImportTag(XmlPullParser parser, BindingInfo bindingInfo) {String type = parser.getAttributeValue(null, "type");String alias = parser.getAttributeValue(null, "alias");// 创建导入信息对象ImportInfo importInfo = new ImportInfo();importInfo.setType(type);importInfo.setAlias(alias);// 添加到绑定信息中bindingInfo.addImport(importInfo);}// 解析普通视图标签private void parseViewTag(XmlPullParser parser, BindingInfo bindingInfo) {String tagName = parser.getName();int id = parser.getIdAttributeResourceValue(-1);// 创建视图信息对象ViewInfo viewInfo = new ViewInfo();viewInfo.setTagName(tagName);viewInfo.setId(id);// 处理视图的属性for (int i = 0; i < parser.getAttributeCount(); i++) {String attrNamespace = parser.getAttributeNamespace(i);String attrName = parser.getAttributeName(i);String attrValue = parser.getAttributeValue(i);// 检查是否是数据绑定表达式if (attrValue.startsWith("@{") && attrValue.endsWith("}")) {// 提取表达式内容String expression = attrValue.substring(2, attrValue.length() - 1);// 创建属性绑定信息AttributeBinding attributeBinding = new AttributeBinding();attributeBinding.setNamespace(attrNamespace);attributeBinding.setName(attrName);attributeBinding.setExpression(expression);// 添加到视图信息中viewInfo.addAttributeBinding(attributeBinding);}}// 添加到绑定信息中bindingInfo.addView(viewInfo);}
}

// 表达式解析器的简化实现
public class ExpressionParser {// 解析表达式public Expression parseExpression(String expression) {// 移除首尾空格expression = expression.trim();// 检查表达式类型if (expression.startsWith("\"") && expression.endsWith("\"")) {// 字符串字面量return new StringLiteralExpression(expression.substring(1, expression.length() - 1));} else if (expression.matches("\\d+")) {// 整数字面量return new IntegerLiteralExpression(Integer.parseInt(expression));} else if (expression.matches("\\d+\\.\\d+")) {// 浮点数字面量return new FloatLiteralExpression(Float.parseFloat(expression));} else if (expression.equals("true") || expression.equals("false")) {// 布尔字面量return new BooleanLiteralExpression(Boolean.parseBoolean(expression));} else if (expression.contains(".")) {// 属性访问表达式return parsePropertyAccessExpression(expression);} else if (expression.contains("(") && expression.endsWith(")")) {// 方法调用表达式return parseMethodCallExpression(expression);} else {// 变量引用表达式return new VariableReferenceExpression(expression);}}// 解析属性访问表达式private Expression parsePropertyAccessExpression(String expression) {String[] parts = expression.split("\\.");if (parts.length == 1) {// 简单变量引用return new VariableReferenceExpression(parts[0]);} else {// 属性访问链PropertyAccessExpression propertyAccess = new PropertyAccessExpression();propertyAccess.setBaseExpression(new VariableReferenceExpression(parts[0]));List<String> propertyChain = new ArrayList<>();for (int i = 1; i < parts.length; i++) {propertyChain.add(parts[i]);}propertyAccess.setPropertyChain(propertyChain);return propertyAccess;}}// 解析方法调用表达式private Expression parseMethodCallExpression(String expression) {// 找到方法名和参数部分int openParenIndex = expression.indexOf("(");String methodName = expression.substring(0, openParenIndex);String argumentsString = expression.substring(openParenIndex + 1, expression.length() - 1);// 解析参数List<Expression> arguments = new ArrayList<>();if (!argumentsString.trim().isEmpty()) {String[] argStrings = argumentsString.split(",");for (String argString : argStrings) {arguments.add(parseExpression(argString.trim()));}}// 创建方法调用表达式MethodCallExpression methodCall = new MethodCallExpression();methodCall.setMethodName(methodName);methodCall.setArguments(arguments);return methodCall;}
}

// 绑定类生成器的简化实现
public class BindingClassGenerator {// 生成绑定类public void generateBindingClass(BindingInfo bindingInfo, File outputDir) throws IOException {String packageName = bindingInfo.getPackageName();String className = bindingInfo.getClassName();// 创建Java文件File javaFile = new File(outputDir, className.replace('.', '/') + ".java");javaFile.getParentFile().mkdirs();javaFile.createNewFile();// 创建输出流try (BufferedWriter writer = new BufferedWriter(new FileWriter(javaFile))) {// 写入包声明writer.write("package " + packageName + ";\n\n");// 写入导入语句writeImports(writer, bindingInfo);// 写入类声明writer.write("public class " + className + " extends ViewDataBinding {\n\n");// 写入成员变量writeMemberVariables(writer, bindingInfo);// 写入构造方法writeConstructor(writer, bindingInfo);// 写入设置变量的方法writeSetVariableMethods(writer, bindingInfo);// 写入执行绑定的方法writeExecuteBindingsMethod(writer, bindingInfo);// 写入结束括号writer.write("}\n");}}// 写入导入语句private void writeImports(BufferedWriter writer, BindingInfo bindingInfo) throws IOException {// 写入必要的导入writer.write("import android.view.View;\n");writer.write("import androidx.databinding.Bindable;\n");writer.write("import androidx.databinding.DataBindingUtil;\n");writer.write("import androidx.databinding.ViewDataBinding;\n");// 写入布局文件中声明的导入for (ImportInfo importInfo : bindingInfo.getImports()) {writer.write("import " + importInfo.getType() + ";\n");}writer.write("\n");}// 写入成员变量private void writeMemberVariables(BufferedWriter writer, BindingInfo bindingInfo) throws IOException {// 写入视图引用for (ViewInfo viewInfo : bindingInfo.getViews()) {writer.write("    @NonNull\n");writer.write("    public final " + viewInfo.getTagName() + " " + viewInfo.getIdName() + ";\n");}// 写入变量引用for (VariableInfo variableInfo : bindingInfo.getVariables()) {writer.write("    @Nullable\n");writer.write("    private " + variableInfo.getType() + " " + variableInfo.getName() + ";\n");}writer.write("\n");}// 写入构造方法private void writeConstructor(BufferedWriter writer, BindingInfo bindingInfo) throws IOException {writer.write("    public " + bindingInfo.getClassName() + "(@NonNull View root) {\n");writer.write("        super(root);\n");// 初始化视图引用for (ViewInfo viewInfo : bindingInfo.getViews()) {writer.write("        this." + viewInfo.getIdName() + " = findViewById(root, " + viewInfo.getId() + ");\n");}writer.write("    }\n\n");}// 写入设置变量的方法private void writeSetVariableMethods(BufferedWriter writer, BindingInfo bindingInfo) throws IOException {// 写入setVariable方法writer.write("    @Override\n");writer.write("    public boolean setVariable(int variableId, @Nullable Object variable) {\n");writer.write("        switch (variableId) {\n");for (VariableInfo variableInfo : bindingInfo.getVariables()) {writer.write("            case " + getVariableId(variableInfo) + ":\n");writer.write("                this." + variableInfo.getName() + " = (" + variableInfo.getType() + ") variable;\n");writer.write("                return true;\n");}writer.write("            default:\n");writer.write("                return false;\n");writer.write("        }\n");writer.write("    }\n\n");// 为每个变量写入单独的setter方法for (VariableInfo variableInfo : bindingInfo.getVariables()) {writer.write("    public void set" + capitalize(variableInfo.getName()) + "(@Nullable " + variableInfo.getType() + " " + variableInfo.getName() + ") {\n");writer.write("        this." + variableInfo.getName() + " = " + variableInfo.getName() + ";\n");writer.write("        invalidateAll();\n");writer.write("    }\n\n");}}// 写入执行绑定的方法private void writeExecuteBindingsMethod(BufferedWriter writer, BindingInfo bindingInfo) throws IOException {writer.write("    @Override\n");writer.write("    protected void executeBindings() {\n");// 获取所有变量for (VariableInfo variableInfo : bindingInfo.getVariables()) {writer.write("        " + variableInfo.getType() + " " + variableInfo.getName() + "Value = " + variableInfo.getName() + ";\n");}writer.write("\n");// 处理每个视图的绑定for (ViewInfo viewInfo : bindingInfo.getViews()) {for (AttributeBinding attributeBinding : viewInfo.getAttributeBindings()) {// 生成绑定代码writer.write("        // " + viewInfo.getIdName() + "." + attributeBinding.getName() + "\n");writer.write("        " + generateBindingCode(viewInfo, attributeBinding) + "\n");}}writer.write("    }\n\n");}// 生成绑定代码private String generateBindingCode(ViewInfo viewInfo, AttributeBinding attributeBinding) {// 简化实现：在实际代码中，这里会生成更复杂的绑定代码return "// Binding code for " + viewInfo.getIdName() + "." + attributeBinding.getName();}// 获取变量IDprivate String getVariableId(VariableInfo variableInfo) {// 简化实现：在实际代码中，这里会使用BR类中的常量return "BR." + variableInfo.getName();}// 首字母大写private String capitalize(String s) {if (s == null || s.isEmpty()) {return s;}return Character.toUpperCase(s.charAt(0)) + s.substring(1);}
}

// 绑定类初始化过程
public class MainActivity extends AppCompatActivity {private ActivityMainBinding binding;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);// 使用DataBindingUtil.inflate方法创建绑定类实例binding = DataBindingUtil.inflate(getLayoutInflater(),R.layout.activity_main,null,false);// 设置ContentView为绑定类的根视图setContentView(binding.getRoot());// 设置数据源User user = new User("John Doe", 30);binding.setUser(user); // 调用生成的setter方法}
}

// 数据变化通知流程
public class User extends BaseObservable {private String name;private int age;// 构造方法public User(String name, int age) {this.name = name;this.age = age;}// 获取name属性@Bindablepublic String getName() {return name;}// 设置name属性，并通知变化public void setName(String name) {this.name = name;notifyPropertyChanged(BR.name); // 通知name属性已变化}// 获取age属性@Bindablepublic int getAge() {return age;}// 设置age属性，并通知变化public void setAge(int age) {this.age = age;notifyPropertyChanged(BR.age); // 通知age属性已变化}
}

// UI更新过程
public class ActivityMainBinding extends ViewDataBinding {@NonNullprivate final LinearLayout rootView;@NonNullpublic final TextView textViewName;@NonNullpublic final TextView textViewAge;@Nullableprivate User mUser;  // 数据源对象// 构造方法public ActivityMainBinding(@NonNull View root) {super(root);this.rootView = (LinearLayout) root;this.textViewName = findViewById(root, R.id.textViewName);this.textViewAge = findViewById(root, R.id.textViewAge);}// 设置User对象public void setUser(@Nullable User user) {mUser = user;invalidateAll();  // 标记所有绑定需要重新计算}// 执行绑定操作@Overrideprotected void executeBindings() {User userValue = mUser;String nameValue = null;String ageValue = null;if (userValue != null) {// 获取最新的属性值nameValue = userValue.getName();ageValue = String.valueOf(userValue.getAge());}// 更新视图textViewName.setText(nameValue);textViewAge.setText(ageValue);}
}

// LiveData类定义
public abstract class LiveData<T> {// 添加观察者public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {// 检查生命周期状态if (owner.getLifecycle().getCurrentState() == DESTROYED) {// 已经销毁，直接返回return;}// 创建包装后的观察者LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);// 存储观察者ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);// 处理已存在的观察者if (existing != null && !existing.isAttachedTo(owner)) {throw new IllegalArgumentException("Cannot add the same observer"+ " with different lifecycles");}if (existing != null) {return;}// 绑定到生命周期owner.getLifecycle().addObserver(wrapper);}// 设置值（主线程）protected void setValue(T value) {assertMainThread("setValue");mVersion++;mData = value;dispatchingValue(null);}// 发布值（后台线程）protected void postValue(T value) {boolean postTask;synchronized (mDataLock) {postTask = mPendingData == NOT_SET;mPendingData = value;}if (!postTask) {return;}ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);}// 分发值给观察者private void dispatchingValue(@Nullable ObserverWrapper initiator) {if (mDispatchingValue) {mDispatchInvalidated = true;return;}mDispatchingValue = true;do {mDispatchInvalidated = false;if (initiator != null) {considerNotify(initiator);initiator = null;} else {for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {considerNotify(iterator.next().getValue());if (mDispatchInvalidated) {break;}}}} while (mDispatchInvalidated);mDispatchingValue = false;}// 考虑通知观察者private void considerNotify(ObserverWrapper observer) {if (!observer.mActive) {return;}// 检查生命周期状态if (!observer.shouldBeActive()) {observer.activeStateChanged(false);return;}// 检查版本if (observer.mLastVersion >= mVersion) {return;}// 更新版本observer.mLastVersion = mVersion;// 调用观察者的onChanged方法observer.mObserver.onChanged((T) mData);}// 观察者包装类private abstract class ObserverWrapper {final Observer<? super T> mObserver;boolean mActive;int mLastVersion = START_VERSION;ObserverWrapper(Observer<? super T> observer) {mObserver = observer;}abstract boolean shouldBeActive();boolean isAttachedTo(LifecycleOwner owner) {return false;}void detachObserver() {}void activeStateChanged(boolean newActive) {if (newActive == mActive) {return;}// 更改活动状态mActive = newActive;// 计算活动观察者数量boolean wasInactive = LiveData.this.mActiveCount == 0;LiveData.this.mActiveCount += mActive ? 1 : -1;// 处理首次活动和不再活动的情况if (wasInactive && mActive) {onActive();}if (LiveData.this.mActiveCount == 0 && !mActive) {onInactive();}if (mActive) {dispatchingValue(this);}}}// 生命周期绑定的观察者class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {@NonNullfinal LifecycleOwner mOwner;LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {super(observer);mOwner = owner;}@Overrideboolean shouldBeActive() {return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);}@Overridepublic void onStateChanged(@NonNull LifecycleOwner source,@NonNull Lifecycle.Event event) {if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {removeObserver(mObserver);return;}activeStateChanged(shouldBeActive());}@Overrideboolean isAttachedTo(LifecycleOwner owner) {return mOwner == owner;}@Overridevoid detachObserver() {mOwner.getLifecycle().removeObserver(this);}}
}

// ViewModel类
public class UserViewModel extends ViewModel {private MutableLiveData<User> userLiveData = new MutableLiveData<>();public UserViewModel() {// 初始化用户数据User user = new User("John Doe", 30);userLiveData.setValue(user);}// 获取用户LiveDatapublic LiveData<User> getUser() {return userLiveData;}// 更新用户年龄public void incrementAge() {User user = userLiveData.getValue();if (user != null) {user.setAge(user.getAge() + 1);userLiveData.setValue(user);}}
}

<!-- 布局文件 -->
<layout xmlns:android="http://schemas.android.com/apk/res/android"><data><variablename="viewModel"type="com.example.UserViewModel" /></data><LinearLayoutandroid:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{viewModel.user.name}" /> <!-- 绑定到LiveData中的name属性 --><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@{String.valueOf(viewModel.user.age)}" /> <!-- 绑定到LiveData中的age属性 --><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Increment Age"android:onClick="@{() -> viewModel.incrementAge()}" /></LinearLayout>
</layout>

// Activity类
public class MainActivity extends AppCompatActivity {private ActivityMainBinding binding;private UserViewModel viewModel;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);// 创建ViewModelviewModel = new ViewModelProvider(this).get(UserViewModel.class);// 创建DataBindingbinding = DataBindingUtil.setContentView(this, R.layout.activity_main);// 设置ViewModel到DataBindingbinding.setViewModel(viewModel);// 设置生命周期所有者，使DataBinding能够观察LiveDatabinding.setLifecycleOwner(this);}
}

// LiveData到UI的更新流程
public class ActivityMainBindingImpl extends ActivityMainBinding {// 用于存储LiveData的观察者private InverseBindingListener mViewModelUserAgeAttrChanged;// 构造方法public ActivityMainBindingImpl(@NonNull ViewDataBinding parent, View root) {super(parent, root);// 初始化LiveData的观察者mViewModelUserAgeAttrChanged = new InverseBindingListener() {@Overridepublic void onChange() {// 当age属性变化时，获取新值Integer viewModelUserAge = mViewModel.getUser().getValue().getAge();// 更新UIupdateRegistration(0, viewModelUserAge);}};}// 执行绑定操作@Overrideprotected void executeBindings() {// 获取LiveData的值User viewModelUser = mViewModel.getUser().getValue();String viewModelUserName = null;Integer viewModelUserAge = null;if (viewModelUser != null) {// 获取用户属性值viewModelUserName = viewModelUser.getName();viewModelUserAge = viewModelUser.getAge();}// 更新UIthis.textViewName.setText(viewModelUserName);this.textViewAge.setText(String.valueOf(viewModelUserAge));}// 注册更新private void updateRegistration(int localFieldId, Object object) {// 移除之前的观察者if (mRegistrationMap.containsKey(localFieldId)) {LiveData<?> oldLiveData = (LiveData<?>) mRegistrationMap.get(localFieldId);oldLiveData.removeObserver(mLocalFieldObservers.get(localFieldId));}// 添加新的观察者LiveData<?> liveData = (LiveData<?>) object;if (liveData != null) {Observer<Object> observer = mLocalFieldObservers.get(localFieldId);if (observer == null) {observer = new Observer<Object>() {@Overridepublic void onChanged(Object o) {// 当LiveData的值变化时，触发重新绑定requestRebind();}};mLocalFieldObservers.put(localFieldId, observer);}liveData.observe(mLifecycleOwner, observer);mRegistrationMap.put(localFieldId, liveData);}}
}

// ObservableCollection接口
public interface ObservableCollection<T> extends Collection<T> {// 添加集合变化监听器void addOnCollectionChangedListener(OnCollectionChangedListener listener);// 移除集合变化监听器void removeOnCollectionChangedListener(OnCollectionChangedListener listener);// 集合变化监听器接口interface OnCollectionChangedListener {// 当集合内容发生变化时调用void onCollectionChanged(ObservableCollection<?> collection);// 当集合中项被添加时调用void onItemRangeInserted(ObservableCollection<?> collection, int positionStart, int itemCount);// 当集合中项被移除时调用void onItemRangeRemoved(ObservableCollection<?> collection, int positionStart, int itemCount);// 当集合中项被修改时调用void onItemRangeChanged(ObservableCollection<?> collection, int positionStart, int itemCount);}
}

// ObservableArrayList实现
public class ObservableArrayList<E> extends ArrayList<E> implements ObservableCollection<E> {// 存储所有注册的监听器private transient List<OnCollectionChangedListener> mListeners = new ArrayList<>();// 添加集合变化监听器@Overridepublic void addOnCollection

// ObservableArrayList实现
public class ObservableArrayList<E> extends ArrayList<E> implements ObservableCollection<E> {// 存储所有注册的监听器private transient List<OnCollectionChangedListener> mListeners = new ArrayList<>();// 添加集合变化监听器@Overridepublic void addOnCollectionChangedListener(OnCollectionChangedListener listener) {mListeners.add(listener); // 将监听器添加到列表中}// 移除集合变化监听器@Overridepublic void removeOnCollectionChangedListener(OnCollectionChangedListener listener) {mListeners.remove(listener); // 从列表中移除监听器}// 通知所有监听器集合已变化private void notifyCollectionChanged() {for (OnCollectionChangedListener listener : mListeners) {listener.onCollectionChanged(this); // 调用监听器的回调方法}}// 通知所有监听器项已插入private void notifyItemRangeInserted(int positionStart, int itemCount) {for (OnCollectionChangedListener listener : mListeners) {listener.onItemRangeInserted(this, positionStart, itemCount); // 调用监听器的项插入回调}}// 通知所有监听器项已移除private void notifyItemRangeRemoved(int positionStart, int itemCount) {for (OnCollectionChangedListener listener : mListeners) {listener.onItemRangeRemoved(this, positionStart, itemCount); // 调用监听器的项移除回调}}// 通知所有监听器项已更改private void notifyItemRangeChanged(int positionStart, int itemCount) {for (OnCollectionChangedListener listener : mListeners) {listener.onItemRangeChanged(this, positionStart, itemCount); // 调用监听器的项更改回调}}// 重写add方法，添加项并通知变化@Overridepublic boolean add(E e) {boolean result = super.add(e);if (result) {notifyItemRangeInserted(size() - 1, 1); // 通知插入了一个项}return result;}// 重写add方法，在指定位置添加项并通知变化@Overridepublic void add(int index, E element) {super.add(index, element);notifyItemRangeInserted(index, 1); // 通知在指定位置插入了一个项}// 重写addAll方法，添加多个项并通知变化@Overridepublic boolean addAll(Collection<? extends E> c) {int startPosition = size();boolean result = super.addAll(c);if (result) {notifyItemRangeInserted(startPosition, c.size()); // 通知插入了多个项}return result;}// 重写addAll方法，在指定位置添加多个项并通知变化@Overridepublic boolean addAll(int index, Collection<? extends E> c) {boolean result = super.addAll(index, c);if (result) {notifyItemRangeInserted(index, c.size()); // 通知在指定位置插入了多个项}return result;}// 重写remove方法，移除项并通知变化@Overridepublic E remove(int index) {E result = super.remove(index);notifyItemRangeRemoved(index, 1); // 通知移除了一个项return result;}// 重写remove方法，移除指定对象并通知变化@Overridepublic boolean remove(Object o) {int index = indexOf(o);if (index >= 0) {remove(index);return true;}return false;}// 重写removeAll方法，移除多个项并通知变化@Overridepublic boolean removeAll(Collection<?> c) {// 简化实现：在实际代码中，这里会更精确地计算移除的范围boolean result = super.removeAll(c);if (result) {notifyCollectionChanged(); // 通知集合已变化}return result;}// 重写set方法，替换项并通知变化@Overridepublic E set(int index, E element) {E result = super.set(index, element);notifyItemRangeChanged(index, 1); // 通知一个项已更改return result;}// 重写clear方法，清空集合并通知变化@Overridepublic void clear() {int size = size();super.clear();if (size > 0) {notifyItemRangeRemoved(0, size); // 通知移除了多个项}}
}

// ViewModel类
public class UserViewModel extends ViewModel {private ObservableArrayList<User> userList = new ObservableArrayList<>();public UserViewModel() {// 初始化用户列表userList.add(new User("John Doe", 30));userList.add(new User("Jane Smith", 25));userList.add(new User("Bob Johnson", 35));}// 获取用户列表public ObservableArrayList<User> getUserList() {return userList;}// 添加新用户public void addUser() {User newUser = new User("New User", 20);userList.add(newUser); // 添加用户到列表，会触发通知}// 更新第一个用户的年龄public void updateFirstUserAge() {if (!userList.isEmpty()) {User user = userList.get(0);user.setAge(user.getAge() + 1); // 更新用户年龄，会触发通知}}
}

<!-- 布局文件 -->
<layout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.android.com/apk/res-auto"><data><variablename="viewModel"type="com.example.UserViewModel" /></data><LinearLayoutandroid:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"><androidx.recyclerview.widget.RecyclerViewandroid:layout_width="match_parent"android:layout_height="0dp"android:layout_weight="1"app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"app:adapter="@{viewModel.userList}" /> <!-- 绑定到ObservableArrayList --><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Add User"android:onClick="@{() -> viewModel.addUser()}" /><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Update First User Age"android:onClick="@{() -> viewModel.updateFirstUserAge()}" /></LinearLayout>
</layout>

// RecyclerView适配器
public class UserAdapter extends RecyclerView.Adapter<UserAdapter.UserViewHolder> implements ObservableCollection.OnCollectionChangedListener {private ObservableArrayList<User> userList;public UserAdapter(ObservableArrayList<User> userList) {this.userList = userList;userList.addOnCollectionChangedListener(this); // 注册集合变化监听器}@NonNull@Overridepublic UserViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {// 创建ViewHolderItemUserBinding binding = ItemUserBinding.inflate(LayoutInflater.from(parent.getContext()), parent, false);return new UserViewHolder(binding);}@Overridepublic void onBindViewHolder(@NonNull UserViewHolder holder, int position) {// 绑定数据到ViewHolderUser user = userList.get(position);holder.binding.setUser(user);holder.binding.executePendingBindings();}@Overridepublic int getItemCount() {return userList.size();}// 集合变化回调@Overridepublic void onCollectionChanged(ObservableCollection<?> collection) {notifyDataSetChanged(); // 通知适配器数据已全部变化}// 项插入回调@Overridepublic void onItemRangeInserted(ObservableCollection<?> collection, int positionStart, int itemCount) {notifyItemRangeInserted(positionStart, itemCount); // 通知插入了新项}// 项移除回调@Overridepublic void onItemRangeRemoved(ObservableCollection<?> collection, int positionStart, int itemCount) {notifyItemRangeRemoved(positionStart, itemCount); // 通知移除了项}// 项更改回调@Overridepublic void onItemRangeChanged(ObservableCollection<?> collection, int positionStart, int itemCount) {notifyItemRangeChanged(positionStart, itemCount); // 通知项已更改}// ViewHolder类public static class UserViewHolder extends RecyclerView.ViewHolder {private ItemUserBinding binding;public UserViewHolder(@NonNull ItemUserBinding binding) {super(binding.getRoot());this.binding = binding;}}
}

// UserDiffCallback类，用于计算新旧数据集的差异
public class UserDiffCallback extends DiffUtil.Callback {private List<User> oldList;private List<User> newList;public UserDiffCallback(List<User> oldList, List<User> newList) {this.oldList = oldList;this.newList = newList;}@Overridepublic int getOldListSize() {return oldList.size();}@Overridepublic int getNewListSize() {return newList.size();}@Overridepublic boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {// 判断是否是同一个项return oldList.get(oldItemPosition).getId() == newList.get(newItemPosition).getId();}@Overridepublic boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {// 判断项的内容是否相同User oldUser = oldList.get(oldItemPosition);User newUser = newList.get(newItemPosition);return oldUser.getName().equals(newUser.getName()) &&oldUser.getAge() == newUser.getAge();}@Nullable@Overridepublic Object getChangePayload(int oldItemPosition, int newItemPosition) {// 获取变化的有效负载User oldUser = oldList.get(oldItemPosition);User newUser = newList.get(newItemPosition);Bundle diffBundle = new Bundle();if (!oldUser.getName().equals(newUser.getName())) {diffBundle.putString("name", newUser.getName());}if (oldUser.getAge() != newUser.getAge()) {diffBundle.putInt("age", newUser.getAge());}if (diffBundle.size() == 0) {return null;}return diffBundle;}
}

// 优化后的UserAdapter
public class UserAdapter extends RecyclerView.Adapter<UserAdapter.UserViewHolder> implements ObservableCollection.OnCollectionChangedListener {private ObservableArrayList<User> userList;public UserAdapter(ObservableArrayList<User> userList) {this.userList = userList;userList.addOnCollectionChangedListener(this); // 注册集合变化监听器setHasStableIds(true); // 启用稳定的ID，提高性能}@NonNull@Overridepublic UserViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {// 创建ViewHolderItemUserBinding binding = ItemUserBinding.inflate(LayoutInflater.from(parent.getContext()), parent, false);return new UserViewHolder(binding);}@Overridepublic void onBindViewHolder(@NonNull UserViewHolder holder, int position) {// 绑定数据到ViewHolderUser user = userList.get(position);holder.binding.setUser(user);holder.binding.executePendingBindings();}@Overridepublic void onBindViewHolder(@NonNull UserViewHolder holder, int position, @NonNull List<Object> payloads) {if (payloads.isEmpty()) {// 没有有效负载，进行完整绑定onBindViewHolder(holder, position);} else {// 有有效负载，只更新变化的部分Bundle payload = (Bundle) payloads.get(0);User user = userList.get(position);if (payload.containsKey("name")) {holder.binding.textViewName.setText(payload.getString("name"));}if (payload.containsKey("age")) {holder.binding.textViewAge.setText(String.valueOf(payload.getInt("age")));}}}@Overridepublic int getItemCount() {return userList.size();}@Overridepublic long getItemId(int position) {// 返回项的唯一ID，提高性能return userList.get(position).getId();}// 集合变化回调@Overridepublic void onCollectionChanged(ObservableCollection<?> collection) {// 使用DiffUtil计算差异并更新List<User> oldList = new ArrayList<>(userList);List<User> newList = new ArrayList<>(userList);DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new UserDiffCallback(oldList, newList));diffResult.dispatchUpdatesTo(this);}// 项插入回调@Overridepublic void onItemRangeInserted(ObservableCollection<?> collection, int positionStart, int itemCount) {notifyItemRangeInserted(positionStart, itemCount);}// 项移除回调@Overridepublic void onItemRangeRemoved(ObservableCollection<?> collection, int positionStart, int itemCount) {notifyItemRangeRemoved(positionStart, itemCount);}// 项更改回调@Overridepublic void onItemRangeChanged(ObservableCollection<?> collection, int positionStart, int itemCount) {// 使用DiffUtil计算差异并更新List<User> oldList = new ArrayList<>(userList);List<User> newList = new ArrayList<>(userList);DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new UserDiffCallback(oldList, newList));diffResult.dispatchUpdatesTo(this);}// ViewHolder类public static class UserViewHolder extends RecyclerView.ViewHolder {private ItemUserBinding binding;public UserViewHolder(@NonNull ItemUserBinding binding) {super(binding.getRoot());this.binding = binding;}}
}

// 使用ListAdapter的UserAdapter
public class UserAdapter extends ListAdapter<User, UserAdapter.UserViewHolder> {// 创建DiffUtil.ItemCallback实例private static final DiffUtil.ItemCallback<User> DIFF_CALLBACK = new DiffUtil.ItemCallback<User>() {@Overridepublic boolean areItemsTheSame(@NonNull User oldItem, @NonNull User newItem) {return oldItem.getId() == newItem.getId();}@Overridepublic boolean areContentsTheSame(@NonNull User oldItem, @NonNull User newItem) {return oldItem.getName().equals(newItem.getName()) &&oldItem.getAge() == newItem.getAge();}};public UserAdapter() {super(DIFF_CALLBACK);}@NonNull@Overridepublic UserViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {// 创建ViewHolderItemUserBinding binding = ItemUserBinding.inflate(LayoutInflater.from(parent.getContext()), parent, false);return new UserViewHolder(binding);}@Overridepublic void onBindViewHolder(@NonNull UserViewHolder holder, int position) {// 绑定数据到ViewHolderUser user = getItem(position);holder.binding.setUser(user);holder.binding.executePendingBindings();}// ViewHolder类public static class UserViewHolder extends RecyclerView.ViewHolder {private ItemUserBinding binding;public UserViewHolder(@NonNull ItemUserBinding binding) {super(binding.getRoot());this.binding = binding;}}
}

// 在ViewModel中使用ListAdapter
public class UserViewModel extends ViewModel {private MutableLiveData<List<User>> userListLiveData = new MutableLiveData<>();private UserAdapter adapter = new UserAdapter();public UserViewModel() {// 初始化用户列表List<User> userList = new ArrayList<>();userList.add(new User("John Doe", 30));userList.add(new User("Jane Smith", 25));userList.add(new User("Bob Johnson", 35));userListLiveData.setValue(userList);// 观察用户列表变化userListLiveData.observeForever(new Observer<List<User>>() {@Overridepublic void onChanged(List<User> users) {adapter.submitList(users); // 更新适配器数据}});}// 获取适配器public UserAdapter getAdapter() {return adapter;}// 添加新用户public void addUser() {List<User> currentList = userListLiveData.getValue();List<User> newList = new ArrayList<>(currentList);newList.add(new User("New User", 20));userListLiveData.setValue(newList);}// 更新第一个用户的年龄public void updateFirstUserAge() {List<User> currentList = userListLiveData.getValue();if (!currentList.isEmpty()) {List<User> newList = new ArrayList<>(currentList);User user = newList.get(0);User updatedUser = new User(user.getId(), user.getName(), user.getAge() + 1);newList.set(0, updatedUser);userListLiveData.setValue(newList);}}
}

// 优化数据类，避免不必要的通知
public class User extends BaseObservable {private String name;private int age;private boolean isPremium;// 构造方法public User(String name, int age) {this.name = name;this.age = age;}// 获取name属性@Bindablepublic String getName() {return name;}// 设置name属性，仅在值不同时通知变化public void setName(String name) {if (!Objects.equals(this.name, name)) {this.name = name;notifyPropertyChanged(BR.name);}}// 获取age属性@Bindablepublic int getAge() {return age;}// 设置age属性，仅在值不同时通知变化public void setAge(int age) {if (this.age != age) {this.age = age;notifyPropertyChanged(BR.age);}}// 获取isPremium属性@Bindablepublic boolean isPremium() {return isPremium;}// 设置isPremium属性，仅在值不同时通知变化public void setPremium(boolean premium) {if (isPremium != premium) {isPremium = premium;notifyPropertyChanged(BR.premium);}}
}

// 使用合并更新的ViewModel
public class UserViewModel extends ViewModel {private MutableLiveData<User> userLiveData = new MutableLiveData<>();private Handler handler = new Handler(Looper.getMainLooper());private Runnable updateRunnable;private User pendingUser;public UserViewModel() {// 初始化用户数据User user = new User("John Doe", 30);userLiveData.setValue(user);}// 获取用户LiveDatapublic LiveData<User> getUser() {return userLiveData;}// 批量更新用户信息public void updateUserInfo(String name, int age, boolean isPremium) {// 获取当前用户User currentUser = userLiveData.getValue();// 创建新用户对象User newUser = new User(name, age);newUser.setPremium(isPremium);// 设置待更新的用户pendingUser = newUser;// 如果已经有一个更新任务在排队，移除它if (updateRunnable != null) {handler.removeCallbacks(updateRunnable);}// 创建新的更新任务，延迟执行以合并更新updateRunnable = new Runnable() {@Overridepublic void run() {// 更新LiveDatauserLiveData.setValue(pendingUser);updateRunnable = null;}};// 延迟100ms执行更新，合并短时间内的多次更新handler.postDelayed(updateRunnable, 100);}
}

// 使用BR类常量通知属性变化
public class User extends BaseObservable {private String name;private int age;// 获取name属性@Bindablepublic String getName() {return name;}// 设置name属性并通知变化public void setName(String name) {this.name = name;notifyPropertyChanged(BR.name); // 使用BR类常量}// 获取age属性@Bindablepublic int getAge() {return age;}// 设置age属性并通知变化public void setAge(int age) {this.age = age;notifyPropertyChanged(BR.age); // 使用BR类常量}
}

// 正确实现Observable接口
public class User extends BaseObservable {private String name;// 获取name属性@Bindablepublic String getName() {return name;}// 设置name属性并通知变化public void setName(String name) {this.name = name;notifyPropertyChanged(BR.name); // 确保调用通知方法}
}

// 错误示例：避免这样做
public class User extends BaseObservable {private String name;private Activity activity; // 不要持有Activity引用，会导致内存泄漏public User(String name, Activity activity) {this.name = name;this.activity = activity;}// 其他方法...
}// 正确示例：使用弱引用
public class User extends BaseObservable {private String name;private WeakReference<Activity> activityWeakReference; // 使用弱引用public User(String name, Activity activity) {this.name = name;this.activityWeakReference = new WeakReference<>(activity);}// 其他方法...
}

// 使用DiffUtil解决RecyclerView更新闪烁问题
public class UserAdapter extends ListAdapter<User, UserAdapter.UserViewHolder> {// 创建DiffUtil.ItemCallback实例private static final DiffUtil.ItemCallback<User> DIFF_CALLBACK = new DiffUtil.ItemCallback<User>() {@Overridepublic boolean areItemsTheSame(@NonNull User oldItem, @NonNull User newItem) {return oldItem.getId() == newItem.getId();}@Overridepublic boolean areContentsTheSame(@NonNull User oldItem, @NonNull User newItem) {return oldItem.getName().equals(newItem.getName()) &&oldItem.getAge() == newItem.getAge();}};public UserAdapter() {super(DIFF_CALLBACK);}// 其他方法...
}

// 使用Paging库处理大型数据集
public class UserViewModel extends ViewModel {private Pager<Integer, User> pager;private LiveData<PagingData<User>> userPagingData;public UserViewModel() {// 创建PagingConfigPagingConfig pagingConfig = new PagingConfig(20,  // 每页显示的数量10,  // 预加载数量false,  // 是否启用占位符50   // 初始加载数量);// 创建Pagerpager = new Pager<>(pagingConfig, () -> new UserPagingSource());// 获取PagingData的LiveDatauserPagingData = pager.flow.cachedIn(viewModelScope).asLiveData();}// 获取用户PagingData的LiveDatapublic LiveData<PagingData<User>> getUserPagingData() {return userPagingData;}
}