Android Room 框架表现层源码深度分析(三)

一、引言

在 Android 应用开发中，表现层（Presentation Layer）扮演着至关重要的脚色，它负责将数据以直观、友好的方式展示给用户，并处理用户的交互操作。Android Room 框架作为一个强大的数据库抽象层，为数据的长期化和访问提供了便利。而表现层与 Room 框架的结合，可以或许实现数据的实时更新和高效展示。
本文将深入分析 Android Room 框架在表现层的应用和实现原理，从源码级别详细分析表现层中与 Room 相关的各个组件和流程。通过对源码的解读，我们可以更好地明白如何在表现层中合理运用 Room 框架，以及如何构建高效、美观的用户界面。
二、表现层概述

2.1 表现层的职责

表现层的重要职责是将数据以可视化的方式呈现给用户，并处理用户的交互事件。具体来说，表现层的职责包括：

• 数据展示：将从数据层获取的数据以符合的 UI 组件（如列表、卡片、图表等）展示给用户。
  
• 用户交互处理：处理用户的点击、滑动、输入等交互事件，并根据用户的操作更新 UI 或触发相应的业务逻辑。
  
• UI 状态管理：管理 UI 的状态，如加载状态、错误状态、空数据状态等，以提供良好的用户体验。
  

2.2 表现层与其他层的关系

在范例的 Android 架构中，表现层位于领域层之上，它从领域层获取数据，并将用户的交互反馈通报给领域层。同时，表现层还负责与 Android 体系的 UI 框架进行交互，如使用 Activity、Fragment、View 等组件来构建界面。
2.3 Room 框架在表现层的作用

Room 框架为表现层提供了数据的来源。表现层可以通过 Room 的 DAO（Data Access Object）接口获取数据库中的数据，并将其展示在 UI 上。同时，Room 的 LiveData 支持使得表现层可以或许实时响应数据的变化，自动更新 UI。
三、表现层中的数据展示

3.1 使用 RecyclerView 展示数据

RecyclerView 是 Android 中常用的用于展示列表数据的组件。结合 Room 框架，我们可以实现数据的实时更新和高效展示。
java

1. // 定义 RecyclerView 的 Adapter
2. import android.view.LayoutInflater;
3. import android.view.View;
4. import android.view.ViewGroup;
5. import android.widget.TextView;
6. import androidx.annotation.NonNull;
7. import androidx.recyclerview.widget.RecyclerView;
8. import java.util.List;
10. // 该 Adapter 用于将 User 数据绑定到 RecyclerView 的每个 Item 上
11. public class UserAdapter extends RecyclerView.Adapter<UserAdapter.UserViewHolder> {
12.     private List<User> userList;
14.     // 构造函数，接收用户数据列表
15.     public UserAdapter(List<User> userList) {
16.         this.userList = userList;
17.     }
19.     // 创建 ViewHolder
20.     @NonNull
21.     @Override
22.     public UserViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
23.         // 加载 Item 的布局文件
24.         View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_user, parent, false);
25.         return new UserViewHolder(view);
26.     }
28.     // 绑定数据到 ViewHolder
29.     @Override
30.     public void onBindViewHolder(@NonNull UserViewHolder holder, int position) {
31.         // 获取当前位置的用户数据
32.         User user = userList.get(position);
33.         // 将用户数据显示在 TextView 上
34.         holder.textViewName.setText(user.getName());
35.         holder.textViewAge.setText(String.valueOf(user.getAge()));
36.     }
38.     // 获取数据项的数量
39.     @Override
40.     public int getItemCount() {
41.         return userList != null ? userList.size() : 0;
42.     }
44.     // 更新数据列表并刷新 Adapter
45.     public void setUserList(List<User> userList) {
46.         this.userList = userList;
47.         notifyDataSetChanged();
48.     }
50.     // 定义 ViewHolder 类
51.     static class UserViewHolder extends RecyclerView.ViewHolder {
52.         TextView textViewName;
53.         TextView textViewAge;
55.         // 构造函数，初始化 ViewHolder 中的视图组件
56.         UserViewHolder(@NonNull View itemView) {
57.             super(itemView);
58.             textViewName = itemView.findViewById(R.id.textViewName);
59.             textViewAge = itemView.findViewById(R.id.textViewAge);
60.         }
61.     }
62. }

复制代码

java

1. // 在 Activity 中使用 RecyclerView 展示数据
2. import androidx.appcompat.app.AppCompatActivity;
3. import androidx.lifecycle.Observer;
4. import androidx.lifecycle.ViewModelProvider;
5. import androidx.recyclerview.widget.LinearLayoutManager;
6. import androidx.recyclerview.widget.RecyclerView;
7. import android.os.Bundle;
8. import java.util.List;
10. // 该 Activity 用于展示用户列表
11. public class UserListActivity extends AppCompatActivity {
12.     private RecyclerView recyclerView;
13.     private UserAdapter userAdapter;
14.     private UserViewModel userViewModel;
16.     @Override
17.     protected void onCreate(Bundle savedInstanceState) {
18.         super.onCreate(savedInstanceState);
19.         setContentView(R.layout.activity_user_list);
21.         // 初始化 RecyclerView
22.         recyclerView = findViewById(R.id.recyclerView);
23.         recyclerView.setLayoutManager(new LinearLayoutManager(this));
24.         userAdapter = new UserAdapter(null);
25.         recyclerView.setAdapter(userAdapter);
27.         // 获取 ViewModel 实例
28.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
30.         // 观察 LiveData 数据的变化
31.         userViewModel.getAllUsers().observe(this, new Observer<List<User>>() {
32.             @Override
33.             public void onChanged(List<User> users) {
34.                 // 当数据发生变化时，更新 Adapter 中的数据并刷新界面
35.                 userAdapter.setUserList(users);
36.             }
37.         });
38.     }
39. }

复制代码

3.2 源码分析

从源码的角度来看，UserAdapter 类继续自 RecyclerView.Adapter，负责将 User 数据绑定到 RecyclerView 的每个 Item 上。UserListActivity 类中，我们使用 ViewModel 获取 LiveData 类型的用户数据，并通过 observe 方法监听数据的变化。当数据发生变化时，Observer 的 onChanged 方法会被调用，我们在该方法中更新 Adapter 中的数据并革新界面。
3.3 使用 LiveData 实现数据的实时更新

LiveData 是 Android 架构组件中的一个可观察的数据持有者类，它具有生命周期感知能力，可以或许在 Activity 或 Fragment 的生命周期内自动管理数据的更新。
java

1. // 定义 UserViewModel
2. import androidx.lifecycle.LiveData;
3. import androidx.lifecycle.ViewModel;
4. import java.util.List;
6. // 该 ViewModel 用于管理用户数据
7. public class UserViewModel extends ViewModel {
8.     private UserRepository userRepository;
9.     private LiveData<List<User>> allUsers;
11.     // 构造函数，初始化 UserRepository 并获取所有用户数据
12.     public UserViewModel() {
13.         userRepository = new UserRepository();
14.         allUsers = userRepository.getAllUsers();
15.     }
17.     // 获取所有用户数据的 LiveData 对象
18.     public LiveData<List<User>> getAllUsers() {
19.         return allUsers;
20.     }
21. }

复制代码

java

1. // 定义 UserRepository
2. import androidx.lifecycle.LiveData;
3. import java.util.List;
5. // 该 Repository 用于与数据层交互，获取用户数据
6. public class UserRepository {
7.     private UserDao userDao;
9.     // 构造函数，初始化 UserDao
10.     public UserRepository() {
11.         AppDatabase appDatabase = AppDatabase.getDatabase();
12.         userDao = appDatabase.userDao();
13.     }
15.     // 获取所有用户数据的 LiveData 对象
16.     public LiveData<List<User>> getAllUsers() {
17.         return userDao.getAllUsers();
18.     }
19. }

复制代码

java

1. // 定义 UserDao
2. import androidx.lifecycle.LiveData;
3. import androidx.room.Dao;
4. import androidx.room.Query;
5. import java.util.List;
7. // 该 DAO 接口定义了与用户数据相关的数据库操作方法
8. @Dao
9. public interface UserDao {
10.     // 查询所有用户数据，并返回 LiveData 类型的结果
11.     @Query("SELECT * FROM user")
12.     LiveData<List<User>> getAllUsers();
13. }

复制代码

3.4 源码分析

在 UserViewModel 中，我们通过 UserRepository 获取 LiveData 类型的用户数据。UserRepository 负责与数据层交互，调用 UserDao 的 getAllUsers 方法。UserDao 是 Room 框架的 DAO 接口，使用 @Query 注解界说了查询所有用户数据的 SQL 语句，并返回 LiveData 类型的结果。当数据库中的数据发生变化时，LiveData 会自动通知所有的观察者，从而实现数据的实时更新。
四、表现层中的用户交互处理

4.1 处理 RecyclerView 中的点击事件

在 RecyclerView 中处理点击事件可以让用户与列表项进行交互。
java

