Tutoriel MVC PHP (PDO / MySQL)

<?php

// Chargement du routeur central
require_once '../core/Router.php';

// Instanciation du routeur
$router = new Router();

// Chargement des routes déclarées dans routes/web.php
require_once '../routes/web.php';

// Démarrage du routeur : analyse l'URL et dispatche vers le bon contrôleur
$router->run();

RewriteEngine On

# Si le fichier ou dossier demandé n'existe pas physiquement sur le serveur
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d

# Redirige toutes les requêtes vers public/index.php
RewriteRule ^(.*)$ public/index.php [QSA,L]

<?php

// Retourne un tableau de configuration pour la connexion PDO
// Ce fichier est chargé par core/Model.php
return [
    'host'     => 'localhost',   // Hôte MySQL (souvent localhost en dev)
    'dbname'   => 'mvc_app',     // Nom de la base de données créée précédemment
    'user'     => 'root',        // Utilisateur MySQL
    'password' => ''             // Mot de passe (vide par défaut avec XAMPP/WAMP)
];

<?php

/**
 * Classe Model – Classe parente de tous les modèles de l'application.
 * Elle centralise la connexion PDO pour éviter de la répéter dans chaque modèle.
 */
class Model
{
    // Propriété partagée : instance PDO accessible dans toutes les sous-classes
    protected $db;

    public function __construct()
    {
        // Chargement de la configuration depuis config/database.php
        $config = require '../config/database.php';

        // Création de la connexion PDO avec le DSN MySQL
        $this->db = new PDO(
            "mysql:host={$config['host']};dbname={$config['dbname']};charset=utf8mb4",
            $config['user'],
            $config['password']
        );

        // Mode d'erreur : lance une exception en cas d'erreur SQL (facilite le débogage)
        $this->db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

        // Retourne les résultats sous forme de tableaux associatifs par défaut
        $this->db->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
    }
}

<?php

/**
 * Classe Router – Analyse l'URL et dispatche vers le bon contrôleur et la bonne action.
 */
class Router
{
    // Tableau des routes enregistrées : ['METHOD /chemin' => callable]
    private $routes = [];

    /**
     * Enregistre une route GET.
     * @param string   $path     L'URL à matcher (ex: '/users')
     * @param callable $callback La fonction ou méthode à exécuter
     */
    public function get($path, $callback)
    {
        $this->routes['GET ' . $path] = $callback;
    }

    /**
     * Enregistre une route POST.
     */
    public function post($path, $callback)
    {
        $this->routes['POST ' . $path] = $callback;
    }

    /**
     * Démarre le routeur : compare l'URL courante aux routes enregistrées.
     */
    public function run()
    {
        // Récupère la méthode HTTP (GET ou POST)
        $method = $_SERVER['REQUEST_METHOD'];

        // Récupère le chemin URL sans les paramètres de requête
        $uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

        foreach ($this->routes as $route => $callback) {
            // Convertit les segments dynamiques comme {id} en regex
            [$routeMethod, $routePath] = explode(' ', $route, 2);
            $pattern = preg_replace('/\{[a-z]+\}/', '([^/]+)', $routePath);
            $pattern = '#^' . $pattern . '$#';

            if ($routeMethod === $method && preg_match($pattern, $uri, $matches)) {
                // Supprime le match complet, garde uniquement les paramètres
                array_shift($matches);
                // Appelle le callback avec les paramètres extraits de l'URL
                call_user_func_array($callback, $matches);
                return;
            }
        }

        // Aucune route correspondante → erreur 404
        http_response_code(404);
        echo "<h1>404 – Page non trouvée</h1>";
    }
}

<?php

// Chargement du contrôleur utilisateur
require_once '../app/controllers/UserController.php';

$controller = new UserController();

// Affiche la liste des utilisateurs
$router->get('/users', function() use ($controller) {
    $controller->index();
});

// Affiche le formulaire de création
$router->get('/users/create', function() use ($controller) {
    $controller->create();
});

// Traite le formulaire de création (POST)
$router->post('/users/store', function() use ($controller) {
    $controller->store();
});

// Affiche le formulaire de modification pour l'utilisateur {id}
$router->get('/users/edit/{id}', function($id) use ($controller) {
    $controller->edit($id);
});

// Traite le formulaire de modification (POST)
$router->post('/users/update/{id}', function($id) use ($controller) {
    $controller->update($id);
});

// Supprime l'utilisateur {id}
$router->get('/users/delete/{id}', function($id) use ($controller) {
    $controller->delete($id);
});

<?php

require_once '../core/Model.php';

/**
 * Classe User – Modèle représentant la table `users`.
 * Contient UNIQUEMENT les opérations SQL (jamais de HTML ici).
 */
