MVC架构的介绍和使用

已于 2025-11-24 15:38:25 修改
阅读量488 收藏 8
点赞数 7
CC 4.0 BY-SA版权
分类专栏： Qt项目实战 文章标签： mvc 架构
于 2025-11-20 23:20:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/TechNomad/article/details/155076478

文章目录

一、什么是 MVC？

MVC = Model（模型） + View（视图） + Controller（控制器）
它是一种非常经典的软件架构模式，用来实现：

  • 界面与业务逻辑解耦
  • 数据与 UI 分离
  • 便于扩展、维护、单元测试

二、MVC 各部分的职责

Model（模型）
负责数据和业务逻辑，包括：

  • 数据结构（类、结构体）
  • 数据处理、计算
  • 数据读写（数据库、网络等）
  • 状态管理

Model 不关心界面如何展示数据。

View（视图）
负责显示数据（UI 部分），通常包括：

  • 一切界面元素（按钮、表格、文本、控件）
  • 与用户的交互（点击、输入等）
  • 视觉样式

View 不包含业务逻辑。

Controller（控制器）
负责协调 Model 和 View 之间的交互。

  • 接收 View 的事件（点击按钮、选择项等）
  • 调用 Model 完成数据处理
  • 将 Model 的结果更新到 View

三、MVC 数据流

典型流程：

用户操作 View（UI）
        ↓
Controller 接管事件
        ↓
Controller 调用 Model 修改数据
        ↓
Model 处理数据后通知 Controller / View
        ↓
View 根据结果刷新界面

MVC 架构图（简化）

+-----------+        +-------------+        +---------+
|   View    |  <---> | Controller  | <--->  | Model   |
+-----------+        +-------------+        +---------+
    ↑                                               |
    |________________________ 数据变化通知 __________|

四、完整示例

加法/减法/乘法/除法计算器的 MVC 示例

  • 不暴露成员变量
  • 控制器不直接操作 UI
  • Model 使用私有成员 + getter/setter
  • View 只负责显示，不参与计算
  • Controller 完整隔离业务逻辑

整个代码结构如下：

CalculatorModel   —— 数据与业务逻辑（计算）
CalculatorView    —— UI 层
CalculatorController —— 事件与逻辑调度

1.CalculatorView（UI 层，只负责输入与输出）

// CalculatorView.h
#pragma once
#include <QWidget>

QT_BEGIN_NAMESPACE
class QLineEdit;
class QPushButton;
QT_END_NAMESPACE

class CalculatorView : public QWidget
{
    Q_OBJECT
public:
    explicit CalculatorView(QWidget* parent=nullptr);

    double operandA() const;
    double operandB() const;
    void setResult(double value);

signals:
    void addRequested();
    void subRequested();
    void mulRequested();
    void divRequested();

private:
    QLineEdit* m_editA;
    QLineEdit* m_editB;
    QLineEdit* m_editResult;

    QPushButton* m_btnAdd;
    QPushButton* m_btnSub;
    QPushButton* m_btnMul;
    QPushButton* m_btnDiv;
};

// CalculatorView.cpp
#include "CalculatorView.h"
#include <QGridLayout>
#include <QLineEdit>
#include <QPushButton>

CalculatorView::CalculatorView(QWidget* parent)
    : QWidget(parent)
{
    m_editA = new QLineEdit(this);
    m_editB = new QLineEdit(this);
    m_editResult = new QLineEdit(this);
    m_editResult->setReadOnly(true);

    m_btnAdd = new QPushButton("+", this);
    m_btnSub = new QPushButton("-", this);
    m_btnMul = new QPushButton("*", this);
    m_btnDiv = new QPushButton("/", this);

    auto layout = new QGridLayout(this);
    layout->addWidget(m_editA, 0, 0, 1, 2);
    layout->addWidget(m_editB, 1, 0, 1, 2);
    layout->addWidget(m_editResult, 2, 0, 1, 2);

    layout->addWidget(m_btnAdd, 3, 0);
    layout->addWidget(m_btnSub, 3, 1);
    layout->addWidget(m_btnMul, 4, 0);
    layout->addWidget(m_btnDiv, 4, 1);

    connect(m_btnAdd, &QPushButton::clicked, this, &CalculatorView::addRequested);
    connect(m_btnSub, &QPushButton::clicked, this, &CalculatorView::subRequested);
    connect(m_btnMul, &QPushButton::clicked, this, &CalculatorView::mulRequested);
    connect(m_btnDiv, &QPushButton::clicked, this, &CalculatorView::divRequested);
}