1. // 在 UserAdapter 中添加点击事件处理
2. import android.view.LayoutInflater;
3. import android.view.View;
4. import android.view.ViewGroup;
5. import android.widget.TextView;
6. import androidx.annotation.NonNull;
7. import androidx.recyclerview.widget.RecyclerView;
8. import java.util.List;
10. // 该 Adapter 用于将 User 数据绑定到 RecyclerView 的每个 Item 上，并处理点击事件
11. public class UserAdapter extends RecyclerView.Adapter<UserAdapter.UserViewHolder> {
12.     private List<User> userList;
13.     private OnItemClickListener onItemClickListener;
15.     // 构造函数，接收用户数据列表和点击事件监听器
16.     public UserAdapter(List<User> userList, OnItemClickListener onItemClickListener) {
17.         this.userList = userList;
18.         this.onItemClickListener = onItemClickListener;
19.     }
21.     // 创建 ViewHolder
22.     @NonNull
23.     @Override
24.     public UserViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
25.         // 加载 Item 的布局文件
26.         View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_user, parent, false);
27.         return new UserViewHolder(view);
28.     }
30.     // 绑定数据到 ViewHolder
31.     @Override
32.     public void onBindViewHolder(@NonNull UserViewHolder holder, int position) {
33.         // 获取当前位置的用户数据
34.         User user = userList.get(position);
35.         // 将用户数据显示在 TextView 上
36.         holder.textViewName.setText(user.getName());
37.         holder.textViewAge.setText(String.valueOf(user.getAge()));
39.         // 设置点击事件监听器
40.         holder.itemView.setOnClickListener(new View.OnClickListener() {
41.             @Override
42.             public void onClick(View v) {
43.                 if (onItemClickListener != null) {
44.                     // 当点击事件发生时，调用监听器的回调方法
45.                     onItemClickListener.onItemClick(user);
46.                 }
47.             }
48.         });
49.     }
51.     // 获取数据项的数量
52.     @Override
53.     public int getItemCount() {
54.         return userList != null ? userList.size() : 0;
55.     }
57.     // 更新数据列表并刷新 Adapter
58.     public void setUserList(List<User> userList) {
59.         this.userList = userList;
60.         notifyDataSetChanged();
61.     }
63.     // 定义点击事件监听器接口
64.     public interface OnItemClickListener {
65.         // 当 Item 被点击时调用该方法
66.         void onItemClick(User user);
67.     }
69.     // 定义 ViewHolder 类
70.     static class UserViewHolder extends RecyclerView.ViewHolder {
71.         TextView textViewName;
72.         TextView textViewAge;
74.         // 构造函数，初始化 ViewHolder 中的视图组件
75.         UserViewHolder(@NonNull View itemView) {
76.             super(itemView);
77.             textViewName = itemView.findViewById(R.id.textViewName);
78.             textViewAge = itemView.findViewById(R.id.textViewAge);
79.         }
80.     }
81. }

复制代码

java

1. // 在 UserListActivity 中处理点击事件
2. import androidx.appcompat.app.AppCompatActivity;
3. import androidx.lifecycle.Observer;
4. import androidx.lifecycle.ViewModelProvider;
5. import androidx.recyclerview.widget.LinearLayoutManager;
6. import androidx.recyclerview.widget.RecyclerView;
7. import android.os.Bundle;
8. import android.widget.Toast;
9. import java.util.List;
11. // 该 Activity 用于展示用户列表并处理点击事件
12. public class UserListActivity extends AppCompatActivity {
13.     private RecyclerView recyclerView;
14.     private UserAdapter userAdapter;
15.     private UserViewModel userViewModel;
17.     @Override
18.     protected void onCreate(Bundle savedInstanceState) {
19.         super.onCreate(savedInstanceState);
20.         setContentView(R.layout.activity_user_list);
22.         // 初始化 RecyclerView
23.         recyclerView = findViewById(R.id.recyclerView);
24.         recyclerView.setLayoutManager(new LinearLayoutManager(this));
25.         userAdapter = new UserAdapter(null, new UserAdapter.OnItemClickListener() {
26.             @Override
27.             public void onItemClick(User user) {
28.                 // 当 Item 被点击时，显示一个 Toast 消息
29.                 Toast.makeText(UserListActivity.this, "Clicked on " + user.getName(), Toast.LENGTH_SHORT).show();
30.             }
31.         });
32.         recyclerView.setAdapter(userAdapter);
34.         // 获取 ViewModel 实例
35.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
37.         // 观察 LiveData 数据的变化
38.         userViewModel.getAllUsers().observe(this, new Observer<List<User>>() {
39.             @Override
40.             public void onChanged(List<User> users) {
41.                 // 当数据发生变化时，更新 Adapter 中的数据并刷新界面
42.                 userAdapter.setUserList(users);
43.             }
44.         });
45.     }
46. }

复制代码

4.2 源码分析

在 UserAdapter 中，我们界说了一个 OnItemClickListener 接口，并在 onBindViewHolder 方法中为每个 Item 设置点击事件监听器。当 Item 被点击时，会调用监听器的 onItemClick 方法。在 UserListActivity 中，我们实现了 OnItemClickListener 接口，并在 onItemClick 方法中表现一个 Toast 消息，以响应用户的点击操作。
4.3 处理表单输入和提交

在表现层中，我们经常须要处理用户的表单输入，并将输入的数据提交到数据层。
java

1. // 定义 AddUserActivity
2. import androidx.appcompat.app.AppCompatActivity;
3. import android.os.Bundle;
4. import android.view.View;
5. import android.widget.Button;
6. import android.widget.EditText;
7. import androidx.lifecycle.ViewModelProvider;
9. // 该 Activity 用于添加新用户
10. public class AddUserActivity extends AppCompatActivity {
11.     private EditText editTextName;
12.     private EditText editTextAge;
13.     private Button buttonAdd;
14.     private UserViewModel userViewModel;
16.     @Override
17.     protected void onCreate(Bundle savedInstanceState) {
18.         super.onCreate(savedInstanceState);
19.         setContentView(R.layout.activity_add_user);
21.         // 初始化视图组件
22.         editTextName = findViewById(R.id.editTextName);
23.         editTextAge = findViewById(R.id.editTextAge);
24.         buttonAdd = findViewById(R.id.buttonAdd);
26.         // 获取 ViewModel 实例
27.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
29.         // 设置按钮的点击事件监听器
30.         buttonAdd.setOnClickListener(new View.OnClickListener() {
31.             @Override
32.             public void onClick(View v) {
33.                 // 获取用户输入的姓名和年龄
34.                 String name = editTextName.getText().toString().trim();
35.                 String ageStr = editTextAge.getText().toString().trim();
36.                 if (!name.isEmpty() && !ageStr.isEmpty()) {
37.                     int age = Integer.parseInt(ageStr);
38.                     // 创建新的用户对象
39.                     User user = new User(name, age);
40.                     // 调用 ViewModel 的方法添加用户
41.                     userViewModel.insertUser(user);
42.                     // 关闭当前 Activity
43.                     finish();
44.                 }
45.             }
46.         });
47.     }
48. }

复制代码

java

1. // 在 UserViewModel 中添加插入用户的方法
2. import androidx.lifecycle.LiveData;
3. import androidx.lifecycle.ViewModel;
4. import java.util.List;
6. // 该 ViewModel 用于管理用户数据
7. public class UserViewModel extends ViewModel {
8.     private UserRepository userRepository;
9.     private LiveData<List<User>> allUsers;
11.     // 构造函数，初始化 UserRepository 并获取所有用户数据
12.     public UserViewModel() {
13.         userRepository = new UserRepository();
14.         allUsers = userRepository.getAllUsers();
15.     }
17.     // 获取所有用户数据的 LiveData 对象
18.     public LiveData<List<User>> getAllUsers() {
19.         return allUsers;
20.     }
22.     // 插入新用户的方法
23.     public void insertUser(User user) {
24.         userRepository.insertUser(user);
25.     }
26. }

复制代码

java

1. // 在 UserRepository 中添加插入用户的方法
2. import androidx.lifecycle.LiveData;
3. import java.util.List;
5. // 该 Repository 用于与数据层交互，获取用户数据
6. public class UserRepository {
7.     private UserDao userDao;
9.     // 构造函数，初始化 UserDao
10.     public UserRepository() {
11.         AppDatabase appDatabase = AppDatabase.getDatabase();
12.         userDao = appDatabase.userDao();
13.     }
15.     // 获取所有用户数据的 LiveData 对象
16.     public LiveData<List<User>> getAllUsers() {
17.         return userDao.getAllUsers();
18.     }
20.     // 插入新用户的方法
21.     public void insertUser(User user) {
22.         userDao.insertUser(user);
23.     }
24. }

复制代码

java

1. // 在 UserDao 中添加插入用户的方法
2. import androidx.room.Dao;
3. import androidx.room.Insert;
5. // 该 DAO 接口定义了与用户数据相关的数据库操作方法
6. @Dao
7. public interface UserDao {
8.     // 查询所有用户数据，并返回 LiveData 类型的结果
9.     @Query("SELECT * FROM user")
10.     LiveData<List<User>> getAllUsers();
12.     // 插入新用户的方法
13.     @Insert
14.     void insertUser(User user);
15. }

复制代码

4.4 源码分析

在 AddUserActivity 中，我们获取用户输入的姓名和年龄，创建新的 User 对象，并调用 UserViewModel 的 insertUser 方法将用户数据插入到数据库中。UserViewModel 调用 UserRepository 的 insertUser 方法，UserRepository 再调用 UserDao 的 insertUser 方法。UserDao 使用 @Insert 注解界说了插入用户数据的方法。
五、表现层中的 UI 状态管理

5.1 加载状态管理

在获取数据时，我们须要表现加载状态，以提高用户体验。
java

