MVP MVC 和 MVVM 之间的区别

Java

MVP、MVC和MVVM的区别及案例代码

在软件开发中，MVP（Model-View-Presenter）、MVC（Model-View-Controller）和MVVM（Model-View-ViewModel）是常用的架构模式。它们都旨在将应用程序的业务逻辑和用户界面分离，以提高代码的可维护性和可测试性。尽管它们有共同之处，但每种模式都有自己的特点和适用场景。本文将讨论MVP、MVC和MVVM之间的区别，并通过案例代码来说明它们的实际用法。

MVP（Model-View-Presenter）

MVP模式是一种将用户界面、业务逻辑和数据分离的架构模式。在MVP中，View负责展示数据和接收用户输入，Model负责处理数据逻辑，Presenter作为中间人连接View和Model，负责处理用户输入、更新视图和调用Model进行数据操作。

在MVP中，View和Model是完全独立的，它们之间通过Presenter进行通信。这种分离使得视图和逻辑可以进行单独的测试和维护，并且可以更容易地对视图和逻辑进行修改和扩展。

下面是一个使用MVP模式的简单登录功能的案例代码：

Java
// Model
public class UserModel {
    private String username;
    private String password;
    public UserModel(String username, String password) {
        this.username = username;
        this.password = password;
    }
    public boolean isValid() {
        // 校验用户名和密码是否有效
        return !TextUtils.isEmpty(username) && !TextUtils.isEmpty(password);
    }
}
// View
public interface LoginView {
    void showLoading();
    void hideLoading();
    void showSuccess();
    void showError();
}
// Presenter
public class LoginPresenter {
    private LoginView loginView;
    private UserModel userModel;
    public LoginPresenter(LoginView loginView) {
        this.loginView = loginView;
    }
    public void login(String username, String password) {
        loginView.showLoading();
        userModel = new UserModel(username, password);
        if (userModel.isValid()) {
            loginView.showSuccess();
        } else {
            loginView.showError();
        }
        loginView.hideLoading();
    }
}
// Activity/Fragment
public class LoginActivity extends AppCompatActivity implements LoginView {
    private EditText etUsername;
    private EditText etPassword;
    private Button btnLogin;
    private ProgressBar progressBar;
    private LoginPresenter loginPresenter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setcontentView(R.layout.activity_login);
        etUsername = findViewById(R.id.et_username);
        etPassword = findViewById(R.id.et_password);
        btnLogin = findViewById(R.id.btn_login);
        progressBar = findViewById(R.id.progress_bar);
        loginPresenter = new LoginPresenter(this);
        btnLogin.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String username = etUsername.getText().toString();
                String password = etPassword.getText().toString();
                loginPresenter.login(username, password);
            }
        });
    }
    @Override
    public void showLoading() {
        progressBar.setVisibility(View.VISIBLE);
    }
    @Override
    public void hideLoading() {
        progressBar.setVisibility(View.GONE);
    }
    @Override
    public void showSuccess() {
        Toast.makeText(this, "登录成功", Toast.LENGTH_SHORT).show();
    }
    @Override
    public void showError() {
        Toast.makeText(this, "登录失败，请检查用户名和密码", Toast.LENGTH_SHORT).show();
    }
}

MVC（Model-View-Controller）

MVC模式是一种将应用程序分为三个部分：模型（Model）、视图（View）和控制器（Controller）。模型负责处理数据和业务逻辑，视图负责展示数据和接收用户输入，控制器负责处理用户输入、更新视图和调用模型进行数据操作。

MVC与MVP最大的区别在于控制器（Controller）的存在。在MVC中，视图（View）与模型（Model）是相互独立的，它们之间通过控制器（Controller）进行交互。控制器（Controller）接收用户输入，并根据输入的类型和内容来调用相应的模型方法和更新视图。

下面是一个使用MVC模式的简单计算器功能的案例代码：