double CalculatorView::operandA() const
{
    return m_editA->text().toDouble();
}

double CalculatorView::operandB() const
{
    return m_editB->text().toDouble();
}

void CalculatorView::setResult(double value)
{
    m_editResult->setText(QString::number(value));
}

2. CalculatorModel（数据模型，真正的计算实现）

// CalculatorModel.h
#pragma once
#include <QObject>

class CalculatorModel : public QObject
{
    Q_OBJECT

public:
    explicit CalculatorModel(QObject* parent=nullptr);

    void setOperands(double a, double b);
    double operandA() const;
    double operandB() const;

    double add() const;
    double sub() const;
    double mul() const;
    double div(bool& ok) const;

private:
    double m_a = 0;
    double m_b = 0;
};

// CalculatorModel.cpp
#include "CalculatorModel.h"

CalculatorModel::CalculatorModel(QObject* parent)
    : QObject(parent)
{
}

void CalculatorModel::setOperands(double a, double b)
{
    m_a = a;
    m_b = b;
}

double CalculatorModel::operandA() const { return m_a; }
double CalculatorModel::operandB() const { return m_b; }

double CalculatorModel::add() const { return m_a + m_b; }
double CalculatorModel::sub() const { return m_a - m_b; }
double CalculatorModel::mul() const { return m_a * m_b; }

double CalculatorModel::div(bool& ok) const
{
    if (m_b == 0) {
        ok = false;
        return 0;
    }
    ok = true;
    return m_a / m_b;
}

3. CalculatorController（逻辑调度层，MVC 核心）

// CalculatorController.h
#pragma once
#include <QObject>

class CalculatorModel;
class CalculatorView;

class CalculatorController : public QObject
{
    Q_OBJECT
public:
    CalculatorController(CalculatorModel* model,
                         CalculatorView* view,
                         QObject* parent=nullptr);

private slots:
    void onAdd();
    void onSub();
    void onMul();
    void onDiv();

private:
    CalculatorModel* m_model;
    CalculatorView* m_view;
};

// CalculatorController.cpp
#include "CalculatorController.h"
#include "CalculatorModel.h"
#include "CalculatorView.h"

CalculatorController::CalculatorController(
        CalculatorModel* model,
        CalculatorView* view,
        QObject* parent)
    : QObject(parent)
    , m_model(model)
    , m_view(view)
{
    connect(m_view, &CalculatorView::addRequested, this, &CalculatorController::onAdd);
    connect(m_view, &CalculatorView::subRequested, this, &CalculatorController::onSub);
    connect(m_view, &CalculatorView::mulRequested, this, &CalculatorController::onMul);
    connect(m_view, &CalculatorView::divRequested, this, &CalculatorController::onDiv);
}

void CalculatorController::onAdd()
{
    m_model->setOperands(m_view->operandA(), m_view->operandB());
    m_view->setResult(m_model->add());
}

void CalculatorController::onSub()
{
    m_model->setOperands(m_view->operandA(), m_view->operandB());
    m_view->setResult(m_model->sub());
}

void CalculatorController::onMul()
{
    m_model->setOperands(m_view->operandA(), m_view->operandB());
    m_view->setResult(m_model->mul());
}

void CalculatorController::onDiv()
{
    m_model->setOperands(m_view->operandA(), m_view->operandB());
    bool ok = true;
    double r = m_model->div(ok);
    if (!ok)
        m_view->setResult(0), qWarning("除数不能为0");
    else
        m_view->setResult(r);
}

调用：

#include <QApplication>

#include "calculator_model.h"
#include "calculator_view.h"
#include "calculator_controller.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    CalculatorView view;
    CalculatorModel model;
    CalculatorController(&model, &view);

    view.show();
    return a.exec();
}

