Devis

Architecture MVC : comprendre le modèle-vue-contrôleur en PHP

L'architecture MVC (modèle-vue-contrôleur) organise une application en trois couches : les données, l'affichage et le pilotage des requêtes. Définition, parcours d'une requête, exemple en PHP natif, avantages, limites et place des frameworks.

Architecture MVC : le modèle-vue-contrôleur expliqué
contactez-nous

Une idée ? un projet ?

À retenir

  • L'architecture MVC sépare les données (modèle), l'affichage (vue) et le pilotage (contrôleur) d'une application.
  • Sur le web, une requête suit toujours le même chemin : routeur, contrôleur, modèle, puis vue.
  • MVC n'exige aucun framework : une application en PHP natif peut l'appliquer avec quelques dossiers et un routeur.

Qu'est-ce que l'architecture MVC ?

L'architecture MVC, pour modèle-vue-contrôleur (Model-View-Controller en anglais), est un patron de conception qui organise le code d'une application en trois rôles distincts. Le modèle gère les données et les règles métier, la vue prend en charge l'affichage, et le contrôleur reçoit les demandes de l'utilisateur pour les orienter vers le bon modèle et la bonne vue. Cette séparation des responsabilités, telle que la définit MDN, facilite la répartition du travail et la maintenance.

Le principe a été formulé en 1979 par l'informaticien norvégien Trygve Reenskaug, lors d'un séjour au centre de recherche Xerox PARC, pour structurer des interfaces graphiques. Il a ensuite été adapté au développement web côté serveur, où il est devenu l'organisation la plus répandue des applications. Des variantes en dérivent, comme MVP (modèle-vue-présentateur) ou MVVM (modèle-vue-vue-modèle), mais elles reposent toutes sur la même idée : ne pas mélanger l'accès aux données, la logique de traitement et la présentation.

Schéma de l'architecture MVC reliant le modèle, les vues et le contrôleur
Le modèle, la vue et le contrôleur échangent selon des rôles précis : chaque couche peut évoluer sans réécrire les deux autres.

Pour une entreprise, l'enjeu n'est pas académique. Une application dont le code mêle requêtes SQL, règles de calcul et HTML dans les mêmes fichiers devient coûteuse à faire évoluer : chaque modification risque d'en casser une autre, et l'arrivée d'un nouveau développeur prend des semaines. L'architecture MVC impose un rangement que toute l'équipe partage.

Le rôle de chaque couche du modèle-vue-contrôleur

Chaque couche répond à une question différente. Le modèle sait ce que sont les données, la vue sait comment les montrer, et le contrôleur sait quoi faire de la demande reçue. Tant que chacune reste dans son rôle, on peut remplacer l'une sans toucher aux deux autres.

Le modèle : les données et les règles métier

Le modèle représente les données de l'application et les règles qui s'y appliquent. Il interroge la base de données, contrôle la validité d'une saisie, calcule un montant ou vérifie qu'une commande peut être annulée. Il ne sait rien de l'affichage : le même modèle peut alimenter une page web, un export CSV ou une API consommée par une application mobile.

La vue : la présentation

La vue produit ce que l'utilisateur voit, le plus souvent du HTML. Elle reçoit des données déjà préparées et se limite à les mettre en forme. Une vue bien conçue ne contient ni requête SQL ni règle métier ; elle peut en revanche inclure des fragments réutilisables, comme un en-tête, un pied de page ou une carte d'article.

Le contrôleur : le chef d'orchestre

Le contrôleur reçoit la requête, appelle le ou les modèles nécessaires, puis transmet le résultat à la vue appropriée. Il gère aussi les cas particuliers : rediriger après l'envoi d'un formulaire, refuser l'accès à un utilisateur non connecté ou renvoyer une page d'erreur. Son rôle est de coordonner, pas de calculer : un contrôleur qui contient de la logique métier est le premier signe d'une architecture qui se dégrade.

Le cheminement d'une requête dans une application MVC

