Site original : Sam & Max: Python, Django, Git et du cul
MVC, pour “Modèle, Vue, Contrôleur”, est le nom donné à une manière d’organiser son code. C’est une façon d’appliquer le principe de séparation des responsabilités, en l’occurrence celles du traitement de l’information et de sa mise en forme.
Une fois n’est pas coutume je vais donner un exemple en Python et PHP, car c’est une question qui hante les codeurs de ce langage. En effet on leur rabâche qu’il faut utiliser MVC, que tel framework est MVC, que leur code à eux ne l’est pas, etc. Sans que nulle part, évidement, on ne donne une explication correcte de la notion.
Long article, petite musique.
(piqué à What the cut :-))
Il n’y a pas de Tables De La Loi qui disent ce qu’est le MVC, il y a donc autant de manières de le faire que de programmes. En fait, c’est un simple principe d’organisation de code, et il y en a d’autres. Mais généralement, c’est basé sur la répartition suivante :
MVC est typiquement quelque chose d’abstrait qu’on ne peut pas comprendre avec une explication seule. Passons donc rapidement à un exemple.
Imaginons que l’on ait des tas de fichiers CSV ainsi faits :
"Jeu";"Nombre de joueurs Max";"Support" "Secret of Mana";"3";"Super Nintendo" "Bomberman";"8";"Super Nintendo" "Mario Kart";"4";"Nintendo 64" "Age of Empire 2";"8";"PC"
Et que nous voulions un programme qui fasse un rapport sur le CSV, affichant :
Nombre de jeux analysés : 10 Détails -------- Support: Super Nintendo Nombre de jeux : 2 Nombre de joueurs max : 8 Support: Nintendo 64 Nombre de jeux : 1 Nombre de joueurs max : 4 etc
Il y a de nombreuses manières de coder ce programme. Si on le fait en suivant le principe du modèle MVC, on va faire 3 fichiers : un pour le modèle, un pour la vue, et un pour le contrôleur. On peut avoir plus ou moins de 3 fichiers, j’ai choisi 3 fichiers pour bien illustrer le principe de séparation des responsabilités.
Le modèle manipule la donnée. Dans un site Web, le modèle est souvent le code qui permet de faire de requêtes à la base de données. Dans notre cas, c’est le code qui va manipuler le CSV. Encore une fois, il n’y a pas de définition divine de ce qu’est un modèle, ceci n’est qu’un exemple de ce que cela PEUT être. C’est le choix du dev.
modele.py
from __future__ import unicode_literals, absolute_import from csv import DictReader from collections import OrderedDict class Modele(object): def __init__(self, csv): self.total_jeux = 0 self.supports = OrderedDict() with open(csv) as f: # on parse le csv for data in DictReader(f, delimiter=b';', quotechar=b'"'): # on calcule les stats pour que ligne du csv support = self.supports.setdefault(data['Support'], {}) support['nombre_de_jeux'] = support.get('nombre_de_jeux', 0) + 1 self.total_jeux += 1 if support.get('joueurs_max', 0) < data['Nombre de joueurs Max']: support['joueurs_max'] = data['Nombre de joueurs Max'] def __iter__(self): # goodies pour pouvoir itérer sur le modèle return self.supports.iteritems()
Ca s’utilise comme ça :
>>> modele = Modele("Bureau/jeux.csv") >>> modele.total_jeux 4 >>> for support, data in modele: print support print data ... Super Nintendo {u'nombre_de_jeux': 2, u'joueurs_max': '8'} Nintendo 64 {u'nombre_de_jeux': 1, u'joueurs_max': '4'} PC {u'nombre_de_jeux': 1, u'joueurs_max': '8'}
On voit ici le principe : le modèle ne fait que manipuler la donnée, et rien d’autre. Il extrait, regroupe, calcule, raffine, et donne une belle interface propre pour que le reste du programme puisse utiliser le résultat sans avoir à connaitre les détails du traitement.
La vue, c’est de la présentation. C’est comment on veut que la donnée soit présentée à l’utilisateur. Ça peut être le code qui pond du HTML ou produit un CSV, ou fait configurer de jolis boutons dans une UI.
Dans notre cas, c’est le code qui va formater le texte pour la console.
On veut un truc comme ça :
Nombre de jeux analysés : 10 Détails -------- Support: Super Nintendo Nombre de jeux : 2 Nombre de joueurs max : 8 Support: Nintendo 64 Nombre de jeux : 1 Nombre de joueurs max : 4
Normalement, on voudrait un template. Mais on a pas de langage de template qui accepte les boucles dans la lib standard, alors on va faire comme la norme WSGI et retourner un générateur de strings.
vue.py
from __future__ import unicode_literals, absolute_import def rapport(modele): # affichage de l'en-tête yield ("Nombre de jeux analysés : {total_jeux}\n\n" "Détails\n--------\n").format(total_jeux=modele.total_jeux) # affichage des stats pour chaque console for support, data in modele: yield ("Support: {support}\n" "Nombre de jeux : {nombre_de_jeux}\n" "Nombre de joueurs max : {joueurs_max}\n").format( support=support, **data)
Et ça s’utilise comme ça :
>>> m = Modele("Bureau/jeux.csv") >>> list(rapport(m)) [u'Nombre de jeux analys\xe9s : 4\n\nD\xe9tails\n--------\n', u'Support: Super Nintendo\nNombre de jeux : 2\nNombre de joueurs max : 8\n', u'Support: Nintendo 64\nNombre de jeux : 1\nNombre de joueurs max : 4\n', u'Support: PC\nNombre de jeux : 1\nNombre de joueurs max : 8\n']
Encore une fois, ceci n’est pas LA manière de faire une vue. Ceci est UNE manière de faire une vue. Le but de la vue est de contenir le code qui se charge de formater la donnée pour l’utilisateur.
Il est plus courant d’utiliser un template pour cela, c’est à dire une sorte lib de texte à trou à remplir plus tard avec le modèle. C’est plus facile et flexible qu’une fonction. Il y a des tas de libs de templates en Python. Je ferai sans doute un article dessus un jour. Si vous voulez un truc simple et rapide, utilisez templite : rien besoin d’installer, ça tient dans un fichier. Si vous voulez le truc le plus standard possible, utiliser jinja2, c’est plus ou moins la lib la plus connue actuellement.
Le contrôleur, c’est tout le reste. Essayer de définir le contrôleur est généralement voué à l’échec, tant sa nature change d’une application à l’autre. Certains disent que c’est le code glue qui permet de lier le modèle et la vue. D’autres qu’il contient la logique de flux du programme. Personnellement, je vous invite à vous fier à la définition “c’est tout le reste”. Avec l’expérience, vous en viendrez à faire des modèles et des vues de plus en plus adaptées, et la partie contrôleur découlera d’elle-même.
De toute façon, aucun MVC n’est parfait, et un peu de vue dégouline parfois sur le contrôleur, un peu de contrôleur coule dans le modèle, ou inversement. Il ne sert à rien d’être un nazi du MVC, c’est une bonne pratique, pas un dogme religieux.
Dans notre cas le programme a besoin d’un code qui :
Le contrôleur est par ailleurs le point d’entrée d’un programme. Et ce sera essentiellement ça, le contrôleur de notre programme : un point d’entrée.
controlleur.py
from __future__ import unicode_literals, absolute_import import os import sys from vue import rapport from modele import Modele # on prend le csv en paramètre du script try: f = sys.argv[1] except IndexError: sys.exit("Veuillez passer le chemin d'un fichier CSV en paramètre.") # on vérifie que le csv existe if not os.path.isfile(f): sys.exit("Le fichier '%s' n'existe pas" % f) # on analyse le CSV et on affiche le rapport for texte in rapport(Modele(f)): print texte
$ python controlleur.py jeux.csv Nombre de jeux analysés : 4 Détails -------- Support: Super Nintendo Nombre de jeux : 2 Nombre de joueurs max : 8 Support: Nintendo 64 Nombre de jeux : 1 Nombre de joueurs max : 4 Support: PC Nombre de jeux : 1 Nombre de joueurs max : 8
Vous pouvez télécharger le code Python de cet article.
Le PHP a eu beaucoup de succès du fait de la facilité avec laquelle on pouvait coder un site Web, en mélangeant code et HTML. Malheureusement cela a donné lieu à des codes très sales, où on trouvait les requêtes SQL à côté de l’affichage d’un tableau, l’analyse des paramètres $_GET
à deux pas de la vérification du mot de passe.
MVC a été une réponse à cela.
Un modèle MVC propre sera généralement très riche et complexe, mais il est possible de bricoler un site en MVC basique à la main sans trop de problème. Je ne vous recommande pas d’utiliser ce code en prod, mais c’est un bon début pour comprendre comment ça marche. Une fois que vous serez à l’aise avec l’idée, n’hésitez pas à coder le votre sur un petit projet, puis à tester un framework. Symfony, par exemple, est une valeur sûre en PHP.
Admettons que notre site ait deux pages : accueil et liste des utilisateurs.
L’accueil dit juste bonjour, la liste affiche tous les utilisateurs du site Web. Passionnant.
L’idée est de mettre toutes les requêtes SQL au même endroit.
Les vieux routards du PHP m’excuseront, mais je n’ai plus codé dans ce langage depuis des années, donc mon style va dater un peu :-) Et honnêtement tous ces points-virgules, ces dollars et ces brackets dans tous les sens, sans compter la flèche comme caractère de look up, ça me perturbe grandement.
modele.php
<?php $con = mysqli_connect("127.0.0.1", 'root', 'admin123', 'ma_db'); class User { public $name; public $age; function __construct($name, $age) { $this->name = $name; $this->age = $age; } static function liste() { $users = array(); $query = mysqli_query($con, 'SELECT * FROM `user`'); while ($row = mysql_fetch_assoc($query)) { $users[] = User($row[0], $row[1]); } return users; } }
Et ça s’utilise comme ça :
$users = User->liste(); foreach ($users as $user) { echo $user.name . '(' . $users.age. 'ans)'; }
Ce qui affiche tous les noms et les ages des utilisateurs.
Bien, on a isolé l’accès aux données, maintenant on va isoler la mise en forme.
Ou plutôt, les vues, puisqu’on a deux pages, et donc deux vues.
Vous ne le savez peut être pas, mais PHP vient avec une syntaxe alternative spécialement conçue pour être utilisée dans le HTML. Elle est similaire à la syntaxe originale, mais les blocs sont ouverts avec :
au lieux de {
et fermés par endinstruction
. Les variables sont affichées avec <?=$nom_de_variable?>
.
Par exemple:
<?php if $truc: ?> <p> <?=$machin?> </p> <?php endif; ?>
Cette syntaxe permet de bien séparer le texte du code PHP, et donc sera utilisée pour la vue.
accueil.php
<html><body><h1>Bonjour</h1></body></html>
liste_utilisateurs.php
<html> <body> <h1>Utilisateurs</h1> <ul>http://www.php.net/manual/fr/control-structures.alternative-syntax.php <?php foreach $users as $user: ?> <li><?=$user->name?> (<?=$user->age?> ans)</li> <?php endforeach; ?> </ul> </body> </html>
Et voilà, on a deux pages, et la deuxième affiche notre liste d'utilisateur. Vous remarquerez qu'il n'y a pas de requête ou de logique de choix de page, pas d'accès à mysql_*
ou à $_GET
dans ce code. Que de l'affichage.
Puisque le contrôleur, c'est le reste, ce sera à la fois notre point d'entrée, notre code glue et notre routing.
<?php if (isset($_GET['page']) && $_GET['page'] == 'liste') { require 'modele.php' require 'liste_utilisateurs.php' } else { require 'accueil.php' }
Et c'est tout.
Si l'utilisateur va sur l'adresse monsite.com/, il va arriver sur l'accueil, si il va sur monsite.com/?page=liste, il va atterrir sur la liste des utilisateurs.
Si on veut changer le look de la page, on modifie la vue. Si on veut changer de base de source de données (et lire par exemple depuis un fichier), on change le modèle. Si on veut rajouter des pages, on change le contrôleur. L'avantage de la séparation des responsabilités, c'est la facilité de lecture et donc de maintenance et d'évolution.
J'insiste sur le fait que c'est un exemple pédagogique, et pas quelque chose à utiliser en prod (par exemple à cause des URLs très moches). Mais il va vous permettre de coder votre premier site en MVC, et plus tard, aller vers des versions plus sérieuses.
L'important, c'est la séparation donnée / formatage / reste du code.
Créer un modèle MVC à la main propre et efficace, c'est énormément de taff. C'est pour cela qu'on utilise des outils tout fait comme des frameworks Web ou des libs graphiques (Qt, wxWidget et Gtk ont toutes des outils MVC, ex : Qt possède QML, un dialecte type CSS pour manipuler des vues).
Un modèle MVC simple, mais propre, est celui du micro-framework Web Python bottle, dont Max vous avait parlé ici. Lisez l'article, et revenez à ce paragraphe, et vous comprendrez que :
@url
.Comme je l'ai dit précédemment, il y a de nombreuses manières de séparer le contenu de sa présentation.
Django par exemple n'utilise pas un modèle MVC au sens traditionnel, mais plutôt du MVT (Modèle - Vue - Template). Ce qu'il appelle les vues sont en fait ce qu'on appelle le contrôleur dans bottle : les fonctions qui mélangent les données avec le template. Django propose par contre un ORM, qui est bel est bien un système de modèle très élaboré.
C'est une question de sémantique, et au final, qu'importe le flacon, pourvu qu'on ait l'ivresse.