Modèle-vue-contrôleur

Un article de Wikipédia, l'encyclopédie libre.
(Redirigé depuis Modèle-Vue-Contrôleur)
Aller à : navigation, rechercher
Page d'aide sur l'homonymie Pour les articles homonymes, voir MVC.
interactions entre le modèle, la vue et le contrôleur

Modèle-Vue-Contrôleur (abr. MVC) est un motif d'architecture logicielle destiné aux interfaces graphiques lancé en 1978 et très populaire pour les applications web. Le motif est composé de trois types de modules ayant trois responsabilités différentes: les modèles, les vues et les contrôleurs.

  • Un modèle contient les données à afficher.
  • Une vue contient la présentation de l'interface graphique.
  • Un contrôleur contient la logique concernant les actions effectuées par l'utilisateur.

Ce motif est utilisé par de nombreux frameworks pour applications web tels que Ruby on Rails, Django, ASP.NET MVC, Spring, Struts ou Apache Tapestry

Histoire[modifier | modifier le code]

Le motif MVC a été créé par Trygve Reenskaug lors de sa visite du Palo Alto Research Center (abr. PARC) en 1978[1]. Le nom original est Thing Model View Editor pattern, puis il a été rapidement renommé Model-View-Controller pattern[1]. Le patron MVC a été utilisé la première fois pour créer des interfaces graphiques avec le langage de programmation Smalltalk en 1980[1].

Description[modifier | modifier le code]

Une application conforme au motif MVC comporte trois types de modules: les modèles, les vues et les contrôleurs[2].

Le modèle

C'est l'élément qui contient les données ainsi que de la logique en rapport avec les données: validation, lecture et enregistrement.[3]. Il peut, dans sa forme la plus simple, contenir uniquement un simple texte, voire des données beaucoup plus compliquées[3]. Le modèle représente l'univers dans lequel s'inscrit l'application[2]. Par exemple pour une application de banque, le modèle représente des comptes, des clients, ainsi que les opérations telles que dépôt et retraits, et vérifie que les retraits ne dépassent pas la limite de crédit[2]. Le modèle est indépendant de la vue et du contrôleur et ne s'en sert pas[3].

La vue

C'est la partie visible d'une interface graphique[3]. La vue se sert du modèle, et peut être un diagramme, un formulaire, des boutons, etc[3]. Une vue contient des éléments visuels ainsi que la logique nécessaire pour afficher les données provenant du modèle[3]. Dans une application web une vue contient des balises HTML[2].

Le contrôleur

C'est le module qui traite les actions de l'utilisateur, modifie les données du modèle et de la vue[3].

l'ensemble

Les trois éléments sont indépendants les uns des autres, le modèle ne se sert ni de la vue ni du contrôleur, il peut cependant leur envoyer des messages[3]. Il y a deux liens entre la vue et le modèle: premièrement la vue lit les données du modèle et deuxièmement reçoit des messages provenant du modèle[3]. Dans la mesure où une vue est associée à un modèle et un modèle est indépendant, un même modèle peut être utilisé par plusieurs vues[3].

Le contrôleur dépend de la vue et du modèle: la vue comporte des éléments visuels que l'utilisateur peut actionner[3]. Le contrôleur répond aux actions effectuées sur la vue et modifie les données du modèle[3].

Dans le cas d'un View model, le modèle contient les données que le contrôleur transmet à la vue[2]. Dans le cas d'un Domain model il contient toutes les données en rapport avec l'activité, ainsi que la logique des opérations de modification et de validation des données[2].

MVP et MVVM[modifier | modifier le code]

Les motifs Model-View-Presenter (abr. MVP) et Model-View-ViewModel (abr. MVVM) sont semblables au motifs modèle-vue-contrôleur, à quelques différences près[4].

  • Dans le patron MVP, le contrôleur est remplacé par une présentation. La présentation est créée par la vue et lui est associée par une interface. Les actions utilisateur déclenchent des événements sur la vue, et ces événements sont propagés à la présentation en utilisant l'interface[4].
  • Dans le patron MVVM il y a une communication bidirectionnelle entre la vue et le modèle, les actions de l'utilisateur entraînent des modification des données du modèle[4].

Dans les applications web[modifier | modifier le code]

Le motif MVC a été créé dans le but de mettre en oeuvre des interfaces utilisateur[2]. Certains détails sont alignés avec le langage Smalltalk, mais les grandes lignes peuvent s'appliquer à n'importe quel environnement[2]. Le cycle action->mise à jour->affichage induit par ce patron est bien adapté aux applications web[2]. De plus le patron impose la séparation des sujets, et les balises HTML sont ainsi confinées aux vues, ce qui améliore la maintenabilité de l'application[2]. C'est le framework pour applications web Ruby on Rails qui a apporté un regain d'intérêt pour ce patron[2].

Ce patron est utilisé par de nombreux frameworks pour applications web tels que Ruby on Rails, Django, ASP.NET MVC, Spring, Struts ou Apache Tapestry[1].

Dans la mise en oeuvre classique du patron MVC, la vue attend des modifications du modèle, puis modifie la présentation des éléments visuels correspondants[5]. Cette mise en oeuvre est appliquée pour les applications de bureau avec des framework comme Swing[5]. Le protocole HTTP ne permet pas cette mise en oeuvre pour les applications web. Pour ces dernières, lors d'une action de l'utilisateur, le contenu de la vue est recalculé puis envoyé au client[5].

Flux de traitement[modifier | modifier le code]

En résumé, lorsqu'un client envoie une requête à l'application :

  • la requête envoyée depuis la vue est analysée par le contrôleur (par exemple un clic de souris pour lancer un traitement de données) ;
  • le contrôleur demande au modèle approprié d'effectuer les traitements et notifie à la vue que la requête est traitée (via par exemple un handler ou callback) ;
  • la vue notifiée fait une requête au modèle pour se mettre à jour (par exemple affiche le résultat du traitement via le modèle).