Sur le web, l'architecture MVC s'accompagne presque toujours d'un point d'entrée unique et d'un routeur. Toutes les requêtes passent par le même fichier, qui décide ensuite quel contrôleur doit répondre. Voici le parcours d'une requête, de l'adresse saisie par l'utilisateur jusqu'à la page affichée.

  1. Le serveur redirige vers le point d'entrée. Une règle de réécriture (dans le fichier .htaccess sous Apache) envoie toutes les adresses vers public/index.php, sauf les fichiers statiques comme les images ou les feuilles de style.
  2. Le routeur identifie la page demandée. Il compare l'URL aux routes déclarées et en déduit le contrôleur, la méthode à appeler et les paramètres, par exemple l'identifiant d'un article.
  3. Le contrôleur interroge le modèle. Il demande les données utiles, vérifie les droits de l'utilisateur et traite le formulaire éventuellement envoyé.
  4. Le modèle renvoie les données. Il exécute les requêtes en base, applique les règles métier et retourne un résultat exploitable, ou une absence de résultat.
  5. La vue construit la réponse. Le contrôleur lui passe les données, elle génère le HTML, et le serveur renvoie la page au navigateur.

Ce circuit unique présente un avantage concret : la sécurité, la journalisation des erreurs ou la gestion des sessions se traitent à un seul endroit, au lieu d'être recopiées dans chaque page du site.

Exemple d'architecture MVC en PHP natif

L'architecture MVC ne dépend d'aucun framework. Une application en PHP natif peut l'appliquer avec une arborescence claire et quelques dizaines de lignes de code. Voici une organisation type, proche de celle que nous utilisons sur nos projets :