Signal + Slot 版的 MVC 架构

  • Controller → Model 全靠 signal/slot，不直接调用函数
  • Model → View 更新结果也靠 signal/slot
  • Controller 不暴露成员，Model 不暴露内部变量
  • View 只发送 UI 的操作，不做业务逻辑

1. Model（数据 + 计算逻辑）
CalculatorModel.h

#pragma once
#include <QObject>

class CalculatorModel : public QObject
{
    Q_OBJECT
public:
    explicit CalculatorModel(QObject *parent = nullptr);

signals:
    void resultChanged(double result);

public slots:
    void onAdd(double a, double b);
    void onSub(double a, double b);
    void onMul(double a, double b);
    void onDiv(double a, double b);
};

CalculatorModel.cpp

#include "CalculatorModel.h"

CalculatorModel::CalculatorModel(QObject *parent)
    : QObject(parent)
{
}

void CalculatorModel::onAdd(double a, double b)
{
    emit resultChanged(a + b);
}

void CalculatorModel::onSub(double a, double b)
{
    emit resultChanged(a - b);
}

void CalculatorModel::onMul(double a, double b)
{
    emit resultChanged(a * b);
}

void CalculatorModel::onDiv(double a, double b)
{
    if (b == 0)
    {
        emit resultChanged(std::numeric_limits<double>::infinity());
        return;
    }
    emit resultChanged(a / b);
}

2. Controller（纯转发：View → Model）
CalculatorController.h

#pragma once
#include <QObject>

class CalculatorModel;

class CalculatorController : public QObject
{
    Q_OBJECT
public:
    explicit CalculatorController(CalculatorModel *model, QObject *parent = nullptr);

signals:
    // Controller 接收 View 的请求（UI 发来指令）
    void addRequested(double a, double b);
    void subRequested(double a, double b);
    void mulRequested(double a, double b);
    void divRequested(double a, double b);

private:
    CalculatorModel *m_model;
};

CalculatorController.cpp

#include "CalculatorController.h"
#include "CalculatorModel.h"

CalculatorController::CalculatorController(CalculatorModel *model, QObject *parent)
    : QObject(parent), m_model(model)
{
    // Controller 的请求信号 → Model 的槽函数
    connect(this, &CalculatorController::addRequested, m_model, &CalculatorModel::onAdd);
    connect(this, &CalculatorController::subRequested, m_model, &CalculatorModel::onSub);
    connect(this, &CalculatorController::mulRequested, m_model, &CalculatorModel::onMul);
    connect(this, &CalculatorController::divRequested, m_model, &CalculatorModel::onDiv);
}

3. View（UI 触发操作 + 显示 Model 的结果）
CalculatorView.h

#pragma once
#include <QWidget>

class CalculatorController;

class CalculatorView : public QWidget
{
    Q_OBJECT
public:
    explicit CalculatorView(CalculatorController *controller, QWidget *parent = nullptr);

signals:
    void calculateAdd(double a, double b);
    void calculateSub(double a, double b);
    void calculateMul(double a, double b);
    void calculateDiv(double a, double b);

public slots:
    void onResultChanged(double result);

private:
    CalculatorController *m_controller;
    QLineEdit *m_editA;
    QLineEdit *m_editB;
    QLabel *m_labelResult;
};

CalculatorView.cpp

#include "CalculatorView.h"
#include "CalculatorController.h"
#include <QPushButton>
#include <QLineEdit>
#include <QLabel>
#include <QVBoxLayout>

CalculatorView::CalculatorView(CalculatorController *controller, QWidget *parent)
    : QWidget(parent), m_controller(controller)
{
    m_editA = new QLineEdit(this);
    m_editB = new QLineEdit(this);
    m_labelResult = new QLabel("结果：", this);

    auto btnAdd = new QPushButton("加法", this);
    auto btnSub = new QPushButton("减法", this);
    auto btnMul = new QPushButton("乘法", this);
    auto btnDiv = new QPushButton("除法", this);

    auto layout = new QVBoxLayout(this);
    layout->addWidget(m_editA);
    layout->addWidget(m_editB);
    layout->addWidget(btnAdd);
    layout->addWidget(btnSub);
    layout->addWidget(btnMul);
    layout->addWidget(btnDiv);
    layout->addWidget(m_labelResult);

    // View 的信号 → Controller
    connect(btnAdd, &QPushButton::clicked, this, [=](){
        emit m_controller->addRequested(m_editA->text().toDouble(), m_editB->text().toDouble());
    });
    connect(btnSub, &QPushButton::clicked, this, [=](){
        emit m_controller->subRequested(m_editA->text().toDouble(), m_editB->text().toDouble());
    });
    connect(btnMul, &QPushButton::clicked, this, [=](){
        emit m_controller->mulRequested(m_editA->text().toDouble(), m_editB->text().toDouble());
    });
    connect(btnDiv, &QPushButton::clicked, this, [=](){
        emit m_controller->divRequested(m_editA->text().toDouble(), m_editB->text().toDouble());
    });
}

