Modèles d’architecture logicielle : Modèle-Vue-Contrôleur

Les modèles sont une abstraction importante dans le développement de logiciels modernes et l’architecture logicielle. Ils offrent une terminologie bien définie, une documentation propre et l’apprentissage des meilleurs. Le modèle-vue-contrôleur (MVC) est l’un des modèles architecturaux classiques du livre “Architecture logicielle orientée modèle, volume 1“. Il est destiné aux applications interactives avec une interface homme-machine flexible.

Le MVC divise la logique de programme d’une interface utilisateur en un modèle, une vue et un contrôleur de composants individuels. Le modèle gère les données et les règles de l’application. La vue restitue les données et le contrôleur interagit avec l’utilisateur.

Modèle Vue Contrôleur

But

• Les interfaces utilisateur doivent être modifiées fréquemment,
• différentes interfaces utilisateur doivent être prises en charge et
• le modèle de données est stable.

Solution

• L’application est divisée en composants Model (modèle de données), View (composants de sortie) et Controller (composants d’entrée) et
• plusieurs composants de sortie peuvent utiliser le même modèle de données.

Structure

Model

• est le composant central du motif,
• contient les données (et la logique métier) et
• est indépendant de View et Controller.

View

• est responsable de la présentation des données et de l’interaction avec l’utilisateur
• Regarde ça Model et
• un View est avec un Controller connecté à cela Model manipuler.

Controller

• gère une ou plusieurs vues
• Reçoit les interactions des utilisateurs et les prépare pour la Model ou voir sur,
• regarde ça Model et
• implémente la logique de mise à jour.

Il y a deux aspects intéressants de MVC : l’initialisation et la saisie de l’utilisateur :

initialisation

Les étapes suivantes ont lieu lors de l’initialisation du MVC :

• Le modèle est créé et ses données sont initialisées.
• Les vues sont créées et observent le modèle.
• Le contrôleur est créé et reçoit des références au modèle et aux vues.
• Le contrôleur observe le modèle.
• L’application commence le traitement de l’événement.

saisie de l’utilisateur

Dans un événement utilisateur, les étapes suivantes ont lieu :

• Le contrôleur accepte l’entrée de l’utilisateur, la traite et déclenche le modèle.
• Le modèle modifie ses données internes.
• Le modèle informe toutes les vues et tous les contrôleurs de la modification des données internes.
• Les vues et les contrôleurs se mettent à jour d’eux-mêmes Exemple : Si le code PIN est saisi de manière incorrecte à un guichet automatique pour la troisième fois, cela peut signifier : L’écran indique que le compte est bloqué. Le guichet automatique confisquera la carte de débit.
• Le contrôleur continue de traiter les événements.

Exemple

Le programme suivant mvc.cpp applique MVC.

// mvc.cpp

#include 
#include 
#include 


class DefectModel {
 public:                                                   // (5)
     mutable std::unordered_map
       defects_ = { {"XYZ" , "File doesn't get deleted."},
                    {"XAB" , "Registry doesn't get created."},
                    {"ABC" , "Wrong title get displayed."} };

    std::string getDefectComponent(const std::string& component) 
      const {
        return defects_[component];
    }

    int getSummary() const {
        return defects_.size();
    }

    std::unordered_map getAllDefects() 
      const {
        return defects_;
    }

};

class DefectView {
 public:
    void showSummary(int num) const {
        std::cout << "There are " + std::to_string(num) + 
          " defects in total!n";
    }
    
    void showDefectComponent(const std::string& defect) const {
        std::cout << "Defect of component: " + defect + 'n';
    }

    void showDefectList(const std::unordered_map& defects) const {
        for (const auto& p: defects) {
            std::cout << "(" + p.first + ", " + p.second + ")n";
        }
    }
};

class DefectController {
    const DefectModel& defectModel;
    const DefectView& defectView;
 public:
    DefectController(const DefectModel& defModel, 
                     const DefectView& defView):
      defectModel{defModel}, defectView{defView} { }

    void showDefectComponent(const std::string& component) 
      const {
        defectView.showDefectComponent(
          defectModel.getDefectComponent(component));    // (6)
    }

    void showDefectSummary() const {
      defectView.showSummary(defectModel.getSummary());  // (7)
    }

    void showDefectList() const {
      defectView.showDefectList(
        defectModel.getAllDefects());                    // (8)
    }

};

int main() {

    std::cout << 'n';

    DefectModel defectModel;
    DefectView defectView;

    
    DefectController defectController(defectModel, 
                                      defectView);  // (1)
    defectController.showDefectComponent("ABC");    // (2)
    std::cout << 'n';
    defectController.showDefectSummary();           // (3)
    std::cout << 'n';
    defectController.showDefectList();              // (4)

    std::cout << 'n';

}

Le contrôleur obtient son modèle et sa vue dans son constructeur (1) et affiche sa liste d’erreurs defects_ (5) de trois manières (2 – 4). Le contrôleur pousse chaque appel dans le main fonction et utilise ses vues pour afficher les données fournies par le modèle (6 – 8).

La capture d’écran suivante montre la sortie du programme :

Variation

Présentation-Abstraction-Contrôle est un autre modèle du livre “Architecture logicielle orientée modèle, volume 1 et est similaire au MVC. Il utilise une structure hiérarchique d’agents, où chaque agent se compose de la présentation, de l’abstraction (modèle) et du contrôle des données. Les agents communiquent entre eux à l’aide du contrôleur.

Avantages et inconvénients

Avantages

• Séparation des préoccupations : le modèle est strictement séparé du contrôleur et des vues. Par conséquent, de nombreuses vues ou contrôleurs peuvent être pris en charge en même temps et modifiés lors de l’exécution.
• Les vues sont synchronisées car elles sont mises à jour en même temps.

Désavantages

• MVC peut être trop complexe et encombré pour une petite interface homme-machine.
• Une modification du modèle peut déclencher une cascade d’opérations sur les vues et contrôleurs dépendants.
• La vue et le contrôleur sont fortement couplés. Une modification de l’un d’eux peut détruire l’autre.

Et après?

Les applications événementielles telles que les interfaces graphiques ou les serveurs utilisent souvent le modèle d’architecture Reactor. Un réacteur peut accepter plusieurs demandes en même temps et les distribuer à différents gestionnaires.

(rme)