1. // 在 UserListActivity 中添加加载状态管理
2. import androidx.appcompat.app.AppCompatActivity;
3. import androidx.lifecycle.Observer;
4. import androidx.lifecycle.ViewModelProvider;
5. import androidx.recyclerview.widget.LinearLayoutManager;
6. import androidx.recyclerview.widget.RecyclerView;
7. import android.os.Bundle;
8. import android.view.View;
9. import android.widget.ProgressBar;
10. import android.widget.Toast;
11. import java.util.List;
13. // 该 Activity 用于展示用户列表，添加了加载状态管理
14. public class UserListActivity extends AppCompatActivity {
15.     private RecyclerView recyclerView;
16.     private UserAdapter userAdapter;
17.     private UserViewModel userViewModel;
18.     private ProgressBar progressBar;
20.     @Override
21.     protected void onCreate(Bundle savedInstanceState) {
22.         super.onCreate(savedInstanceState);
23.         setContentView(R.layout.activity_user_list);
25.         // 初始化 RecyclerView
26.         recyclerView = findViewById(R.id.recyclerView);
27.         recyclerView.setLayoutManager(new LinearLayoutManager(this));
28.         userAdapter = new UserAdapter(null, new UserAdapter.OnItemClickListener() {
29.             @Override
30.             public void onItemClick(User user) {
31.                 // 当 Item 被点击时，显示一个 Toast 消息
32.                 Toast.makeText(UserListActivity.this, "Clicked on " + user.getName(), Toast.LENGTH_SHORT).show();
33.             }
34.         });
35.         recyclerView.setAdapter(userAdapter);
37.         // 初始化 ProgressBar
38.         progressBar = findViewById(R.id.progressBar);
40.         // 获取 ViewModel 实例
41.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
43.         // 显示加载状态
44.         progressBar.setVisibility(View.VISIBLE);
46.         // 观察 LiveData 数据的变化
47.         userViewModel.getAllUsers().observe(this, new Observer<List<User>>() {
48.             @Override
49.             public void onChanged(List<User> users) {
50.                 // 当数据加载完成后，隐藏加载状态
51.                 progressBar.setVisibility(View.GONE);
52.                 // 更新 Adapter 中的数据并刷新界面
53.                 userAdapter.setUserList(users);
54.             }
55.         });
56.     }
57. }

复制代码

5.2 源码分析

在 UserListActivity 中，我们添加了一个 ProgressBar 用于表现加载状态。在获取数据之前，将 ProgressBar 的可见性设置为 VISIBLE，当数据加载完成后，将其可见性设置为 GONE。这样可以让用户清楚地知道数据正在加载中。
5.3 错误状态管理

当数据获取失败时，我们须要表现错误状态。
java

1. // 在 UserViewModel 中添加错误状态管理
2. import androidx.lifecycle.LiveData;
3. import androidx.lifecycle.MutableLiveData;
4. import androidx.lifecycle.ViewModel;
5. import java.util.List;
7. // 该 ViewModel 用于管理用户数据，添加了错误状态管理
8. public class UserViewModel extends ViewModel {
9.     private UserRepository userRepository;
10.     private LiveData<List<User>> allUsers;
11.     private MutableLiveData<String> errorMessage;
13.     // 构造函数，初始化 UserRepository 并获取所有用户数据
14.     public UserViewModel() {
15.         userRepository = new UserRepository();
16.         allUsers = userRepository.getAllUsers();
17.         errorMessage = new MutableLiveData<>();
18.         // 模拟数据获取失败的情况
19.         userRepository.getErrorLiveData().observeForever(new Observer<String>() {
20.             @Override
21.             public void onChanged(String error) {
22.                 errorMessage.setValue(error);
23.             }
24.         });
25.     }
27.     // 获取所有用户数据的 LiveData 对象
28.     public LiveData<List<User>> getAllUsers() {
29.         return allUsers;
30.     }
32.     // 获取错误消息的 LiveData 对象
33.     public LiveData<String> getErrorMessage() {
34.         return errorMessage;
35.     }
37.     // 插入新用户的方法
38.     public void insertUser(User user) {
39.         userRepository.insertUser(user);
40.     }
41. }

复制代码

java

1. // 在 UserRepository 中添加错误状态管理
2. import androidx.lifecycle.LiveData;
3. import androidx.lifecycle.MutableLiveData;
4. import java.util.List;
6. // 该 Repository 用于与数据层交互，获取用户数据，添加了错误状态管理
7. public class UserRepository {
8.     private UserDao userDao;
9.     private MutableLiveData<String> errorLiveData;
11.     // 构造函数，初始化 UserDao
12.     public UserRepository() {
13.         AppDatabase appDatabase = AppDatabase.getDatabase();
14.         userDao = appDatabase.userDao();
15.         errorLiveData = new MutableLiveData<>();
16.         // 模拟数据获取失败的情况
17.         try {
18.             // 这里可以添加实际的错误处理逻辑
19.             if (Math.random() < 0.1) {
20.                 throw new Exception("Data fetch failed");
21.             }
22.         } catch (Exception e) {
23.             errorLiveData.setValue(e.getMessage());
24.         }
25.     }
27.     // 获取所有用户数据的 LiveData 对象
28.     public LiveData<List<User>> getAllUsers() {
29.         return userDao.getAllUsers();
30.     }
32.     // 获取错误消息的 LiveData 对象
33.     public LiveData<String> getErrorLiveData() {
34.         return errorLiveData;
35.     }
37.     // 插入新用户的方法
38.     public void insertUser(User user) {
39.         userDao.insertUser(user);
40.     }
41. }

复制代码

java

1. // 在 UserListActivity 中处理错误状态
2. import androidx.appcompat.app.AppCompatActivity;
3. import androidx.lifecycle.Observer;
4. import androidx.lifecycle.ViewModelProvider;
5. import androidx.recyclerview.widget.LinearLayoutManager;
6. import androidx.recyclerview.widget.RecyclerView;
7. import android.os.Bundle;
8. import android.view.View;
9. import android.widget.ProgressBar;
10. import android.widget.TextView;
11. import android.widget.Toast;
12. import java.util.List;
14. // 该 Activity 用于展示用户列表，处理错误状态
15. public class UserListActivity extends AppCompatActivity {
16.     private RecyclerView recyclerView;
17.     private UserAdapter userAdapter;
18.     private UserViewModel userViewModel;
19.     private ProgressBar progressBar;
20.     private TextView textViewError;
22.     @Override
23.     protected void onCreate(Bundle savedInstanceState) {
24.         super.onCreate(savedInstanceState);
25.         setContentView(R.layout.activity_user_list);
27.         // 初始化 RecyclerView
28.         recyclerView = findViewById(R.id.recyclerView);
29.         recyclerView.setLayoutManager(new LinearLayoutManager(this));
30.         userAdapter = new UserAdapter(null, new UserAdapter.OnItemClickListener() {
31.             @Override
32.             public void onItemClick(User user) {
33.                 // 当 Item 被点击时，显示一个 Toast 消息
34.                 Toast.makeText(UserListActivity.this, "Clicked on " + user.getName(), Toast.LENGTH_SHORT).show();
35.             }
36.         });
37.         recyclerView.setAdapter(userAdapter);
39.         // 初始化 ProgressBar
40.         progressBar = findViewById(R.id.progressBar);
42.         // 初始化错误提示 TextView
43.         textViewError = findViewById(R.id.textViewError);
45.         // 获取 ViewModel 实例
46.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
48.         // 显示加载状态
49.         progressBar.setVisibility(View.VISIBLE);
51.         // 观察 LiveData 数据的变化
52.         userViewModel.getAllUsers().observe(this, new Observer<List<User>>() {
53.             @Override
54.             public void onChanged(List<User> users) {
55.                 // 当数据加载完成后，隐藏加载状态
56.                 progressBar.setVisibility(View.GONE);
57.                 if (users != null) {
58.                     // 隐藏错误提示
59.                     textViewError.setVisibility(View.GONE);
60.                     // 更新 Adapter 中的数据并刷新界面
61.                     userAdapter.setUserList(users);
62.                 }
63.             }
64.         });
66.         // 观察错误消息的变化
67.         userViewModel.getErrorMessage().observe(this, new Observer<String>() {
68.             @Override
69.             public void onChanged(String error) {
70.                 // 隐藏加载状态
71.                 progressBar.setVisibility(View.GONE);
72.                 if (error != null) {
73.                     // 显示错误提示
74.                     textViewError.setVisibility(View.VISIBLE);
75.                     textViewError.setText(error);
76.                 }
77.             }
78.         });
79.     }
80. }

复制代码

5.4 源码分析

在 UserViewModel 和 UserRepository 中，我们添加了 MutableLiveData 类型的 errorMessage 用于存储错误消息。在 UserListActivity 中，我们观察 errorMessage 的变化，当有错误消息时，隐藏加载状态并表现错误提示。
六、表现层中的动画和过渡结果

6.1 RecyclerView 中的动画结果

在 RecyclerView 中添加动画结果可以提拔用户体验，让数据的更新更加生动。Android 为 RecyclerView 提供了默认的动画结果，同时也允许开发者自界说动画。
6.1.1 使用默认动画

RecyclerView 默认使用 DefaultItemAnimator 来实现动画结果，当数据发生变化时（如插入、删除、更新），会自动播放相应的动画。
java