void CalculatorView::onResultChanged(double result)
{
    m_labelResult->setText(QString("结果：%1").arg(result));
}

4. main.cpp：连接 View ← Model

#include <QApplication>
#include "CalculatorModel.h"
#include "CalculatorController.h"
#include "CalculatorView.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    CalculatorModel model;
    CalculatorController controller(&model);
    CalculatorView view(&controller);

    // Model → View
    QObject::connect(&model, &CalculatorModel::resultChanged,
                     &view, &CalculatorView::onResultChanged);

    view.show();
    return a.exec();
}

加/减/乘/除计算器的 MVC + Q_PROPERTY 示例
1.Model（业务逻辑，不直接暴露 UI，但用 Q_PROPERTY 让结果可观察）

#ifndef CALCULATORMODEL_H
#define CALCULATORMODEL_H

#include <QObject>

class CalculatorModel : public QObject
{
    Q_OBJECT
    Q_PROPERTY(double result READ result NOTIFY resultChanged)

public:
    explicit CalculatorModel(QObject *parent = nullptr) : QObject(parent) {}

    double result() const { return m_result; }

public slots:
    void add(double a, double b) { setResult(a + b); }
    void sub(double a, double b) { setResult(a - b); }
    void mul(double a, double b) { setResult(a * b); }
    void div(double a, double b) {
        if(b == 0) setResult(0);
        else setResult(a / b);
    }

signals:
    void resultChanged();

private:
    void setResult(double value) {
        if(m_result != value) {
            m_result = value;
            emit resultChanged();
        }
    }

    double m_result = 0;
};

#endif // CALCULATORMODEL_H

2.Controller（纯转发 View → Model）

#ifndef CALCULATORCONTROLLER_H
#define CALCULATORCONTROLLER_H

#include <QObject>

#include "calculator_model.h"
#include "calculator_view.h"

class CalculatorController : public QObject
{
    Q_OBJECT
public:
    explicit CalculatorController(CalculatorModel* model, CalculatorView* view, QObject* parent = nullptr)
        : QObject(parent), m_model(model), m_view(view) {

        // View → Controller
        connect(m_view, &CalculatorView::addRequested, this, &CalculatorController::handleAdd);
        connect(m_view, &CalculatorView::subRequested, this, &CalculatorController::handleSub);
        connect(m_view, &CalculatorView::mulRequested, this, &CalculatorController::handleMul);
        connect(m_view, &CalculatorView::divRequested, this, &CalculatorController::handleDiv);

        // Model (Q_PROPERTY result) → View
        connect(m_model, &CalculatorModel::resultChanged, [&](){
            m_view->updateResult(m_model->result());
        });
    }

    // 接收 View 信号 → 转发到 Model
public slots:
    void handleAdd(double a, double b) { m_model->add(a, b); }
    void handleSub(double a, double b) { m_model->sub(a, b); }
    void handleMul(double a, double b) { m_model->mul(a, b); }
    void handleDiv(double a, double b) { m_model->div(a, b); }

private:
    CalculatorModel* m_model;
    CalculatorView*  m_view;
};

#endif // CALCULATORCONTROLLER_H

3.View（UI 完全不做计算，只发送信号和显示结果）

ifndef CALCULATORVIEW_H
#define CALCULATORVIEW_H

#include <QWidget>

class QLineEdit;
class QPushButton;
class QLabel;

