MVVM（Model-View-ViewModel）架构模式

最新推荐文章于 2025-10-31 10:48:03 发布

原创最新推荐文章于 2025-10-31 10:48:03 发布 · 2.6k 阅读

CC 4.0 BY-SA版权

文章标签：

在Android开发中，MVVM（Model-View-ViewModel）架构模式已经成为构建可维护和可扩展应用程序的重要选择。MVVM模式通过分离视图（View）、模型（Model）和视图模型（ViewModel）来提高代码的可读性、可测试性和可维护性。本文将详细探讨MVVM模式在Android架构组件中的实战应用，通过具体示例来说明如何搭建和实现MVVM架构。

一、MVVM架构概述

MVVM模式由三部分组成：Model（模型）、View（视图）和ViewModel（视图模型）。在Android开发中，这三部分各自承担着不同的职责：

Model：承载业务逻辑与数据实体，独立于UI并与ViewModel进行交互，实现数据获取与处理功能。
View：用户界面层，负责显示数据和接收用户输入。在Android中，通常使用XML布局文件和Activity/Fragment等组件来创建视图。
ViewModel：作为View与Model之间的桥梁，封装UI状态与逻辑，具备生命周期感知特性，确保在配置改变时数据得以持久保存。

二、实战应用步骤

1. 准备工作

在开始MVVM架构的实战应用之前，需要准备一些必要的依赖库和工具。Android Jetpack提供了许多有助于实现MVVM架构的组件，如LiveData、ViewModel和Room等。此外，还可以引入Dagger2进行依赖注入，RxJava进行反应式编程，以及FastAndroidNetworking进行网络请求。

添加依赖

在项目的build.gradle文件中添加以下依赖：

dependencies {
    // ViewModel和LiveData
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.0"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.4.0"

    // Room数据库
    implementation "androidx.room:room-runtime:2.4.0"
    annotationProcessor "androidx.room:room-compiler:2.4.0"

    // Dagger2
    implementation 'com.google.dagger:dagger:2.38.1'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.38.1'

    // RxJava
    implementation 'io.reactivex.rxjava3:rxjava:3.1.2'

    // FastAndroidNetworking
    implementation 'com.amitshekhar.android:android-networking:1.0.2'

    // 其他必要依赖...
}

2. 创建Model层

Model层负责数据管理和业务逻辑处理。在Android中，可以使用Java类来定义数据模型，或者使用Room数据库来管理持久化数据。

示例数据模型

public class User {
    private String name;
    private int age;

    // 构造函数、Getter和Setter方法
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter和Setter省略...
}

Room数据库

如果需要持久化存储数据，可以使用Room。首先定义一个Dao接口，然后创建数据库类。

@Dao
public interface UserDao {
    @Insert
    void insert(User user);

    @Query("SELECT * FROM user_table")
    LiveData<List<User>> getAllUsers();
}

@Database(entities = {User.class}, version = 1, exportSchema = false)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();

    // 单例获取数据库实例
    private static volatile AppDatabase INSTANCE;

    public static AppDatabase getDatabase(Context context) {
        if (INSTANCE == null) {
            synchronized (AppDatabase.class) {
                if (INSTANCE == null) {
                    INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                            AppDatabase.class, "app_database")
                            .build();
                }
            }
        }
        return INSTANCE;
    }
}

3. 创建ViewModel层

ViewModel层负责封装UI相关的逻辑和数据，具有生命周期感知能力。通过LiveData，ViewModel可以确保在UI组件的生命周期内更新数据。

示例ViewModel

public class UserViewModel extends ViewModel {
    private MutableLiveData<User> userLiveData;
    private UserDao userDao;

    public UserViewModel(Application application) {
        AppDatabase db = AppDatabase.getDatabase(application);
        userDao = db.userDao();
        userLiveData
        = new MutableLiveData<>();

        // 假设我们从数据库加载用户数据
        loadUser();
    }

    private void loadUser() {
        // 使用LiveData来监听数据库变化
        userLiveData.setValue(null); // 初始化为null或默认用户对象
        // 这里使用LiveData从Room获取数据，Room已经处理了线程切换
        userDao.getAllUsers().observeForever(new Observer<List<User>>() {
            @Override
            public void onChanged(List<User> users) {
                if (!users.isEmpty()) {
                    // 假设我们只关心第一个用户
                    userLiveData.setValue(users.get(0));
                }
                // 注意：在实际应用中，可能需要移除这个observeForever监听器，
                // 或者使用ViewModel的onCleared()方法来处理
            }
        });

        // 注意：上面的代码示例中，直接使用observeForever可能不是最佳实践，
        // 因为这会导致ViewModel持有LiveData的永久引用，从而可能导致内存泄漏。
        // 更好的做法是在Fragment或Activity中通过getViewLifecycleOwner().observe()来观察LiveData。
        // 但为了简单起见，这里使用了observeForever。
    }

    public LiveData<User> getUserLiveData() {
        return userLiveData;
    }

    // 还可以添加其他方法来处理用户数据的更新、删除等操作
}

4. 创建View层

View层负责展示数据和接收用户输入。在Android中，这通常是通过Activity或Fragment来实现的，同时结合XML布局文件来定义界面。

示例Fragment

public class UserFragment extends Fragment {

    private UserViewModel userViewModel;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_user, container, false);

        // 获取ViewModel实例
        userViewModel = ViewModelProviders.of(this).get(UserViewModel.class);

        // 观察LiveData变化并更新UI
        userViewModel.getUserLiveData().observe(getViewLifecycleOwner(), new Observer<User>() {
            @Override
            public void onChanged(User user) {
                // 更新UI，例如显示用户名称和年龄
                TextView userName = view.findViewById(R.id.user_name);
                TextView userAge = view.findViewById(R.id.user_age);
                if (user != null) {
                    userName.setText(user.getName());
                    userAge.setText(String.valueOf(user.getAge()));
                }
            }
        });

        return view;
    }
}

注意：从Android Jetpack的androidx.lifecycle:lifecycle-extensions:2.x.x版本开始，推荐使用ViewModelProvider.Factory来创建ViewModel的实例，并通过ViewModelProvider.of(this, factory)来获取ViewModel。但从androidx.lifecycle:lifecycle-viewmodel-ktx:2.x.x开始，可以直接使用ViewModelProvider.of(this)来获取ViewModel实例，因为库内部已经处理了ViewModel的创建和缓存逻辑。

5. 总结

通过以上步骤，我们实现了一个简单的MVVM架构在Android中的应用。Model层负责数据管理，ViewModel层负责封装UI逻辑和数据，View层负责展示数据和接收用户输入。这样的架构使得代码更加清晰、易于维护和测试。在实际项目中，还可以结合Dagger2进行依赖注入，RxJava进行反应式编程等高级特性，来进一步提升应用的性能和可维护性。