1. import androidx.appcompat.app.AppCompatActivity;
2. import androidx.lifecycle.Observer;
3. import androidx.lifecycle.ViewModelProvider;
4. import androidx.recyclerview.widget.DefaultItemAnimator;
5. import androidx.recyclerview.widget.LinearLayoutManager;
6. import androidx.recyclerview.widget.RecyclerView;
7. import android.os.Bundle;
8. import android.widget.Toast;
9. import java.util.List;
11. // 该 Activity 用于展示用户列表，并使用 RecyclerView 默认动画
12. public class UserListActivity extends AppCompatActivity {
13.     private RecyclerView recyclerView;
14.     private UserAdapter userAdapter;
15.     private UserViewModel userViewModel;
17.     @Override
18.     protected void onCreate(Bundle savedInstanceState) {
19.         super.onCreate(savedInstanceState);
20.         setContentView(R.layout.activity_user_list);
22.         // 初始化 RecyclerView
23.         recyclerView = findViewById(R.id.recyclerView);
24.         recyclerView.setLayoutManager(new LinearLayoutManager(this));
26.         // 设置默认的 Item 动画
27.         recyclerView.setItemAnimator(new DefaultItemAnimator());
29.         userAdapter = new UserAdapter(null, new UserAdapter.OnItemClickListener() {
30.             @Override
31.             public void onItemClick(User user) {
32.                 // 当 Item 被点击时，显示一个 Toast 消息
33.                 Toast.makeText(UserListActivity.this, "Clicked on " + user.getName(), Toast.LENGTH_SHORT).show();
34.             }
35.         });
36.         recyclerView.setAdapter(userAdapter);
38.         // 获取 ViewModel 实例
39.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
41.         // 观察 LiveData 数据的变化
42.         userViewModel.getAllUsers().observe(this, new Observer<List<User>>() {
43.             @Override
44.             public void onChanged(List<User> users) {
45.                 // 当数据发生变化时，更新 Adapter 中的数据并刷新界面
46.                 userAdapter.setUserList(users);
47.             }
48.         });
49.     }
50. }

复制代码

6.1.2 源码分析

在上述代码中，通过 recyclerView.setItemAnimator(new DefaultItemAnimator()) 设置了 RecyclerView 的默认动画。DefaultItemAnimator 是 RecyclerView.ItemAnimator 的一个实现类，它内部处理了 RecyclerView 中 Item 的插入、删除、移动和更新动画。当调用 userAdapter.setUserList(users) 并触发 notifyDataSetChanged() 时，DefaultItemAnimator 会根据数据的变化情况播放相应的动画。
6.1.3 自界说动画

如果默认动画不能满足需求，开发者可以自界说动画。以下是一个自界说 ItemAnimator 的示例：
java

1. import android.animation.Animator;
2. import android.animation.ObjectAnimator;
3. import android.view.View;
4. import android.view.animation.Animation;
5. import android.view.animation.AnimationUtils;
6. import androidx.recyclerview.widget.RecyclerView;
7. import java.util.ArrayList;
8. import java.util.List;
10. // 自定义的 RecyclerView Item 动画类
11. public class CustomItemAnimator extends RecyclerView.ItemAnimator {
12.     private List<RecyclerView.ViewHolder> pendingAdditions = new ArrayList<>();
13.     private List<RecyclerView.ViewHolder> pendingRemovals = new ArrayList<>();
15.     @Override
16.     public boolean animateAdd(RecyclerView.ViewHolder holder) {
17.         pendingAdditions.add(holder);
18.         return true;
19.     }
21.     @Override
22.     public boolean animateRemove(RecyclerView.ViewHolder holder) {
23.         pendingRemovals.add(holder);
24.         return true;
25.     }
27.     @Override
28.     public boolean animateMove(RecyclerView.ViewHolder holder, int fromX, int fromY, int toX, int toY) {
29.         // 这里可以实现移动动画逻辑，暂不实现
30.         dispatchMoveFinished(holder);
31.         return false;
32.     }
34.     @Override
35.     public boolean animateChange(RecyclerView.ViewHolder oldHolder, RecyclerView.ViewHolder newHolder, int fromLeft, int fromTop, int toLeft, int toTop) {
36.         // 这里可以实现变更动画逻辑，暂不实现
37.         dispatchChangeFinished(oldHolder, true);
38.         dispatchChangeFinished(newHolder, false);
39.         return false;
40.     }
42.     @Override
43.     public void runPendingAnimations() {
44.         if (!pendingAdditions.isEmpty()) {
45.             for (RecyclerView.ViewHolder holder : pendingAdditions) {
46.                 // 为新增的 Item 播放动画
47.                 animateAddImpl(holder);
48.             }
49.             pendingAdditions.clear();
50.         }
52.         if (!pendingRemovals.isEmpty()) {
53.             for (RecyclerView.ViewHolder holder : pendingRemovals) {
54.                 // 为删除的 Item 播放动画
55.                 animateRemoveImpl(holder);
56.             }
57.             pendingRemovals.clear();
58.         }
59.     }
61.     private void animateAddImpl(final RecyclerView.ViewHolder holder) {
62.         View view = holder.itemView;
63.         // 使用属性动画实现淡入效果
64.         ObjectAnimator animator = ObjectAnimator.ofFloat(view, "alpha", 0f, 1f);
65.         animator.setDuration(300);
66.         animator.addListener(new Animator.AnimatorListener() {
67.             @Override
68.             public void onAnimationStart(Animator animation) {
69.                 dispatchAddStarting(holder);
70.             }
72.             @Override
73.             public void onAnimationEnd(Animator animation) {
74.                 dispatchAddFinished(holder);
75.             }
77.             @Override
78.             public void onAnimationCancel(Animator animation) {
79.                 dispatchAddFinished(holder);
80.             }
82.             @Override
83.             public void onAnimationRepeat(Animator animation) {
84.                 // 不处理重复动画
85.             }
86.         });
87.         animator.start();
88.     }
90.     private void animateRemoveImpl(final RecyclerView.ViewHolder holder) {
91.         View view = holder.itemView;
92.         // 使用属性动画实现淡出效果
93.         ObjectAnimator animator = ObjectAnimator.ofFloat(view, "alpha", 1f, 0f);
94.         animator.setDuration(300);
95.         animator.addListener(new Animator.AnimatorListener() {
96.             @Override
97.             public void onAnimationStart(Animator animation) {
98.                 dispatchRemoveStarting(holder);
99.             }
101.             @Override
102.             public void onAnimationEnd(Animator animation) {
103.                 dispatchRemoveFinished(holder);
104.             }
106.             @Override
107.             public void onAnimationCancel(Animator animation) {
108.                 dispatchRemoveFinished(holder);
109.             }
111.             @Override
112.             public void onAnimationRepeat(Animator animation) {
113.                 // 不处理重复动画
114.             }
115.         });
116.         animator.start();
117.     }
119.     @Override
120.     public void endAnimation(RecyclerView.ViewHolder item) {
121.         // 结束动画的逻辑
122.     }
124.     @Override
125.     public void endAnimations() {
126.         // 结束所有动画的逻辑
127.     }
129.     @Override
130.     public boolean isRunning() {
131.         return !pendingAdditions.isEmpty() || !pendingRemovals.isEmpty();
132.     }
133. }

复制代码

java

1. import androidx.appcompat.app.AppCompatActivity;
2. import androidx.lifecycle.Observer;
3. import androidx.lifecycle.ViewModelProvider;
4. import androidx.recyclerview.widget.LinearLayoutManager;
5. import androidx.recyclerview.widget.RecyclerView;
6. import android.os.Bundle;
7. import android.widget.Toast;
8. import java.util.List;
10. // 该 Activity 用于展示用户列表，并使用自定义的 RecyclerView 动画
11. public class UserListActivity extends AppCompatActivity {
12.     private RecyclerView recyclerView;
13.     private UserAdapter userAdapter;
14.     private UserViewModel userViewModel;
16.     @Override
17.     protected void onCreate(Bundle savedInstanceState) {
18.         super.onCreate(savedInstanceState);
19.         setContentView(R.layout.activity_user_list);
21.         // 初始化 RecyclerView
22.         recyclerView = findViewById(R.id.recyclerView);
23.         recyclerView.setLayoutManager(new LinearLayoutManager(this));
25.         // 设置自定义的 Item 动画
26.         recyclerView.setItemAnimator(new CustomItemAnimator());
28.         userAdapter = new UserAdapter(null, new UserAdapter.OnItemClickListener() {
29.             @Override
30.             public void onItemClick(User user) {
31.                 // 当 Item 被点击时，显示一个 Toast 消息
32.                 Toast.makeText(UserListActivity.this, "Clicked on " + user.getName(), Toast.LENGTH_SHORT).show();
33.             }
34.         });
35.         recyclerView.setAdapter(userAdapter);
37.         // 获取 ViewModel 实例
38.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
40.         // 观察 LiveData 数据的变化
41.         userViewModel.getAllUsers().observe(this, new Observer<List<User>>() {
42.             @Override
43.             public void onChanged(List<User> users) {
44.                 // 当数据发生变化时，更新 Adapter 中的数据并刷新界面
45.                 userAdapter.setUserList(users);
46.             }
47.         });
48.     }
49. }

复制代码

6.1.4 源码分析