projet/
├── public/
│   ├── index.php          (point d'entrée unique)
│   ├── .htaccess
│   └── assets/            (CSS, JavaScript, images)
├── app/
│   ├── config/config.php
│   ├── controllers/ArticleController.php
│   ├── models/ArticleModel.php
│   └── views/
│       ├── layout.php
│       └── articles/show.php
└── router/Router.php

Seul le dossier public/ est exposé au web ; le code applicatif et la configuration restent hors de portée d'un visiteur. Le contrôleur ci-dessous récupère un article par son identifiant d'URL et le transmet à la vue :

<?php
class ArticleController
{
    public function show(string $slug): void
    {
        $article = (new ArticleModel())->findBySlug($slug);

        if ($article === null) {
            (new PageController())->notFound();
            return;
        }

        require __DIR__ . '/../views/articles/show.php';
    }
}

Le modèle se charge seul de l'accès aux données, avec une requête préparée qui protège contre les injections SQL :

<?php
class ArticleModel
{
    public function findBySlug(string $slug): ?array
    {
        $requete = Database::get()->prepare(
            'SELECT titre, resume FROM articles WHERE slug = ?'
        );
        $requete->execute([$slug]);

        return $requete->fetch(PDO::FETCH_ASSOC) ?: null;
    }
}

La vue, enfin, se contente d'afficher les données en les échappant :

<h1><?= htmlspecialchars($article['titre']) ?></h1>
<p><?= htmlspecialchars($article['resume']) ?></p>

Chaque fichier a une seule raison de changer. Si la structure de la table évolue, seul le modèle est modifié ; si le graphiste refait la page, seule la vue l'est. Les versions récentes du langage, avec le typage des paramètres et des retours visible dans ces exemples, renforcent cette discipline, comme nous l'expliquons dans notre article sur PHP 8 et l'éco-conception.

Avantages et limites de l'architecture MVC

L'architecture MVC n'est pas une fin en soi. Elle apporte des bénéfices nets sur les applications appelées à durer, mais elle a aussi un coût qu'il faut connaître avant de l'adopter. Le tableau ci-dessous résume l'arbitrage.

AvantagesLimites
Code rangé selon des conventions partagées par toute l'équipeStructure disproportionnée pour un script ou une page isolée
Modèles réutilisables pour plusieurs vues ou une APIContrôleurs qui grossissent si la logique métier n'est pas déléguée
Interface modifiable sans toucher aux donnéesDavantage de fichiers à parcourir pour suivre une fonctionnalité
Chaque couche testable séparémentCourbe d'apprentissage pour un développeur habitué au code linéaire

La séparation des couches facilite en particulier les tests automatisés. Un modèle qui ne dépend pas de l'affichage se teste en isolant ses règles métier, ce qui rend possible une démarche comme le développement piloté par les tests (TDD).

La limite la plus fréquente en pratique est le « contrôleur obèse ». Lorsque les développeurs y ajoutent des calculs, des envois d'e-mails et des appels à des services externes, le contrôleur devient aussi difficile à maintenir qu'un ancien script monolithique. La parade consiste à déplacer ces traitements dans des classes de service ou dans le modèle. Sur les applications importantes, MVC se combine d'ailleurs avec un découpage en modules fonctionnels, que nous détaillons dans notre article sur l'architecture modulaire en développement web.

MVC et frameworks : Laravel, Symfony, Django ou PHP natif

La plupart des frameworks web côté serveur reprennent les principes de l'architecture MVC, avec des variantes de vocabulaire. Le guide officiel de Ruby on Rails indique que le code d'une application Rails est organisé selon l'architecture MVC. En PHP, Laravel et Symfony structurent les projets autour de contrôleurs, de modèles ou d'entités, et de gabarits pour l'affichage.

Le vocabulaire varie pourtant d'un outil à l'autre. Django, framework web écrit en Python, se présente plutôt comme un framework « MTV » (modèle, gabarit, vue) : dans sa terminologie, la « vue » choisit les données à présenter et le gabarit décide de leur apparence, tandis que le rôle du contrôleur est assuré par le framework lui-même, comme l'explique la FAQ officielle de Django. Côté navigateur, les bibliothèques d'interface comme React ne relèvent pas de MVC : elles ne gèrent que la vue et s'appuient sur d'autres modèles d'organisation.

Faut-il pour autant un framework ? Pas nécessairement. Un framework apporte des outils prêts à l'emploi, mais aussi des dépendances à mettre à jour et un poids que l'application n'utilise pas toujours. Une architecture MVC en PHP natif, avec un routeur et quelques classes de base, reste plus légère et entièrement maîtrisée. C'est le choix que nous faisons pour nos projets de développement web sur mesure : le client reste propriétaire d'un code lisible, sans dépendre du calendrier de mises à jour d'un outil tiers.

FAQ sur le modèle-vue-contrôleur

Les questions ci-dessous reviennent souvent lorsqu'une équipe découvre l'architecture MVC ou hésite à restructurer une application existante.

Peut-on utiliser le même modèle pour différentes vues ?

Oui. Le modèle est indépendant de l'affichage : la même méthode qui récupère une liste de commandes peut alimenter un tableau de bord, un export comptable et une API. C'est l'un des principaux intérêts de la séparation des couches.

Comment le contrôleur sait-il quelle vue afficher ?

Le routeur désigne le contrôleur et la méthode à appeler ; la méthode choisit ensuite la vue selon la situation. Un formulaire valide mène par exemple à une redirection vers une page de confirmation, alors qu'un formulaire incomplet réaffiche la même vue avec les messages d'erreur.

Peut-on adapter la structure MVC à son projet ?

Oui, à condition de conserver la séparation des responsabilités. Ajouter une couche de services, regrouper les fichiers par module fonctionnel ou isoler une API dans ses propres contrôleurs sont des adaptations courantes et saines.

Une application existante peut-elle passer en MVC ?

Oui, progressivement. On commence généralement par installer un point d'entrée unique et un routeur, puis on migre les pages une à une en extrayant les requêtes vers des modèles et le HTML vers des vues. Cette reprise peut se mener sans interrompre le service.

Structurer votre application métier avec une architecture MVC

Une architecture MVC bien appliquée se remarque surtout dans la durée : les évolutions se chiffrent plus facilement, les anomalies se localisent plus vite et un nouveau développeur prend ses marques sans devoir déchiffrer un code entremêlé. C'est particulièrement vrai pour les outils métier, les intranets et les extranets, qui accumulent les fonctionnalités au fil des années.

Codyweb développe des applications métier et outils sur mesure en PHP natif, structurés en MVC et pensés pour évoluer avec votre activité. Si votre application actuelle devient difficile à maintenir, ou si vous préparez un nouvel outil, nous pouvons en discuter sous accord de confidentialité si nécessaire.

0/5

- 0 vote(s)

604
Mathieu F.

Mathieu est un développeur web chevronné avec plus de 15 ans d'expérience dans le domaine. Il est le fondateur et créateur de Codyweb, notre entreprise spécialisée dans le développement web et la conception de sites web éco-responsables. Il a travaillé sur de nombreux projets de sites web pour différentes entreprises, ce qui lui a permis d'acquérir une expertise approfondie dans le domaine. Passionné par les nouvelles technologies et dévoué à la cause de l'éco-conception et du numérique responsable, Mathieu aime partager son savoir et ses connaissances à travers des articles et des ressources informatives.

Contact

Vous avez un projet en tête ?

Site internet, application métier ou refonte : nous vous proposons un échange de cadrage gratuit pour évaluer vos besoins et vous remettre une estimation sous 48 h.

Décollez votre projet web avec Codyweb

Découvrez d'autres articles sur le sujet : Code & Architecture

Continuez votre lecture et explorez nos contenus autour de code & architecture, entre conseils, innovations et retours d’expérience.