Sommaire
Retour à la liste

Comprendre et implémenter le modèle MVC (Modèle-Vue-Contrôleur) en PHP

Publié le 13/01/2026 par Frédéric dans la catégorie "Architecture"

Le MVC (Modèle-Vue-Contrôleur) est un design pattern architectural largement utilisé en développement web pour séparer les responsabilités entre la logique métier, l'interface utilisateur et la gestion des requêtes. En PHP, ce modèle permet d'organiser le code de manière modulaire, maintenable et évolutive, en évitant le mélange de HTML et de logique PHP dans un seul fichier.

🔹 Avantages : ✅ Meilleure séparation des concerns (logique, affichage, contrôle) ✅ Code plus lisible et maintenable ✅ Réutilisabilité des composants ✅ Facilité de collaboration en équipe ✅ Testabilité améliorée (unit tests, intégration tests)

🔹 Cas d'usage :

  • Développement d'applications web structurées (CMS, e-commerce, SaaS)
  • Projets nécessitant une évolutivité (ajout de fonctionnalités sans tout réécrire)
  • Équipes travaillant en agile avec une base de code propre
Prompt pour l'IA
Analyse ce code PHP et vérifie qu'il respecte bien les principes du modèle MVC.
Pour chaque composant (Modèle, Vue, Contrôleur), vérifie :

1. **Modèle (Model)** :
   - Contient-il uniquement la logique métier et les interactions avec la base de données ?
   - Utilise-t-il des classes/méthodes pour représenter les données (ex: `User`, `Product`) ?
   - Évite-t-il toute logique d'affichage ou de gestion de requêtes HTTP ?

2. **Vue (View)** :
   - Se limite-t-elle à l'affichage (HTML + balises PHP minimales comme `<?= $variable ?>`) ?
   - Contient-elle des boucles ou conditions uniquement pour l'affichage (ex: `foreach` pour lister des articles) ?
   - Évite-t-elle les requêtes SQL ou la logique métier ?

3. **Contrôleur (Controller)** :
   - Gère-t-il les requêtes HTTP (GET, POST) et les redirections ?
   - Fait-il le lien entre le Modèle (récupération des données) et la Vue (passage des données) ?
   - Évite-t-il de contenir du HTML ou des requêtes SQL directes ?

4. **Structure globale** :
   - Les fichiers sont-ils organisés dans des dossiers distincts (`/models`, `/views`, `/controllers`) ?
   - Y a-t-il un fichier d'entrée unique (ex: `index.php`) qui route les requêtes vers les contrôleurs ?
   - Le code utilise-t-il l'autoloading (via Composer ou `spl_autoload_register`) pour charger les classes ?