自界说 CustomItemAnimator 继续自 RecyclerView.ItemAnimator，并重写了 animateAdd、animateRemove、animateMove、animateChange 等方法来处理不同类型的动画。在 runPendingAnimations 方法中，会根据 pendingAdditions 和 pendingRemovals 列表中的 ViewHolder 执行相应的动画。animateAddImpl 和 animateRemoveImpl 方法分别使用 ObjectAnimator 实现了淡入和淡出的动画结果，并在动画开始和竣事时调用相应的 dispatch 方法通知 RecyclerView。
6.2 Activity 过渡动画

Activity 过渡动画可以让 Activity 之间的切换更加流畅和美观。Android 提供了多种过渡动画结果，如淡入淡出、滑动、缩放等。
6.2.1 使用体系默认过渡动画

在 Android 中，可以通过设置 Activity 的主题来使用体系默认的过渡动画。
xml

1. <!-- styles.xml -->
2. <resources>
3.     <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
4.         <!-- 设置 Activity 过渡动画 -->
5.         <item name="android:windowActivityTransitions">true</item>
6.         <item name="android:windowEnterTransition">@android:transition/fade</item>
7.         <item name="android:windowExitTransition">@android:transition/fade</item>
8.     </style>
9. </resources>

复制代码

java

1. import androidx.appcompat.app.AppCompatActivity;
2. import android.content.Intent;
3. import android.os.Bundle;
4. import android.view.View;
5. import android.widget.Button;
7. // 该 Activity 用于演示 Activity 过渡动画
8. public class MainActivity extends AppCompatActivity {
9.     private Button buttonOpenActivity;
11.     @Override
12.     protected void onCreate(Bundle savedInstanceState) {
13.         super.onCreate(savedInstanceState);
14.         setContentView(R.layout.activity_main);
16.         // 初始化按钮
17.         buttonOpenActivity = findViewById(R.id.buttonOpenActivity);
18.         buttonOpenActivity.setOnClickListener(new View.OnClickListener() {
19.             @Override
20.             public void onClick(View v) {
21.                 // 启动新的 Activity
22.                 Intent intent = new Intent(MainActivity.this, SecondActivity.class);
23.                 startActivity(intent);
24.             }
25.         });
26.     }
27. }

复制代码

java

1. import androidx.appcompat.app.AppCompatActivity;
2. import android.os.Bundle;
4. // 第二个 Activity
5. public class SecondActivity extends AppCompatActivity {
6.     @Override
7.     protected void onCreate(Bundle savedInstanceState) {
8.         super.onCreate(savedInstanceState);
9.         setContentView(R.layout.activity_second);
10.     }
11. }

复制代码

6.2.2 源码分析

在 styles.xml 中，通过设置 android:windowActivityTransitions 为 true 开启 Activity 过渡动画，android:windowEnterTransition 和 android:windowExitTransition 分别设置了 Activity 进入和退出时的过渡动画为淡入淡出结果。当在 MainActivity 中启动 SecondActivity 时，体系会自动应用这些过渡动画。
6.2.3 自界说过渡动画

除了使用体系默认的过渡动画，还可以自界说过渡动画。
xml

1. <!-- res/transition/slide_transition.xml -->
2. <transitionSet xmlns:android="http://schemas.android.com/apk/res/android">
3.     <slide
4.         android:duration="300"
5.         android:slideEdge="right" />
6. </transitionSet>

复制代码

java

1. import androidx.appcompat.app.AppCompatActivity;
2. import android.content.Intent;
3. import android.os.Bundle;
4. import android.transition.TransitionInflater;
5. import android.view.View;
6. import android.widget.Button;
8. // 该 Activity 用于演示自定义 Activity 过渡动画
9. public class MainActivity extends AppCompatActivity {
10.     private Button buttonOpenActivity;
12.     @Override
13.     protected void onCreate(Bundle savedInstanceState) {
14.         super.onCreate(savedInstanceState);
15.         setContentView(R.layout.activity_main);
17.         // 初始化按钮
18.         buttonOpenActivity = findViewById(R.id.buttonOpenActivity);
19.         buttonOpenActivity.setOnClickListener(new View.OnClickListener() {
20.             @Override
21.             public void onClick(View v) {
22.                 // 启动新的 Activity
23.                 Intent intent = new Intent(MainActivity.this, SecondActivity.class);
25.                 // 设置进入过渡动画
26.                 getWindow().setEnterTransition(TransitionInflater.from(MainActivity.this).inflateTransition(R.transition.slide_transition));
27.                 // 设置退出过渡动画
28.                 getWindow().setExitTransition(TransitionInflater.from(MainActivity.this).inflateTransition(R.transition.slide_transition));
30.                 startActivity(intent);
31.             }
32.         });
33.     }
34. }

复制代码

6.2.4 源码分析

在 res/transition/slide_transition.xml 中界说了一个滑动过渡动画，android:slideEdge="right" 表示从右侧滑入。在 MainActivity 中，通过 getWindow().setEnterTransition 和 getWindow().setExitTransition 方法设置了进入和退出时的过渡动画。当启动 SecondActivity 时，会应用自界说的滑动过渡动画。
七、表现层中的响应式设计

7.1 结构的响应式设计

在不同的屏幕尺寸和方向下，应用的结构须要可以或许自适应，以提供一致的用户体验。
7.1.1 使用 ConstraintLayout

ConstraintLayout 是 Android 中一个强大的结构管理器，它可以根据束缚条件来结构子视图，非常适合实现响应式设计。
xml

1. <!-- activity_main.xml -->
2. <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
3.     xmlns:app="http://schemas.android.com/apk/res-auto"
4.     android:layout_width="match_parent"
5.     android:layout_height="match_parent">
7.     <TextView
8.         android:id="@+id/textViewTitle"
9.         android:layout_width="wrap_content"
10.         android:layout_height="wrap_content"
11.         android:text="Title"
12.         app:layout_constraintTop_toTopOf="parent"
13.         app:layout_constraintStart_toStartOf="parent"
14.         app:layout_constraintEnd_toEndOf="parent"
15.         android:layout_marginTop="16dp" />
17.     <Button
18.         android:id="@+id/buttonAction"
19.         android:layout_width="wrap_content"
20.         android:layout_height="wrap_content"
21.         android:text="Action"
22.         app:layout_constraintTop_toBottomOf="@id/textViewTitle"
23.         app:layout_constraintStart_toStartOf="parent"
24.         app:layout_constraintEnd_toEndOf="parent"
25.         android:layout_marginTop="16dp" />
26. </androidx.constraintlayout.widget.ConstraintLayout>

复制代码

7.1.2 源码分析

在上述结构文件中，使用 ConstraintLayout 来结构 TextView 和 Button。通过 app:layout_constraintTop_toTopOf、app:layout_constraintStart_toStartOf 等束缚条件，将 TextView 固定在结构的顶部中央，Button 固定在 TextView 的下方中央。这样，无论屏幕尺寸和方向如何变化，结构都会自适应调解。
7.1.3 使用不同的结构文件

除了使用 ConstraintLayout，还可以根据不同的屏幕尺寸和方向提供不同的结构文件。
plaintext

1. res/
2. ├── layout/
3. │   └── activity_main.xml
4. ├── layout-sw600dp/
5. │   └── activity_main.xml
6. ├── layout-land/
7. │   └── activity_main.xml

复制代码

在 layout-sw600dp 目录下的 activity_main.xml 是针对屏幕最小宽度为 600dp 的装备的结构文件，layout-land 目录下的 activity_main.xml 是针对横屏的结构文件。体系会根据装备的屏幕尺寸和方向自动选择符合的结构文件。
7.2 数据的响应式设计

在表现层中，数据的展示也须要根据不同的情况进行响应式设计。例如，在不同的屏幕尺寸下，可能须要展示不同数目标数据项。
java

1. import androidx.appcompat.app.AppCompatActivity;
2. import androidx.lifecycle.Observer;
3. import androidx.lifecycle.ViewModelProvider;
4. import androidx.recyclerview.widget.GridLayoutManager;
5. import androidx.recyclerview.widget.RecyclerView;
6. import android.content.res.Configuration;
7. import android.os.Bundle;
8. import android.widget.Toast;
9. import java.util.List;
11. // 该 Activity 用于展示用户列表，并实现数据的响应式设计
12. public class UserListActivity extends AppCompatActivity {
13.     private RecyclerView recyclerView;
14.     private UserAdapter userAdapter;
15.     private UserViewModel userViewModel;
17.     @Override
18.     protected void onCreate(Bundle savedInstanceState) {
19.         super.onCreate(savedInstanceState);
20.         setContentView(R.layout.activity_user_list);
22.         // 初始化 RecyclerView
23.         recyclerView = findViewById(R.id.recyclerView);
25.         // 根据屏幕方向设置不同的列数
26.         int spanCount = getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT ? 2 : 3;
27.         recyclerView.setLayoutManager(new GridLayoutManager(this, spanCount));
29.         userAdapter = new UserAdapter(null, new UserAdapter.OnItemClickListener() {
30.             @Override
31.             public void onItemClick(User user) {
32.                 // 当 Item 被点击时，显示一个 Toast 消息
33.                 Toast.makeText(UserListActivity.this, "Clicked on " + user.getName(), Toast.LENGTH_SHORT).show();
34.             }
35.         });
36.         recyclerView.setAdapter(userAdapter);
38.         // 获取 ViewModel 实例
39.         userViewModel = new ViewModelProvider(this).get(UserViewModel.class);
41.         // 观察 LiveData 数据的变化
42.         userViewModel.getAllUsers().observe(this, new Observer<List<User>>() {
43.             @Override
44.             public void onChanged(List<User> users) {
45.                 // 当数据发生变化时，更新 Adapter 中的数据并刷新界面
46.                 userAdapter.setUserList(users);
47.             }
48.         });
49.     }
50. }