class CalculatorView : public QWidget
{
    Q_OBJECT
public:
    explicit CalculatorView(QWidget* parent = nullptr);

signals:
    void addRequested(double a, double b);
    void subRequested(double a, double b);
    void mulRequested(double a, double b);
    void divRequested(double a, double b);

public slots:
    void updateResult(double r);

private:
    QLineEdit* m_editA;
    QLineEdit* m_editB;
    QLabel* m_labelResult;
};
#endif // CALCULATORVIEW_H

#include "calculator_view.h"

#include <QLineEdit>
#include <QPushButton>
#include <QLabel>
#include <QGridLayout>
#include <QString>

CalculatorView::CalculatorView(QWidget* parent)
    : QWidget(parent)
{
    m_editA = new QLineEdit(this);
    m_editB = new QLineEdit(this);
    m_labelResult = new QLabel("结果: 0", this);

    auto btnAdd = new QPushButton("+", this);
    auto btnSub = new QPushButton("-", this);
    auto btnMul = new QPushButton("*", this);
    auto btnDiv = new QPushButton("/", this);

    auto layout = new QGridLayout(this);
    layout->addWidget(m_editA, 0, 0, 1, 2);
    layout->addWidget(m_editB, 1, 0, 1, 2);
    layout->addWidget(btnAdd, 2, 0);
    layout->addWidget(btnSub, 2, 1);
    layout->addWidget(btnMul, 3, 0);
    layout->addWidget(btnDiv, 3, 1);
    layout->addWidget(m_labelResult, 4, 0, 1, 2);

    // 按钮点击 → Controller
    connect(btnAdd, &QPushButton::clicked, this, [=](){
        emit addRequested(m_editA->text().toDouble(), m_editB->text().toDouble());
    });
    connect(btnSub, &QPushButton::clicked, this, [=](){
        emit subRequested(m_editA->text().toDouble(), m_editB->text().toDouble());
    });
    connect(btnMul, &QPushButton::clicked, this, [=](){
        emit mulRequested(m_editA->text().toDouble(), m_editB->text().toDouble());
    });
    connect(btnDiv, &QPushButton::clicked, this, [=](){
        emit divRequested(m_editA->text().toDouble(), m_editB->text().toDouble());
    });
}

void CalculatorView::updateResult(double r)
{
    m_labelResult->setText(QString("结果: %1").arg(r));
}

4.main.cpp（连接 MVC + Q_PROPERTY 自动更新）

#include <QApplication>

#include "calculator_model.h"
#include "calculator_controller.h"
#include "calculator_view.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    CalculatorModel model;
    CalculatorView view;
    CalculatorController controller(&model, &view);

    view.show();
    return a.exec();
}

MVC + Q_PROPERTY + 双向绑定 的完整计算器示例
特点：

  • 支持加、减、乘、除
  • 双向绑定：用户在输入框修改操作数 → Model 自动更新
  • 结果显示自动更新（Q_PROPERTY + resultChanged）
  • MVC 完整分层：Model/Controller/View

1.Model（带 Q_PROPERTY）

#pragma once
#include <QObject>

class CalculatorModel : public QObject
{
    Q_OBJECT
    Q_PROPERTY(double operandA READ operandA WRITE setOperandA NOTIFY operandAChanged)
    Q_PROPERTY(double operandB READ operandB WRITE setOperandB NOTIFY operandBChanged)
    Q_PROPERTY(double result READ result NOTIFY resultChanged)

public:
    explicit CalculatorModel(QObject* parent = nullptr)
        : QObject(parent) {}

    double operandA() const { return m_operandA; }
    double operandB() const { return m_operandB; }
    double result() const { return m_result; }

public slots:
    void setOperandA(double v)
    {
        if(qFuzzyCompare(m_operandA, v)) return;
        m_operandA = v;
        emit operandAChanged();
    }

    void setOperandB(double v)
    {
        if(qFuzzyCompare(m_operandB, v)) return;
        m_operandB = v;
        emit operandBChanged();
    }

    void setResult(double v)
    {
        if(qFuzzyCompare(m_result, v)) return;
        m_result = v;
        emit resultChanged();
    }

signals:
    void operandAChanged();
    void operandBChanged();
    void resultChanged();

private:
    double m_operandA = 0;
    double m_operandB = 0;
    double m_result = 0;
};