**Exemple de code à analyser** :
[Coller ici le code ou décrire l'architecture]

**Questions supplémentaires** :
- Le code utilise-t-il un framework MVC (Laravel, Symfony) ou est-ce une implémentation "from scratch" ?
- Y a-t-il des violations évidentes du principe de responsabilité unique (SRP) ?
- Comment sont gérées les dépendances entre les composants (injection de dépendances, singletons) ?

Explication détaillée

📚 Article Détaillé : Le Modèle MVC en PHP

1. Introduction au MVC

Le MVC est un pattern architectural qui divise une application en trois composants principaux :

  • Modèle (Model) : Gère les données et la logique métier.
  • Vue (View) : Gère l'affichage (interface utilisateur).
  • Contrôleur (Controller) : Fait le lien entre le Modèle et la Vue, en traitant les requêtes utilisateur.

👉 Pourquoi utiliser MVC en PHP ? PHP a longtemps été critiqué pour son manque de structure (mélange de HTML et PHP dans les mêmes fichiers). Le MVC résout ce problème en imposant une séparation claire, ce qui rend le code :

  • Plus facile à maintenir (modifications localisées).
  • Plus sécurisé (meilleure gestion des entrées/sorties).
  • Plus testable (isolation des composants).

2. Les 3 Composants du MVC

🔹 Modèle (Model)

Rôle :

  • Représente les données et la logique métier.
  • Interagit avec la base de données (via PDO, Eloquent, Doctrine, etc.).
  • Ne doit pas contenir de logique d'affichage ou de gestion de requêtes HTTP.

Exemple en PHP :

// Fichier : models/User.php
class User {
    private $db;

    public function __construct(PDO $db) {
        $this->db = $db;
    }

    public function getAllUsers() {
        $stmt = $this->db->query("SELECT * FROM users");
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }

    public function createUser($name, $email) {
        $stmt = $this->db->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
        return $stmt->execute([$name, $email]);
    }
}

✅ Bonnes pratiques :

  • Utiliser des classes pour représenter les entités (ex: User, Product).
  • Éviter les requêtes SQL directes dans les contrôleurs/vues.
  • Utiliser des interfaces pour les dépendances (ex: UserRepositoryInterface).

🎨 Vue (View)

Rôle :

  • Affiche les données à l'utilisateur (HTML + PHP minimal).
  • Ne doit pas contenir de logique métier ou de requêtes SQL.

Exemple en PHP :

<!-- Fichier : views/users/list.php -->
<!DOCTYPE html>
<html>
<head>
    <title>Liste des utilisateurs</title>
</head>
<body>
    <h1>Utilisateurs</h1>
    <ul>
        <?php foreach ($users as $user): ?>
            <li><?= htmlspecialchars($user['name']) ?> (<?= htmlspecialchars($user['email']) ?>)</li>
        <?php endforeach; ?>
    </ul>
</body>
</html>

✅ Bonnes pratiques :

  • Utiliser <?= ?> pour afficher des variables (équivalent à <?php echo ?>).
  • Échapper les sorties (htmlspecialchars()) pour éviter les failles XSS.
  • Éviter les boucles/conditions complexes (les préparer dans le contrôleur).

⚙️ Contrôleur (Controller)

Rôle :

  • Reçoit les requêtes HTTP (GET, POST, etc.).
  • Appelle le Modèle pour récupérer/modifier des données.
  • Passe les données à la Vue pour affichage.

Exemple en PHP :

// Fichier : controllers/UserController.php
class UserController {
    private $userModel;

    public function __construct(User $userModel) {
        $this->userModel = $userModel;
    }

    public function listUsers() {
        $users = $this->userModel->getAllUsers();
        include __DIR__ . '/../views/users/list.php';
    }

    public function createUser() {
        if ($_SERVER['REQUEST_METHOD'] === 'POST') {
            $name = $_POST['name'] ?? '';
            $email = $_POST['email'] ?? '';
            $this->userModel->createUser($name, $email);
            header('Location: /users');
            exit;
        }
        include __DIR__ . '/../views/users/create.php';
    }
}

✅ Bonnes pratiques :

  • Valider les entrées (filter_input, filter_var).
  • Gérer les erreurs (exceptions, redirections).
  • Éviter la logique d'affichage (déléguer à la Vue).

3. Structure de Fichiers Typique

my-mvc-app/
├── index.php          # Point d'entrée (front controller)
├── config/
│   └── database.php   # Configuration de la BDD
├── models/
│   └── User.php       # Modèle User
├── views/
│   └── users/
│       ├── list.php   # Vue pour lister les users
│       └── create.php # Vue pour créer un user
├── controllers/
│   └── UserController.php
└── public/            # Fichiers accessibles publiquement (CSS, JS, images)

4. Implémentation Paso a Paso

Étape 1 : Configuration de l'Autoloading

Utilisez Composer pour charger automatiquement les classes :

composer init
composer dump-autoload

Ou utilisez spl_autoload_register :

spl_autoload_register(function ($class) {
    require __DIR__ . '/../' . str_replace('\\', '/', $class) . '.php';
});

Étape 2 : Point d'Entrée Unique (index.php)

<?php
require __DIR__ . '/../vendor/autoload.php';
require __DIR__ . '/../config/database.php';

// Routing basique (à améliorer avec un router comme FastRoute)
$action = $_GET['action'] ?? 'list';
$controller = new \Controllers\UserController(new \Models\User($db));

if ($action === 'list') {
    $controller->listUsers();
} elseif ($action === 'create') {
    $controller->createUser();
} else {
    header('HTTP/1.0 404 Not Found');
    echo 'Page introuvable';
}

Étape 3 : Utilisation d'un Router (Optionnel)

Pour une meilleure gestion des routes, utilisez un package comme nikic/FastRoute :

$dispatcher = FastRoute\simpleDispatcher(function(FastRoute\RouteCollector $r) {
    $r->addRoute('GET', '/users', [UserController::class, 'listUsers']);
    $r->addRoute('GET', '/users/create', [UserController::class, 'createUser']);
});

// Match la route courante
$routeInfo = $dispatcher->dispatch($_SERVER['REQUEST_METHOD'], $_SERVER['REQUEST_URI']);
switch ($routeInfo[0]) {
    case FastRoute\Dispatcher::FOUND:
        $controller = $routeInfo[1][0];
        $method = $routeInfo[1][1];
        (new $controller())->$method();
        break;
    default:
        http_response_code(404);
        echo '404 Not Found';
}

5. Avantages et Inconvénients du MVC en PHP

✅ Avantages ❌ Inconvénients
Séparation claire des responsabilités Courbe d'apprentissage pour les débutants
Code plus maintenable Surcharge pour les petits projets
Facilité de tests (unitaires, intégration) Configuration initiale plus complexe
Réutilisabilité des composants Risque de sur-ingénierie si mal implémenté
Collaboration facilitée en équipe Performances légèrement impactées (mais négligeable)

6. Frameworks PHP Utilisant MVC

Si vous ne voulez pas tout coder from scratch, voici des frameworks populaires basés sur MVC :

  • Laravel (avec Eloquent ORM et Blade pour les vues)
  • Symfony (modulaire, avec Doctrine et Twig)
  • CodeIgniter (léger et simple)
  • Yii2 (performant et sécurisé)

👉 Quand utiliser un framework ?

  • Pour des projets complexes (e-commerce, SaaS).
  • Si vous avez besoin de fonctionnalités intégrées (authentification, ORM, caching).
  • Pour gagner du temps sur la structure de base.

7. Bonnes Pratiques Supplémentaires

  1. Utiliser des interfaces pour les Modèles (ex: UserRepositoryInterface).
  2. Valider les données en entrée (avec filter_var ou des libs comme respect/validation).
  3. Échapper les sorties pour éviter les failles XSS (htmlspecialchars).
  4. Utiliser des migrations pour la base de données (ex: php-migrations/phinx).
  5. Implémenter un système de cache (Redis, Memcached) pour les données fréquemment accédées.
  6. Documenter le code avec PHPDoc et des outils comme phpDocumentor.

8. Exemple Complet : Mini-Application MVC

Structure :

mini-mvc/
├── public/
│   └── index.php
├── src/
│   ├── Models/
│   │   └── User.php
│   ├── Views/
│   │   └── users/
│   │       ├── list.php
│   │       └── create.php
│   └── Controllers/
│       └── UserController.php
├── config/
│   └── database.php
└── vendor/

9. Conclusion

Le MVC est un standard industriel pour structurer les applications PHP. Bien que sa mise en place demande un effort initial, il offre : ✔ Un code organisé et maintenable. ✔ Une meilleure collaboration en équipe. ✔ Une évolutivité facilitée.

🔹 Pour aller plus loin :

  • Étudier les design patterns complémentaires (Repository, Factory, Observer).
  • Explorer les frameworks MVC (Laravel, Symfony).
  • Automatiser les tests avec PHPUnit.

📌 Ressources Utiles

❓ FAQ Q : Le MVC est-il obligatoire en PHP ? R : Non, mais fortement recommandé pour les projets de taille moyenne/grande.

Q : Puis-je mixer MVC avec d'autres patterns ? R : Oui ! Par exemple, utiliser le Repository Pattern pour les Modèles ou le Dependency Injection pour les Contrôleurs.

Q : Comment gérer les requêtes AJAX en MVC ? R : Les contrôleurs peuvent retourner du JSON au lieu d'appeler une Vue :

public function getUsersJson() {
    header('Content-Type: application/json');
    echo json_encode($this->userModel->getAllUsers());
}