复制代码

7.2.1 源码分析

在 UserListActivity 中，根据屏幕的方向（竖屏或横屏）设置 GridLayoutManager 的列数。在竖屏时，列数为 2；在横屏时，列数为 3。这样，在不同的屏幕方向下，RecyclerView 会以不同的结构方式展示数据。
八、表现层中的性能优化

8.1 减少结构嵌套

结构嵌套过多会导致结构的测量和绘制时间增加，影响性能。可以使用 ConstraintLayout 等结构管理器来减少结构嵌套。
xml

1. <!-- 优化前的布局 -->
2. <LinearLayout
3.     android:layout_width="match_parent"
4.     android:layout_height="match_parent"
5.     android:orientation="vertical">
7.     <LinearLayout
8.         android:layout_width="match_parent"
9.         android:layout_height="wrap_content"
10.         android:orientation="horizontal">
12.         <TextView
13.             android:layout_width="wrap_content"
14.             android:layout_height="wrap_content"
15.             android:text="Title" />
17.         <Button
18.             android:layout_width="wrap_content"
19.             android:layout_height="wrap_content"
20.             android:text="Action" />
21.     </LinearLayout>
23.     <ListView
24.         android:layout_width="match_parent"
25.         android:layout_height="match_parent" />
26. </LinearLayout>

复制代码

xml

1. <!-- 优化后的布局 -->
2. <androidx.constraintlayout.widget.ConstraintLayout
3.     android:layout_width="match_parent"
4.     android:layout_height="match_parent">
6.     <TextView
7.         android:id="@+id/textViewTitle"
8.         android:layout_width="wrap_content"
9.         android:layout_height="wrap_content"
10.         android:text="Title"
11.         app:layout_constraintTop_toTopOf="parent"
12.         app:layout_constraintStart_toStartOf="parent"
13.         android:layout_marginTop="16dp"
14.         android:layout_marginStart="16dp" />
16.     <Button
17.         android:id="@+id/buttonAction"
18.         android:layout_width="wrap_content"
19.         android:layout_height="wrap_content"
20.         android:text="Action"
21.         app:layout_constraintTop_toTopOf="@id/textViewTitle"
22.         app:layout_constraintStart_toEndOf="@id/textViewTitle"
23.         android:layout_marginStart="16dp" />
25.     <ListView
26.         android:layout_width="match_parent"
27.         android:layout_height="0dp"
28.         app:layout_constraintTop_toBottomOf="@id/textViewTitle"
29.         app:layout_constraintBottom_toBottomOf="parent"
30.         android:layout_marginTop="16dp" />
31. </androidx.constraintlayout.widget.ConstraintLayout>

复制代码

8.1.1 源码分析

优化前的结构使用了两层 LinearLayout 嵌套，而优化后的结构使用 ConstraintLayout 直接结构子视图，减少了结构嵌套。这样可以提高结构的测量和绘制效率。
8.2 克制在主线程进行耗时操作

在表现层中，应该克制在主线程进行耗时操作，如网络请求、数据库查询等。可以使用 ViewModel 和 LiveData 结合 Coroutine 或 RxJava 来实现异步操作。
java

1. import androidx.lifecycle.LiveData;
2. import androidx.lifecycle.MutableLiveData;
3. import androidx.lifecycle.ViewModel;
4. import java.util.List;
5. import kotlinx.coroutines.CoroutineScope;
6. import kotlinx.coroutines.Dispatchers;
7. import kotlinx.coroutines.Job;
8. import kotlinx.coroutines.launch;
10. // 该 ViewModel 用于管理用户数据，并使用 Coroutine 进行异步操作
11. public class UserViewModel extends ViewModel {
12.     private UserRepository userRepository;
13.     private MutableLiveData<List<User>> allUsers;
14.     private Job job;
16.     // 构造函数，初始化 UserRepository 并获取所有用户数据
17.     public UserViewModel() {
18.         userRepository = new UserRepository();
19.         allUsers = new MutableLiveData<>();
20.         loadUsers();
21.     }
23.     // 获取所有用户数据的 LiveData 对象
24.     public LiveData<List<User>> getAllUsers() {
25.         return allUsers;
26.     }
28.     // 加载用户数据的方法
29.     private void loadUsers() {
30.         job = CoroutineScope(Dispatchers.IO).launch {
31.             // 在 IO 线程中进行数据库查询
32.             List<User> users = userRepository.getAllUsersSync();
33.             // 将结果切换到主线程更新 LiveData
34.             CoroutineScope(Dispatchers.Main).launch {
35.                 allUsers.setValue(users);
36.             }
37.         };
38.     }
40.     @Override
41.     protected void onCleared() {
42.         super.onCleared();
43.         // 取消协程任务
44.         if (job != null && job.isActive()) {
45.             job.cancel();
46.         }
47.     }
48. }

复制代码

8.2.2 源码分析

在 UserViewModel 中，使用 Coroutine 进行异步操作。loadUsers 方法在 IO 线程中进行数据库查询，查询完成后，将结果切换到主线程更新 LiveData。这样可以克制在主线程进行耗时的数据库查询，包管 UI 的流畅性。同时，在 ViewModel 烧毁时，取消协程使命，克制内存走漏。
8.3 使用 RecyclerView 的视图缓存

RecyclerView 提供了视图缓存机制，可以复用已经创建的视图，减少视图的创建和烧毁次数，提高性能。
java

1. import android.view.LayoutInflater;
2. import android.view.View;
3. import android.view.ViewGroup;
4. import android.widget.TextView;
5. import androidx.annotation.NonNull;
6. import androidx.recyclerview.widget.RecyclerView;
7. import java.util.List;
9. // 该 Adapter 用于将 User 数据绑定到 RecyclerView 的每个 Item 上
10. public class UserAdapter extends RecyclerView.Adapter<UserAdapter.UserViewHolder> {
11.     private List<User> userList;
13.     // 构造函数，接收用户数据列表
14.     public UserAdapter(List<User> userList) {
15.         this.userList = userList;
16.     }
18.     // 创建 ViewHolder
19.     @NonNull
20.     @Override
21.     public UserViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
22.         // 加载 Item 的布局文件
23.         View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_user, parent, false);
24.         return new UserViewHolder(view);
25.     }
27.     // 绑定数据到 ViewHolder
28.     @Override
29.     public void onBindViewHolder(@NonNull UserViewHolder holder, int position) {
30.         // 获取当前位置的用户数据
31.         User user = userList.get(position);
32.         // 将用户数据显示在 TextView 上
33.         holder.textViewName.setText(user.getName());
34.         holder.textViewAge.setText(String.valueOf(user.getAge()));
35.     }
37.     // 获取数据项的数量
38.     @Override
39.     public int getItemCount() {
40.         return userList != null ? userList.size() : 0;
41.     }
43.     // 更新数据列表并刷新 Adapter
44.     public void setUserList(List<User> userList) {
45.         this.userList = userList;
46.         notifyDataSetChanged();
47.     }
49.     // 定义 ViewHolder 类
50.     static class UserViewHolder extends RecyclerView.ViewHolder {
51.         TextView textViewName;
52.         TextView textViewAge;
54.         // 构造函数，初始化 ViewHolder 中的视图组件
55.         UserViewHolder(@NonNull View itemView) {
56.             super(itemView);
57.             textViewName = itemView.findViewById(R.id.textViewName);
58.             textViewAge = itemView.findViewById(R.id.textViewAge);
59.         }
60.     }
61. }

复制代码

8.3.3 源码分析

在 UserAdapter 中，RecyclerView 会自动管理视图的缓存。当 RecyclerView 滚动时，会复用已经创建的 ViewHolder，只须要调用 onBindViewHolder 方法更新视图的数据。这样可以克制频仍创建和烧毁视图，提高性能。
九、表现层中的无停滞设计

9.1 为视图添加内容描述

java

1. // 在 RecyclerView Adapter 中设置内容描述（关键源码）
2. class UserAdapter extends RecyclerView.Adapter<UserAdapter.ViewHolder> {
3.     @NonNull
4.     @Override
5.     public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
6.         View itemView = LayoutInflater.from(parent.getContext())
7.            .inflate(R.layout.item_user, parent, false);
8.         
9.         // 为整个 Item 设置内容描述（辅助功能）
10.         itemView.setContentDescription("用户项：姓名 ${user.name}，年龄 ${user.age}岁");
11.         return new ViewHolder(itemView);
12.     }
14.     @Override
15.     public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
16.         User user = userList.get(position);
17.         
18.         // 为姓名 TextView 添加无障碍标签
19.         holder.nameView.setAccessibilityDelegate(new View.AccessibilityDelegate() {
20.             @Override
21.             public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfo info) {
22.                 super.onInitializeAccessibilityNodeInfo(host, info);
23.                 info.setText("用户名：" + user.name);
24.                 info.addAction(AccessibilityNodeInfo.ACTION_CLICK);
25.             }
26.         });
27.     }
28. }
30. // Android 框架中 ContentDescription 的处理逻辑（View.java）
31. public void setContentDescription(CharSequence contentDescription) {
32.     mContentDescription = contentDescription;
33.     // 触发无障碍节点更新
34.     sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CONTENT_DESCRIPTION_CHANGED);
35. }
37. // RecyclerView 辅助功能更新机制（RecyclerView.java）
38. @Override
39. public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfo info) {
40.     super.onInitializeAccessibilityNodeInfo(host, info);
41.     // 自动聚合子项的无障碍信息
42.     info.setCollectionInfo(CollectionInfo.obtain(
43.         getAdapter().getItemCount(),
44.         getChildCount(),
45.         isLayoutRtl()
46.     ));
47. }