2.Controller（转发 View → Model）

#pragma once
#include <QObject>

class CalculatorModel;

class CalculatorController : public QObject
{
    Q_OBJECT
public:
    explicit CalculatorController(CalculatorModel* model, QObject* parent = nullptr)
        : QObject(parent), m_model(model) {}

public slots:
    void setOperandA(double v) { m_model->setOperandA(v); }
    void setOperandB(double v) { m_model->setOperandB(v); }

    void add()
    {
        m_model->setResult(m_model->operandA() + m_model->operandB());
    }
    void sub()
    {
        m_model->setResult(m_model->operandA() - m_model->operandB());
    }
    void mul()
    {
        m_model->setResult(m_model->operandA() * m_model->operandB());
    }
    void div()
    {
        if (m_model->operandB() == 0)
            m_model->setResult(0); // 避免除零崩溃
        else
            m_model->setResult(m_model->operandA() / m_model->operandB());
    }

private:
    CalculatorModel* m_model;
};

3.View（UI + 双向绑定）

#pragma once
#include <QWidget>

class QLineEdit;
class QLabel;
class CalculatorModel;
class CalculatorController;

class CalculatorView : public QWidget
{
    Q_OBJECT
public:
    explicit CalculatorView(CalculatorModel* model,
                            CalculatorController* controller,
                            QWidget* parent = nullptr);

private:
    QLineEdit* m_editA;
    QLineEdit* m_editB;
    QLabel* m_labelResult;

    CalculatorModel* m_model;
    CalculatorController* m_controller;
};

#include "CalculatorView.h"
#include "CalculatorModel.h"
#include "CalculatorController.h"
#include <QLineEdit>
#include <QLabel>
#include <QPushButton>
#include <QGridLayout>
#include <QDoubleValidator>

CalculatorView::CalculatorView(CalculatorModel* model,
                               CalculatorController* controller,
                               QWidget* parent)
    : QWidget(parent), m_model(model), m_controller(controller)
{
    m_editA = new QLineEdit(this);
    m_editB = new QLineEdit(this);
    m_editA->setValidator(new QDoubleValidator(this));
    m_editB->setValidator(new QDoubleValidator(this));

    auto btnAdd = new QPushButton("+", this);
    auto btnSub = new QPushButton("-", this);
    auto btnMul = new QPushButton("*", this);
    auto btnDiv = new QPushButton("/", this);

    m_labelResult = new QLabel("结果: 0", this);

    auto layout = new QGridLayout(this);
    layout->addWidget(m_editA, 0, 0, 1, 2);
    layout->addWidget(m_editB, 1, 0, 1, 2);
    layout->addWidget(btnAdd, 2, 0);
    layout->addWidget(btnSub, 2, 1);
    layout->addWidget(btnMul, 3, 0);
    layout->addWidget(btnDiv, 3, 1);
    layout->addWidget(m_labelResult, 4, 0, 1, 2);

    // UI -> Controller
    connect(m_editA, &QLineEdit::textChanged, this, [=](QString t){
        bool ok; double v = t.toDouble(&ok);
        if(ok) m_controller->setOperandA(v);
    });
    connect(m_editB, &QLineEdit::textChanged, this, [=](QString t){
        bool ok; double v = t.toDouble(&ok);
        if(ok) m_controller->setOperandB(v);
    });

    // Buttons -> Controller
    connect(btnAdd, &QPushButton::clicked, m_controller, &CalculatorController::add);
    connect(btnSub, &QPushButton::clicked, m_controller, &CalculatorController::sub);
    connect(btnMul, &QPushButton::clicked, m_controller, &CalculatorController::mul);
    connect(btnDiv, &QPushButton::clicked, m_controller, &CalculatorController::div);

    // Model -> UI（自动更新）
    connect(m_model, &CalculatorModel::resultChanged, this, [=](){
        m_labelResult->setText(QString("结果：%1").arg(m_model->result()));
    });
}

4.main.cpp（连接 MVC）