Avantages[modifier | modifier le code]

Question book-4.svg
Cette section ne cite pas suffisamment ses sources (indiquez la date de pose grâce au paramètre date).
Pour l'améliorer, ajoutez des références vérifiables [Comment faire ?] ou le modèle {{Référence nécessaire}} sur les passages nécessitant une source.

Un avantage apporté par ce modèle est la clarté de l'architecture qu'il impose. Cela simplifie la tâche du développeur qui tenterait d'effectuer une maintenance ou une amélioration sur le projet. En effet, la modification des traitements ne change en rien la vue. Par exemple on peut passer d'une base de données de type SQL à XML en changeant simplement les traitements d'interaction avec la base, et les vues ne s'en trouvent pas affectées.

Le MVC montre ses limites dans le cadre des applications utilisant les technologies du web, bâties à partir de serveurs d'applications[réf. nécessaire]. Des couches supplémentaires sont alors introduites ainsi que les mécanismes d'inversion de contrôle et d'injection de dépendance[6].

Différence avec l'architecture trois tiers[modifier | modifier le code]

Question book-4.svg
Cette section ne cite pas suffisamment ses sources (indiquez la date de pose grâce au paramètre date).
Pour l'améliorer, ajoutez des références vérifiables [Comment faire ?] ou le modèle {{Référence nécessaire}} sur les passages nécessitant une source.
Article détaillé : Architecture trois tiers.

L'architecture trois tiers est un modèle en couches, c'est-à-dire que chaque couche communique seulement avec ses couches adjacentes (supérieures et inférieures) et le flux de contrôle traverse le système de haut en bas. Les couches supérieures contrôlent les couches inférieures, c'est-à-dire que les couches supérieures sont toujours sources d'interaction (clients) alors que les couches inférieures ne font que répondre à des requêtes (serveurs).

Dans le modèle MVC, il est généralement admis que la vue puisse consulter directement le modèle (lecture) sans passer par le contrôleur. Par contre, elle doit nécessairement passer par le contrôleur pour effectuer une modification (écriture). Ici, le flux de contrôle est inversé par rapport au modèle en couches, le contrôleur peut alors envoyer des requêtes à toutes les vues de manière qu'elles se mettent à jour.

Dans l'architecture trois tiers, si une vue modifie les données, toutes les vues concernées par la modification doivent être mises à jour, d'où l'utilité de l'utilisation du MVC au niveau de la couche de présentation. La couche de présentation permet donc d'établir des règles du type « mettre à jour les vues concernant X si Y ou Z sont modifiés ». Mais ces règles deviennent rapidement trop nombreuses et ingérables si les relations logiques sont trop élevées. Dans ce cas, un simple rafraîchissement des vues à intervalle régulier permet de surmonter aisément ce problème. Il s'agit d'ailleurs de la solution la plus répandue en architecture trois tiers, l'utilisation du MVC étant moderne et encore marginale.

Exemples d’architecture MVC[modifier | modifier le code]

En ASP.NET[modifier | modifier le code]

Article détaillé : ASP.NET MVC.

En C++[modifier | modifier le code]

Article détaillé : C++.

En JavaScript[modifier | modifier le code]

Article détaillé : JavaScript.

En ECMAScript[modifier | modifier le code]

Article détaillé : ECMAScript.

En Java[modifier | modifier le code]

Article détaillé : Java (technique).

En Objective C[modifier | modifier le code]

Article détaillé : Objective C.

En Perl[modifier | modifier le code]

Article détaillé : Perl (langage).

Frameworks orientés Web en Perl :

  • Catalyst ;
  • CGI::Application : basé sur le module Perl CGI.pm ;
  • Dancer ;
  • Gantry : similaire à Django ;
  • Jifty ;
  • MasonX ;
  • MayPole : superposition de Catalyst ;
  • O2 ;
  • Plack ;
  • Solstice ;
  • Squatting.
  • Mojolicious

En PHP[modifier | modifier le code]

Article détaillé : PHP: Hypertext Preprocessor.

Frameworks basés sur l'architecture MVC :

L'utilisation d'un Framework n'est pas une obligation[7].

En Python[modifier | modifier le code]

Article détaillé : Python (langage).

En Ruby[modifier | modifier le code]

Article détaillé : Ruby.

Voir aussi[modifier | modifier le code]

Notes et références[modifier | modifier le code]

  1. a, b, c et d (en)Stephen Walther,ASP.NET MVC Framework Unleashed,Sams Publishing - 2009, (ISBN 9780768689785)
  2. a, b, c, d, e, f, g, h, i, j et k (en)Adam Freeman et Steven Sanderson,Pro ASP.NET MVC 3 Framework,Apress - 2011, (ISBN 9781430234043)
  3. a, b, c, d, e, f, g, h, i, j, k et l (en)Joey Lott et Danny Patterson,Advanced ActionScript with Design Patterns,Adobe Press - 2007,Modèle:ISNB
  4. a, b et c (en)John Ciliberti,ASP.NET MVC 4 Recipes: A Problem-Solution Approach,Apress - 2013, (ISBN 9781430247746)
  5. a, b et c (en)Colin Yates - Seth Ladd - Marten Deinum - Koen Serneels et Christophe Vanfleteren,Pro Spring MVC: With Web Flow,Apress - 2012, (ISBN 9781430241553)
  6. (en) Fabien Potencier, « What is Dependency Injection? », 26 mars 2009.
  7. http://blog.nalis.fr/index.php?post/2009/10/19/Architecture-%3A-Le-Design-Pattern-MVC-en-PHP exemple d'implémentation MVC en PHP ]