复制代码

9.2 动态字体适配（源码实现）

xml

1. <!-- 布局文件中启用自动字体大小 -->
2. <TextView
3.     android:id="@+id/user_name"
4.     android:layout_width="wrap_content"
5.     android:layout_height="wrap_content"
6.     android:autofillHints="@string/hint_name"
7.     android:textSize="@dimen/font_size_normal"
8.     android:fontVariationSettings="wdth 100, wght 400"
9.     tools:text="张三" />

复制代码

java

1. // 系统字体适配核心类（Configuration.java）
2. public class Configuration {
3.     public float fontScale; // 字体缩放比例（用户设置）
5.     // 框架内部处理逻辑（ActivityThread.java）
6.     private void handleConfigurationChanged(Configuration config) {
7.         ViewRootImpl[] roots = mRoots.getArray();
8.         for (ViewRootImpl root : roots) {
9.             root.setLayoutParams(null, config, null);
10.         }
11.         // 触发全局字体更新
12.         applyOverrideConfiguration(config);
13.     }
14. }
16. // 在 Activity 中监听字体变化
17. public class UserActivity extends AppCompatActivity {
18.     @Override
19.     public void onConfigurationChanged(Configuration newConfig) {
20.         super.onConfigurationChanged(newConfig);
21.         // 重新绑定数据触发字体更新
22.         userViewModel.getAllUsers().observe(this, users -> adapter.setUsers(users));
23.     }
24. }

复制代码

十、Jetpack Compose 与 Room 的深度集成

10.1 基于 Compose 的数据绑定（核心源码）

kotlin

1. // Compose 界面组件
2. @Composable
3. fun UserListScreen(viewModel: UserViewModel = viewModel()) {
4.     val users by viewModel.users.collectAsState(emptyList())
5.     val context = LocalContext.current
7.     RecyclerView(
8.         modifier = Modifier.fillMaxSize(),
9.         verticalArrangement = Arrangement.spacedBy(16.dp)
10.     ) {
11.         items(users) { user ->
12.             UserItem(
13.                 user = user,
14.                 onClick = { viewModel.onUserClick(user) }
15.             )
16.         }
17.     }
19.     // 加载状态处理
20.     if (viewModel.isLoading.value) {
21.         CircularProgressIndicator(modifier = Modifier.centerInParent())
22.     }
23. }
25. // ViewModel 中的 State 管理
26. class UserViewModel : ViewModel() {
27.     private val _users = MutableStateFlow<List<User>>(emptyList())
28.     val users = _users.asStateFlow()
29.    
30.     private val _isLoading = MutableStateFlow(false)
31.     val isLoading = _isLoading.asStateFlow()
33.     init {
34.         loadUsers()
35.     }
37.     private fun loadUsers() {
38.         viewModelScope.launch {
39.             _isLoading.value = true
40.             try {
41.                 val users = userRepository.getAllUsers()
42.                 _users.value = users
43.             } finally {
44.                 _isLoading.value = false
45.             }
46.         }
47.     }
48. }
50. // Room 协程支持（Compose 专用扩展）
51. @Dao
52. interface UserDao {
53.     @Query("SELECT * FROM users")
54.     fun getAllUsersFlow(): Flow<List<User>> // 直接返回 Flow
55. }

复制代码

10.2 Compose 与 LiveData 的互操作

kotlin

1. // LiveData 转 Compose State
2. @Composable
3. fun <T> LiveData<T>.asComposeState(
4.     context: Context = LocalContext.current,
5.     initialValue: T
6. ): State<T> {
7.     val state = remember { mutableStateOf(initialValue) }
8.     val lifecycleOwner = rememberUpdatedState(context as LifecycleOwner)
9.    
10.     DisposableEffect(this) {
11.         val observer = Observer<T> { state.value = it }
12.         observe(lifecycleOwner.value, observer)
13.         onDispose { removeObserver(observer) }
14.     }
15.     return state
16. }
18. // 使用示例
19. val users = userViewModel.allUsers.asComposeState(emptyList())

复制代码

十一、表现层性能优化深度解析

11.1 RecyclerView 预结构优化（源码级）

java

1. // 自定义 RecyclerView（优化预布局）
2. class OptimizedRecyclerView @JvmOverloads constructor(
3.     context: Context,
4.     attrs: AttributeSet? = null,
5.     defStyle: Int = 0
6. ) : RecyclerView(context, attrs, defStyle) {
8.     override fun onMeasure(widthSpec: Int, heightSpec: Int) {
9.         // 禁用预布局（针对固定高度列表）
10.         setHasFixedSize(true);
11.         super.onMeasure(widthSpec, heightSpec);
12.     }
14.     override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
15.         // 跳过不必要的布局计算
16.         if (!changed) return;
17.         super.onLayout(changed, l, t, r, b);
18.     }
19. }
21. // 框架预布局逻辑（RecyclerView.java）
22. void processLayout(Recycler recycler, State state) {
23.     if (mState.mRunPredictiveAnimations) {
24.         // 预布局用于动画计算
25.         performPredictiveLayout(recycler, state);
26.     }
27.     // 正式布局
28.     performLayout(recycler, state);
29. }

复制代码

11.2 数据变更的细粒度更新（DiffUtil 源码）

java

1. // Adapter 中的 DiffUtil 实现
2. class UserAdapter : ListAdapter<User, UserAdapter.ViewHolder>(USER_DIFF_CALLBACK) {
3.     companion object {
4.         val USER_DIFF_CALLBACK = object : DiffUtil.ItemCallback<User>() {
5.             override fun areItemsTheSame(oldItem: User, newItem: User): Boolean {
6.                 return oldItem.id == newItem.id // 基于唯一标识判断
7.             }
9.             override fun areContentsTheSame(oldItem: User, newItem: User): Boolean {
10.                 return oldItem == newItem // 基于内容比较
11.             }
12.         }
13.     }
15.     // 框架内部 Diff 计算（DiffUtil.java）
16.     public static DiffResult calculateDiff(Callback callback) {
17.         return new DiffUtil(callback).calculate();
18.     }
20.     // 差异分发（RecyclerView.java）
21.     public void dispatchUpdateRanges(List<UpdateOp> ops) {
22.         mAdapterHelper.calculateDiff(ops);
23.         // 触发局部刷新
24.         for (UpdateOp op : ops) {
25.             dispatchSingleUpdate(op);
26.         }
27.     }
28. }

复制代码

十二、表现层与 Room 的生命周期协同

12.1 ViewModel 与 Room 的绑定

java

1. // ViewModel 中的 Room 初始化（关键源码）
2. class UserViewModel(application: Application) : AndroidViewModel(application) {
3.     private val database by lazy {
4.         AppDatabase.getInstance(application) // 生命周期感知的数据库实例
5.     }
7.     val users: LiveData<List<User>> = database.userDao().getAllUsers()
9.     override fun onCleared() {
10.         super.onCleared()
11.         // 释放数据库资源（可选）
12.         database.close()
13.     }
14. }
16. // 数据库单例实现（AppDatabase.java）
17. public class AppDatabase {
18.     private static volatile AppDatabase INSTANCE;
20.     public static AppDatabase getInstance(Context context) {
21.         if (INSTANCE == null) {
22.             synchronized (AppDatabase.class) {
23.                 if (INSTANCE == null) {
24.                     INSTANCE = Room.databaseBuilder(
25.                         context.getApplicationContext(),
26.                         AppDatabase.class, "user.db"
27.                     ).addCallback(new Callback() {
28.                         @Override
29.                         public void onCreate(@NonNull SupportSQLiteDatabase db) {
30.                             // 初始化数据（可选）
31.                         }
32.                     }).build();
33.                 }
34.             }
35.         }
36.         return INSTANCE;
37.     }
38. }

复制代码

12.2 LiveData 的生命周期安全（源码解析）

java

1. // LiveData observe 方法（LiveData.java）
2. public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
3.     // 检查生命周期状态
4.     if (owner.getLifecycle().getCurrentState() == DESTROYED) {
5.         return;
6.     }
7.     LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
8.     ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
9.     if (existing != null && !existing.isAttachedTo(owner)) {
10.         throw new IllegalArgumentException("Cannot add the same observer");
11.     }
12.     owner.getLifecycle().addObserver(wrapper);
13. }
15. // 生命周期事件处理（LifecycleBoundObserver.java）
16. @Override
17. public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
18.     if (source.getLifecycle().getCurrentState() == DESTROYED) {
19.         removeObserver(mObserver);
20.         return;
21.     }
22.     activeStateChanged(shouldBeActive());
23. }

复制代码

十三、表现层单元测试（源码级验证）

13.1 纯 UI 测试（不带 Room）

java