Java
// Model
public class CalculatorModel {
    public int add(int num1, int num2) {
        return num1 + num2;
    }
    public int subtract(int num1, int num2) {
        return num1 - num2;
    }
    public int multiply(int num1, int num2) {
        return num1 * num2;
    }
    public int divide(int num1, int num2) {
        if (num2 == 0) {
            throw new IllegalArgumentException("除数不能为0");
        }
        return num1 / num2;
    }
}
// View
public interface CalculatorView {
    void showResult(int result);
    void showError(String message);
}
// Controller
public class CalculatorController {
    private CalculatorView calculatorView;
    private CalculatorModel calculatorModel;
    public CalculatorController(CalculatorView calculatorView) {
        this.calculatorView = calculatorView;
        calculatorModel = new CalculatorModel();
    }
    public void add(int num1, int num2) {
        try {
            int result = calculatorModel.add(num1, num2);
            calculatorView.showResult(result);
        } catch (Exception e) {
            calculatorView.showError(e.getMessage());
        }
    }
    public void subtract(int num1, int num2) {
        try {
            int result = calculatorModel.subtract(num1, num2);
            calculatorView.showResult(result);
        } catch (Exception e) {
            calculatorView.showError(e.getMessage());
        }
    }
    public void multiply(int num1, int num2) {
        try {
            int result = calculatorModel.multiply(num1, num2);
            calculatorView.showResult(result);
        } catch (Exception e) {
            calculatorView.showError(e.getMessage());
        }
    }
    public void divide(int num1, int num2) {
        try {
            int result = calculatorModel.divide(num1, num2);
            calculatorView.showResult(result);
        } catch (Exception e) {
            calculatorView.showError(e.getMessage());
        }
    }
}
// Activity/Fragment
public class CalculatorActivity extends AppCompatActivity implements CalculatorView {
    private EditText etNum1;
    private EditText etNum2;
    private Button btnAdd;
    private Button btnSubtract;
    private Button btnMultiply;
    private Button btnDivide;
    private TextView tvResult;
    private CalculatorController calculatorController;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setcontentView(R.layout.activity_calculator);
        etNum1 = findViewById(R.id.et_num1);
        etNum2 = findViewById(R.id.et_num2);
        btnAdd = findViewById(R.id.btn_add);
        btnSubtract = findViewById(R.id.btn_subtract);
        btnMultiply = findViewById(R.id.btn_multiply);
        btnDivide = findViewById(R.id.btn_divide);
        tvResult = findViewById(R.id.tv_result);
        calculatorController = new CalculatorController(this);
        btnAdd.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                int num1 = Integer.parseInt(etNum1.getText().toString());
                int num2 = Integer.parseInt(etNum2.getText().toString());
                calculatorController.add(num1, num2);
            }
        });
        // 同样的方式处理减法、乘法和除法的点击事件
    }
    @Override
    public void showResult(int result) {
        tvResult.setText(String.valueOf(result));
    }
    @Override
    public void showError(String message) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
    }
}

MVVM（Model-View-ViewModel）

MVVM模式是一种将用户界面、业务逻辑和数据分离的架构模式。在MVVM中，View负责展示数据和接收用户输入，Model负责处理数据逻辑，ViewModel作为中间人连接View和Model，负责处理用户输入、更新视图和调用Model进行数据操作。

与MVP模式不同的是，MVVM模式使用数据绑定来实现View和ViewModel的通信，当ViewModel中的数据发生变化时，View会自动更新，而无需手动编写更新视图的代码。

下面是一个使用MVVM模式的简单列表展示功能的案例代码：

Java
// Model
public class Item {
    private String name;
    public Item(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
// ViewModel
public class ItemViewModel extends ViewModel {
    private MutableLiveData<List<Item>> itemsLiveData;
    public LiveData<List<Item>> getItems() {
        if (itemsLiveData == null) {
            itemsLiveData = new MutableLiveData<>();
            loadItems();
        }
        return itemsLiveData;
    }
    private void loadItems() {
        // 模拟从数据源加载数据
        List<Item> items = new ArrayList<>();
        items.add(new Item("Item 1"));
        items.add(new Item("Item 2"));
        items.add(new Item("Item 3"));
        itemsLiveData.setValue(items);
    }
}
// Activity/Fragment
public class MAInActivity extends AppCompatActivity {
    private RecyclerView recyclerView;
    private ItemAdapter itemAdapter;
    private ItemViewModel itemViewModel;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setcontentView(R.layout.activity_mAIn);
        recyclerView = findViewById(R.id.recycler_view);
        recyclerView.setLayoutManager(new LinearLayoutManager(this));
        itemAdapter = new ItemAdapter();
        recyclerView.setAdapter(itemAdapter);
        itemViewModel = ViewModelProviders.of(this).get(ItemViewModel.class);
        itemViewModel.getItems().observe(this, new Observer<List<Item>>() {
            @Override
            public void onChanged(List<Item> items) {
                itemAdapter.setItems(items);
            }
        });
    }
}
// Adapter
public class ItemAdapter extends RecyclerView.Adapter<ItemAdapter.ItemViewHolder> {
    private List<Item> items;
    public void setItems(List<Item> items) {
        this.items = items;
        notifyDataSetchanged();
    }
    @NonNull
    @Override
    public ItemViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(parent.getcontext()).inflate(R.layout.item_list, parent, false);
        return new ItemViewHolder(itemView);
    }
    @Override
    public void onBindViewHolder(@NonNull ItemViewHolder holder, int position) {
        Item item = items.get(position);
        holder.bind(item);
    }
    @Override
    public int getItemCount() {
        return items != null ? items.size() : 0;
    }
    public class ItemViewHolder extends RecyclerView.ViewHolder {
        private TextView tvName;
        public ItemViewHolder(@NonNull View itemView) {
            super(itemView);
            tvName = itemView.findViewById(R.id.tv_name);
        }
        public void bind(Item item) {
            tvName.setText(item.getName());
        }
    }
}

MVP、MVC和MVVM都是常用的架构模式，它们通过将应用程序的不同部分分离，提高了代码的可维护性和可测试性。MVP适用于需要高度可测试和可维护的项目，MVC适用于需要更紧密耦合的项目，而MVVM适用于需要实现数据绑定和自动视图更新的项目。根据项目的需求和团队的偏好，选择适合的架构模式可以提高开发效率和代码质量。