class User extends Model
{
    /**
     * Récupère tous les utilisateurs de la table.
     * @return array Tableau de tous les utilisateurs
     */
    public function getAll()
    {
        // query() suffit pour une requête sans paramètre dynamique
        return $this->db
                    ->query("SELECT * FROM users ORDER BY id DESC")
                    ->fetchAll(PDO::FETCH_ASSOC);
    }

    /**
     * Récupère un utilisateur par son identifiant.
     * @param int $id L'identifiant de l'utilisateur
     * @return array|false Les données de l'utilisateur ou false si non trouvé
     */
    public function getById($id)
    {
        // prepare() + execute() = requête préparée → protège contre les injections SQL
        $stmt = $this->db->prepare("SELECT * FROM users WHERE id = ?");
        $stmt->execute([$id]);
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }

    /**
     * Insère un nouvel utilisateur.
     * @param string $name  Le nom de l'utilisateur
     * @param string $email L'adresse email
     * @return bool true en cas de succès
     */
    public function create($name, $email)
    {
        $stmt = $this->db->prepare(
            "INSERT INTO users (name, email) VALUES (?, ?)"
        );
        return $stmt->execute([$name, $email]);
    }

    /**
     * Met à jour les données d'un utilisateur existant.
     * @param int    $id    L'identifiant de l'utilisateur à modifier
     * @param string $name  Le nouveau nom
     * @param string $email Le nouvel email
     * @return bool true en cas de succès
     */
    public function update($id, $name, $email)
    {
        $stmt = $this->db->prepare(
            "UPDATE users SET name = ?, email = ? WHERE id = ?"
        );
        // Attention à l'ordre des paramètres : name, email, puis id
        return $stmt->execute([$name, $email, $id]);
    }

    /**
     * Supprime un utilisateur par son identifiant.
     * @param int $id L'identifiant de l'utilisateur à supprimer
     * @return bool true en cas de succès
     */
    public function delete($id)
    {
        $stmt = $this->db->prepare("DELETE FROM users WHERE id = ?");
        return $stmt->execute([$id]);
    }
}

<?php

require_once '../app/models/User.php';

/**
 * Classe UserController – Contrôleur gérant toutes les actions CRUD sur les utilisateurs.
 * Le contrôleur fait le lien entre le modèle (données) et la vue (affichage).
 * Il ne contient ni SQL, ni HTML brut.
 */
class UserController
{
    /**
     * Action index – Affiche la liste de tous les utilisateurs.
     * Correspond à la route : GET /users
     */
    public function index()
    {
        $model = new User();
        $users = $model->getAll();           // Récupère les données via le modèle
        require '../app/views/users/index.php'; // Délègue l'affichage à la vue
    }

    /**
     * Action create – Affiche le formulaire de création d'un utilisateur.
     * Correspond à la route : GET /users/create
     */
    public function create()
    {
        require '../app/views/users/create.php';
    }

    /**
     * Action store – Traite le formulaire de création (méthode POST).
     * Correspond à la route : POST /users/store
     */
    public function store()
    {
        // Récupération et nettoyage des données du formulaire
        $name  = trim($_POST['name']  ?? '');
        $email = trim($_POST['email'] ?? '');

        // Validation basique avant insertion
        if (!empty($name) && filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $model = new User();
            $model->create($name, $email);
        }

        // Redirection vers la liste après enregistrement
        header("Location: /users");
        exit; // Important : stoppe l'exécution après un header redirect
    }

    /**
     * Action edit – Affiche le formulaire de modification d'un utilisateur.
     * Correspond à la route : GET /users/edit/{id}
     * @param int $id L'identifiant de l'utilisateur à modifier
     */
    public function edit($id)
    {
        $model = new User();
        $data  = $model->getById($id); // Récupère les données actuelles de l'utilisateur

        if (!$data) {
            // Si l'utilisateur n'existe pas, redirection vers la liste
            header("Location: /users");
            exit;
        }

        require '../app/views/users/edit.php'; // Passe $data à la vue
    }

    /**
     * Action update – Traite le formulaire de modification (méthode POST).
     * Correspond à la route : POST /users/update/{id}
     * @param int $id L'identifiant de l'utilisateur à mettre à jour
     */
    public function update($id)
    {
        $name  = trim($_POST['name']  ?? '');
        $email = trim($_POST['email'] ?? '');

        if (!empty($name) && filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $model = new User();
            $model->update($id, $name, $email);
        }

        header("Location: /users");
        exit;
    }

    /**
     * Action delete – Supprime un utilisateur.
     * Correspond à la route : GET /users/delete/{id}
     * @param int $id L'identifiant de l'utilisateur à supprimer
     */
    public function delete($id)
    {
        $model = new User();
        $model->delete($id);
        header("Location: /users");
        exit;
    }
}