1. @RunWith(AndroidJUnit4::class)
2. public class UserAdapterTest {
3.     private UserAdapter adapter;
5.     @Before
6.     public void setup() {
7.         adapter = new UserAdapter(Collections.emptyList());
8.     }
10.     @Test
11.     public void testViewHolderBinding() {
12.         // 创建测试 View
13.         View itemView = LayoutInflater.from(ApplicationProvider.getApplicationContext())
14.            .inflate(R.layout.item_user, null);
15.         UserAdapter.ViewHolder holder = new UserAdapter.ViewHolder(itemView);
16.         
17.         // 绑定数据
18.         User user = new User(1, "张三", 25);
19.         adapter.onBindViewHolder(holder, 0);
20.         
21.         // 验证 UI 显示
22.         assertEquals("张三", holder.nameView.getText());
23.         assertEquals("25", holder.ageView.getText());
24.     }
26.     @Test
27.     public void testDiffUtil() {
28.         User oldUser = new User(1, "张三", 25);
29.         User newUser = new User(1, "张三", 26);
30.         
31.         // 测试内容变更
32.         assertEquals(false, USER_DIFF_CALLBACK.areContentsTheSame(oldUser, newUser));
33.     }
34. }

复制代码

13.2 集成测试（结合 Room 测试库）

java

1. @RunWith(AndroidJUnit4::class)
2. public class UserActivityTest {
3.     private final UserDao dao = Room.inMemoryDatabaseBuilder(
4.         ApplicationProvider.getApplicationContext(),
5.         AppDatabase.class
6.     ).allowMainThreadQueries().build().userDao();
8.     @Test
9.     public void testUserListUpdate() {
10.         // 插入测试数据
11.         dao.insert(new User(1, "李四", 30));
12.         
13.         // 启动 Activity
14.         ActivityScenario.launch(UserActivity.class);
15.         
16.         // 验证列表显示
17.         onView(withText("李四")).check(matches(isDisplayed()));
18.     }
20.     @Test
21.     public void testAddUserFlow() {
22.         // 启动添加用户 Activity
23.         ActivityScenario.launch(AddUserActivity.class);
24.         
25.         // 模拟输入
26.         onView(withId(R.id.edit_name)).perform(typeText("王五"));
27.         onView(withId(R.id.edit_age)).perform(typeText("28"));
28.         onView(withId(R.id.btn_add)).perform(click());
29.         
30.         // 验证列表更新
31.         onView(withText("王五")).check(matches(isDisplayed()));
32.     }
33. }

复制代码

十四、表现层设计模式实战

14.1 状态模式（UI 状态管理）

java

1. // UI 状态枚举
2. enum UiState {
3.     LOADING,
4.     CONTENT,
5.     ERROR
6. }
8. // Activity 中的状态管理
9. public class UserActivity extends AppCompatActivity {
10.     private UiState currentState = UiState.LOADING;
12.     private void updateState(UiState newState) {
13.         currentState = newState;
14.         runOnUiThread(() -> {
15.             switch (newState) {
16.                 case LOADING:
17.                     showLoading();
18.                     hideContent();
19.                     hideError();
20.                     break;
21.                 case CONTENT:
22.                     hideLoading();
23.                     showContent();
24.                     hideError();
25.                     break;
26.                 case ERROR:
27.                     hideLoading();
28.                     hideContent();
29.                     showError();
30.                     break;
31.             }
32.         });
33.     }
35.     // 框架内部的状态更新（ActivityThread.java）
36.     public void handleResumeActivity(IBinder token, boolean finalStateRequest) {
37.         // 恢复 Activity 状态
38.         performResumeActivity(token, finalStateRequest);
39.         // 触发 UI 状态更新
40.         mMainThreadHandler.obtainMessage(H.RESUME_ACTIVITY, token).sendToTarget();
41.     }
42. }

复制代码

14.2 策略模式（UI 样式切换）

java

1. // 主题策略接口
2. interface ThemeStrategy {
3.     int getBackgroundColor();
4.     int getTextColor();
5. }
7. // 浅色主题实现
8. class LightThemeStrategy implements ThemeStrategy {
9.     @Override
10.     public int getBackgroundColor() {
11.         return Color.WHITE;
12.     }
14.     @Override
15.     public int getTextColor() {
16.         return Color.BLACK;
17.     }
18. }
20. // Activity 中的策略应用
21. public class UserActivity extends AppCompatActivity {
22.     private ThemeStrategy themeStrategy = new LightThemeStrategy();
24.     @Override
25.     protected void onCreate(Bundle savedInstanceState) {
26.         super.onCreate(savedInstanceState);
27.         setContentView(R.layout.activity_user);
28.         
29.         // 应用主题策略
30.         userList.setBackgroundColor(themeStrategy.getBackgroundColor());
31.         titleView.setTextColor(themeStrategy.getTextColor());
32.     }
34.     // 动态切换主题
35.     public void switchToDarkTheme() {
36.         themeStrategy = new DarkThemeStrategy();
37.         recreate();
38.     }
39. }

复制代码

十五、表现层异常处理最佳实践

15.1 全局异常捕获（源码实现）

java

1. // 全局异常处理器
2. public class AppExceptionHandler implements Thread.UncaughtExceptionHandler {
3.     private final Thread.UncaughtExceptionHandler defaultHandler;
4.     private final Context context;
6.     public AppExceptionHandler(Context context) {
7.         this.context = context;
8.         defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
9.     }
11.     @Override
12.     public void uncaughtException(Thread thread, Throwable ex) {
13.         if (ex instanceof SQLiteException) {
14.             // 处理 Room 数据库异常
15.             showDatabaseError(ex);
16.             return;
17.         }
18.         defaultHandler.uncaughtException(thread, ex);
19.     }
21.     private void showDatabaseError(Throwable ex) {
22.         new AlertDialog.Builder(context)
23.            .setTitle("数据库错误")
24.            .setMessage("数据加载失败：" + ex.getMessage())
25.            .setPositiveButton("重试", (dialog, which) -> recreate())
26.            .show();
27.     }
28. }
30. // 在 Application 中注册
31. public class AppApplication extends Application {
32.     @Override
33.     public void onCreate() {
34.         super.onCreate();
35.         Thread.setDefaultUncaughtExceptionHandler(new AppExceptionHandler(this));
36.     }
37. }

复制代码

15.2 Room 异常转换（表现层适配）

java

1. // 在 Repository 中封装异常
2. class UserRepository {
3.     public LiveData<List<User>> getUsers() {
4.         return Transformations.map(dao.getAllUsers(), users -> {
5.             try {
6.                 return users;
7.             } catch (SQLiteException e) {
8.                 // 转换为表现层可识别的异常
9.                 throw new UiDataException("数据库查询失败", e);
10.             }
11.         });
12.     }
13. }
15. // Activity 中的异常处理
16. userViewModel.users.observe(this, users -> {
17.     if (users instanceof UiDataException) {
18.         showError((UiDataException) users);
19.         return;
20.     }
21.     updateUI(users);
22. });

复制代码

十六、总结：表现层的 Room 集成哲学

16.1 源码架构总览

plaintext

1. 表现层
2. ├─ Activity/Fragment （UI 宿主）
3. │  ├─ ViewModel （数据与逻辑）
4. │  └─ LiveData/State （数据订阅）
5. ├─ RecyclerView/Compose （数据展示）
6. │  ├─ Adapter （数据绑定）
7. │  └─ DiffUtil （增量更新）
8. ├─ DataBinding （视图绑定）
9. └─ 无障碍/动画/性能 （体验优化）
11. Room 依赖
12. ├─ DAO （数据访问接口）
13. ├─ LiveData/Flow （数据订阅源）
14. └─ TypeConverter （数据转换）

复制代码

16.2 核心设计原则

• 单向数据流：Room → ViewModel → UI，确保状态可追溯（参考 LiveData 源码）
  
• 生命周期感知：通过 LifecycleOwner 管理 Room 查询（ViewModel 内部实现）
  
• 增量更新：利用 DiffUtil 和 RecyclerView 局部革新（减少绘制操作）
  
• 异步抽象：通过协程 / LiveData 隐藏 Room 线程细节（SuspendSupport 源码）
  
• 防御性编程：在 UI 层处理 Room 异常（SQLiteException 转换）
  

16.3 性能优化清单

优化点实现方式源码位置列表更新DiffUtil + RecyclerView 局部革新ListAdapter.java数据订阅LiveData 自动生命周期绑定LifecycleBoundObserver.java结构性能DataBinding 替代 findViewByIdDataBinderMapperImpl.java内存管理ViewModel 绑定 Room 单例ViewModelStore.java动画优化默认 ItemAnimator + 自界说过渡DefaultItemAnimator.java 16.4 反模式规避

• ❌ 在 Activity 直接操作 Room DAO（紧耦合）
  ✅ 通过 ViewModel 间接访问（参考 UserViewModel 源码）
  
• ❌ 忽略 DiffUtil 导致全量革新（性能损耗）
  ✅ 使用 ListAdapter 逼迫差分更新（源码逼迫实现 getItemId）
  
• ❌ 在 UI 线程执行 Room 查询（ANR 风险）
  ✅ 通过 LiveData / 协程自动切换线程（RoomDatabase 内部查抄）
  
• ❌ 复杂结构嵌套（过分绘制）
  ✅ 使用 ConstraintLayout + 扁平化结构（减少层级）
  
• ❌ 内存走漏（未取消订阅）
  ✅ LiveData 自动解绑（LifecycleOwner 机制）
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。