#include <QApplication>
#include "CalculatorModel.h"
#include "CalculatorController.h"
#include "CalculatorView.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    CalculatorModel model;
    CalculatorController controller(&model);
    CalculatorView view(&model, &controller);
    view.show();

    return a.exec();
}
应用分层、三层架构和MVC架构
zhyhgx的博客
02-16 1627
在前面中，我们已经学习了Spring MVC 的一些基础操作，那么后面就用一些简单的案例来巩固一下。在开始学习做案例之前，我们先来了解一下在软件开发中常见的设计模式和架构。高内聚低耦合是一种软件设计原则。高内聚指一个模块中各个元素之间的联系的紧密程度，如果各个元素(语句、程序段）之间的联系程度越高，说明内聚性越高，即“高内聚”。低耦合指的是软件中各个层、模块之间的依赖关系程度越低越好。修改一处，对其他模块的改动越少越好。
MVC架构介绍
allway2的博客
09-27 4417
客户端-服务器之间的通信需要持续的 Internet 或 Intranet 连接。MVC架构、访问者架构、状态架构、观察者架构等。实际场景：如何使用MVC。
MVC架构详细介绍与分析
热门推荐
ccjjjjdff的博客
03-13 1万+
MVC架构详细介绍以及通过实例了解并实现MVC架构
什么是MVC架构模式？
破损的天堂鸟博客
08-04 4682
MVC架构模式，即模型-视图-控制器（Model-View-Controller）模式，是一种软件工程中的软件架构模式。它将应用程序分为三个主要部分：模型（Model）、视图（View）和控制器（Controller），以实现代码的分层组织和关注点的分离。模型代表应用程序的数据和业务逻辑。它负责处理数据的获取、存储和更新等操作，并且可以包含一些逻辑处理，当数据发生变化时，通知视图进行更新。模型是相对稳定的部分，重用率高，通常不直接与用户界面交互。视图负责展示数据并呈现给用户。
MVC架构模式详解
冰茶的博客
04-25 1490
MVC(Model-View-Controller)是一种软件架构模式,它通过将应用程序的逻辑分为三个相互独立的组件来组织代码,使得应用程序的可维护性、灵活性和可扩展性得到提高。fill:#333;color:#333;color:#333;fill:none;Model 模型Controller 控制器View 视图。
Qt 应用开发之 MVC 架构
极地星辰
11-03 2403
MVC架构在Qt应用开发中具有显著的优势和广泛的应用价值。它通过将应用程序的业务逻辑、数据展示和用户交互分离开来，提高了代码的可维护性和可扩展性，为开发人员提供了更加清晰和高效的开发模式。
什么是MVC架构？怎么使用Spring MVC架构开发项目
m0_73450461的博客
10-13 2295
什么是MVC架构？怎么使用Spring MVC架构开发项目
MVC（Model-View-Controller）架构模式和三层架构介绍
m0_73941339的博客
04-02 8679
本文系统解析MVC架构模式的核心组件与交互流程，通过用户注册案例演示模型、视图、控制器的协同机制，对比MVC与三层架构的异同及互补关系，阐述分层设计如何提升系统可维护性和扩展性，为现代Web开发提供清晰的架构设计指导。
MVC架构模式与三层架构
????
01-26 7483
详细解读了三层架构和MVC以及两者之间的关系
MVC、MVP 和 MVVM 架构总结
leizhengshenglzs的博客
05-31 1801
MVC是一种经典的模式，适用于基础和中等复杂度的应用程序，但可能在复杂应用中导致 Controller 过于复杂。MVP提供了更清晰的视图和逻辑分离，提高了测试性，但可能增加 Presenter 的复杂性。MVVM通过数据绑定简化了视图和逻辑的交互，适合现代前端开发，但需要掌握数据绑定技术，且在复杂应用中可能增加调试难度。
Qt使用mvc架构进行编程
06-01
本篇文章将深入探讨Qt如何利用MVC架构进行编程，以及这一模式在实际开发中的应用和优势。 **模型（Model）** 模型是MVC架构中的核心部分，它负责存储和管理应用程序的数据。在Qt中，模型类通常继承自`...
传统MVC架构和前后端分离架构模式对比
02-25
MVC架构是一种经典的架构模式，主要用于实现用户界面与业务逻辑的分离，提高系统的可维护性和灵活性。具体来说： - **Model（模型）**：负责管理和存储数据，处理业务逻辑。它直接与数据库或其他数据源交互，处理...
PHPMVC架构搭建
08-10
这种架构模式将应用程序的不同部分分离，使代码更易于维护和扩展。以下是关于PHP MVC架构搭建的详细说明： ...通过以上步骤和实践，你可以成功地搭建一个PHP MVC架构的应用，从而实现高效、可扩展和易于维护的Web开发。
mvc三层架构应用案例简单代码
07-30
总结来说，这个案例展示了如何使用MVC架构和一系列技术构建一个Web应用。通过解耦模型、视图和控制器，使得代码更易于维护和扩展，同时利用各种工具和框架提高开发效率。理解和实践这样的案例对于提升Java Web开发...
Elixir与Phoenix高并发实时服务开发实践分享：函数式架构与消息推送优化经验
最新发布
2501_94114373的博客
11-23 255
充分利用轻量进程实现高并发连接函数式架构保证代码可维护性异步数据库访问和缓存策略提升响应速度消息推送与任务队列确保实时性和稳定性监控与日志保障系统可观测性Elixir + Phoenix 通过函数式编程和轻量级进程，为高并发、实时服务提供了可靠、高效的开发方案，是构建大规模实时系统的理想选择。
Ⅲ. 高级篇——性能、架构与新技术
qq_55253420的博客
11-20 368
本文介绍了JAVA体系进阶学习专栏的主要内容框架，包含四大核心模块：安全进阶（零信任架构、密码学、容器安全）、大数据与机器学习（Spark、Flink、模型部署）、前沿技术（Project Loom、GraalVM等）以及项目实战案例（秒杀系统全栈实现）。每个模块均设有理论知识和实践练习，如基于RSA的加解密工具开发、Spark词频统计等，通过系统化知识梳理帮助开发者构建完整技术栈。专栏后续将持续深入讲解各技术点，提供从基础到进阶的完整学习路径。
Flowable实战：从流程混乱到优雅编排的架构演进
safestar2012的博客
11-19 1065
摘要： 本文详细记录了一个供应链金融项目从传统硬编码审批流程迁移到Flowable工作流引擎的技术改造过程。项目原有的"大泥球"架构导致每次流程变更需要2个月开发周期，通过采用Flowable实现流程与业务解耦后，变更周期缩短至2天。文章重点阐述了技术选型考量、BPMN流程建模、事件驱动架构设计等核心改造环节，并分享了事务管理、性能优化等实战经验。最终系统实现了审批效率提升66%、开发效率提升3倍的显著效果，同时总结了Flowable适用场景评估框架和实施方法论。
【CUDA笔记】03 CUDA GPU 架构与一般的程序优化思路（下）
明天，做什么好呢
11-21 703
（1）共享内存是一种位于 GPU 芯片上的高速内存，允许同一个 block 内的所有线程之间共享数据。（2）它主要用于减少全局内存访问次数，从而提升性能。相比于全局内存，共享内存的访问延迟显著更低，通常只需要几个时钟周期。这使得它非常适合用于频繁访问的小块数据。（3）使用__shared__关键字声明共享内存变量。（4）这些变量在每个 block 内独立分配，并且只对该 block 内的线程可见（5）代码设计上，可以借助这一层级来优化对 Global Memory的访问模式。
用户管理系统 06 实现用户管理功能 | Java新手实战 | 最小架构 | 期末实训 | Java+SpringBoot+Vue3
teacherchen90的博客
11-21 57
本文是Java用户管理系统实战系列的第六篇，主要讲解后端用户管理功能的实现。文章详细介绍了用户列表分页查询、新增、编辑和删除等核心功能的开发流程，采用MVP最小架构设计。 核心内容包括： 功能架构设计：分页查询+条件筛选、增删改查操作 Controller层实现：定义用户管理相关接口 Service层业务逻辑：用户列表查询、增删改查实现 关键特性：分页处理、表单验证、数据回显、逻辑删除 通过本教程，Java新手可以掌握企业级CRUD开发技巧，理解前后端数据交互流程，并学习MyBatis Plus的高级查询方
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值