Tutoriel MVC PHP MySQL

1. Point d’entrée unique & Sécurité

• Seul public/index.php est accessible via le navigateur.
• Dans une architecture MVC moderne, public/index.php est le point d’entrée unique (Front Controller). Il ne doit contenir aucune logique métier, ni routing, ni connexion DB. Son seul rôle est de préparer l’environnement, charger les dépendances et lancer le cœur de l’application.
• Voici une version professionnelle, sécurisée et commentée :

<?php
// public/index.php

// 1️⃣ Définir les constantes de chemins (fiables, indépendantes du serveur)
define('ROOT_PATH', dirname(__DIR__) . DIRECTORY_SEPARATOR);
define('PUBLIC_PATH', __DIR__ . DIRECTORY_SEPARATOR);

// 2️⃣ Charger l'autoloader Composer (gestion automatique des classes & namespaces)
require ROOT_PATH . 'vendor/autoload.php';

// 3️⃣ Configuration de l'environnement
// En production : display_errors = 0 | En développement : 1
ini_set('display_errors', 0); 
ini_set('log_errors', 1);
ini_set('error_log', ROOT_PATH . 'storage/logs/app.log');
error_reporting(E_ALL);
date_default_timezone_set('Europe/Paris');

// 4️⃣ (Optionnel mais recommandé) Charger les variables d'environnement
// if (file_exists(ROOT_PATH . '.env')) {
//     $dotenv = Dotenv\Dotenv::createImmutable(ROOT_PATH);
//     $dotenv->load();
// }

// 5️⃣ Exécution de l'application avec gestion globale des exceptions
try {
    // Instanciation du cœur de l'application
    $app = new App\Core\App();
    
    // Lancement du cycle de vie : config → routeur → contrôleur → vue
    $app->run();
} catch (Throwable $e) {
    // 🛡️ En production : on logue et on affiche une page 500 propre
    error_log($e->getMessage() . ' | Fichier: ' . $e->getFile() . ' | Ligne: ' . $e->getLine());
    
    http_response_code(500);
    
    // Affichage basique si le moteur de vue n'est pas encore chargé
    if (defined('ROOT_PATH')) {
        include ROOT_PATH . 'views/errors/500.php';
    } else {
        echo '<h1>Erreur Serveur Interne</h1><p>Veuillez réessayer plus tard.</p>';
    }
}

• Détail rôle par rôle

Bloc	Pourquoi ?	Bonne pratique
define(‘ROOT_PATH’, …)	Évite les chemins relatifs fragiles (../../) qui peuvent casser lors de l’inclusion de fichiers.	Utilisez __DIR__ et la constante DIRECTORY_SEPARATOR pour garantir la portabilité entre Windows et Linux.
vendor/autoload.php	Charge automatiquement les classes (core, controllers, models) via la norme PSR-4.	Indispensable pour la maintenance. Élimine l’utilisation de require ou include manuels à travers le projet.
ini_set() & error_reporting()	Permet de contrôler finement la visibilité et le niveau de détail des erreurs PHP.	Désactivez display_errors (0) en production. Redirigez les erreurs vers des fichiers logs dans storage/logs/.
try/catch (Throwable)	Capture les erreurs fatales, les exceptions et les warnings qui n’ont pas été gérés par le code.	En cas d’échec, affichez une page d’erreur 500 propre à l’utilisateur et enregistrez l’erreur détaillée pour le débogage.
$app->run()	Délègue toute la logique d’exécution au cœur du framework MVC.	Le fichier index.php doit rester léger : il ne doit ni router, ni se connecter à la DB, ni charger de vue directement.

2. Le fichier public/.htaccess
• .htaccess (Apache) ou nginx.conf doit réécrire toutes les requêtes vers index.php.
• Désactivez display_errors en production. Utilisez un système de logs (storage/logs/).
• Contenu de public/.htaccess

# public/.htaccess


    RewriteEngine On
    RewriteBase /

    # 🛡️ Bloquer l'accès direct aux fichiers/dossiers cachés (.env, .git, .DS_Store, etc.)
    RewriteRule (^\.|/\.) - [F]

    # 📁 Si la requête pointe vers un fichier ou dossier réel, on le sert directement
    # (CSS, JS, images, fonts dans public/assets/)
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d

    # 🔄 Sinon, on redirige TOUTE autre requête vers le point d'entrée PHP
    RewriteRule ^ index.php [QSA,L]


# 🔒 Désactiver le listage de dossiers
Options -Indexes

# 📦 Headers de sécurité (optionnel mais fortement recommandé)

    Header set X-Content-Type-Options "nosniff"
    Header set X-Frame-Options "DENY"
    Header set Referrer-Policy "strict-origin-when-cross-origin"

• Rôle ligne par ligne

Directive	Utilité
RewriteEngine On	Active le module de réécriture d’URL d’Apache, indispensable pour transformer les URLs virtuelles en requêtes traitables par PHP.
RewriteCond !-f / !-d	Vérifie que la requête ne correspond pas à un fichier (-f) ou un dossier (-d) existant. Cela permet d’accéder directement aux images, CSS et JS sans passer par le routeur.
RewriteRule ^ index.php [QSA,L]	Redirige toutes les requêtes vers index.php. QSA (Query String Append) préserve les paramètres URL (ex: ?id=5), et L (Last) indique qu’il s’agit de la dernière règle à appliquer.
Options -Indexes	Mesure de sécurité majeure : empêche Apache d’afficher la liste des fichiers d’un dossier si le fichier d’index (index.php/html) est absent.
RewriteRule (^.|/.) – [F]	Interdit l’accès (Forbidden) aux fichiers cachés commençant par un point (comme .env ou .git), protégeant ainsi vos informations sensibles.

• Débriefing pédagogique (Questions / Réponses)

Question	Réponse attendue	Exemple / Illustration
Pourquoi [L] est indispensable ?	Il stoppe l’exécution des règles suivantes. Sans lui, Apache pourrait réécrire l’URL en boucle ou appliquer d’autres règles non désirées.	Si vous avez une règle A qui transforme l’URL et une règle B juste après, sans [L], Apache tentera d’appliquer B sur le résultat de A.
Que fait QSA (Query String Append) ?	Il préserve et ajoute les paramètres ?clé=valeur de l’URL originale à la redirection vers index.php. Indispensable pour les formulaires GET, filtres, pagination.	Une URL /produits?page=2 est réécrite en index.php?page=2. Sans QSA, on recevrait juste index.php (donnée perdue).
Pourquoi !-f et !-d avant la réécriture ?	Pour éviter que le routeur PHP ne prenne le contrôle sur des assets statiques (CSS, JS, images), ce qui tuerait les performances et casserait l’affichage.	Si l’utilisateur demande /style.css, Apache le sert directement. Sans ces lignes, il chercherait un contrôleur « Style » dans votre code PHP.
Pourquoi .htaccess dans public/ et pas à la racine ?	Le DocumentRoot du serveur doit pointer vers public/. Ainsi, config/, core/, .env sont physiquement hors d’atteinte HTTP. Aucune règle .htaccess ne peut remplacer une mauvaise architecture de dossiers.	En pointant sur public/, une requête vers monsite.com/.env renverra une erreur 404 car le fichier est « au-dessus » dans l’arborescence.
Comment savoir si mod_rewrite est actif ?	apache2ctl -M | grep rewrite ou tester avec une règle simple et voir si elle s’applique. Sinon, activer via a2enmod rewrite + redémarrer Apache.	Si vous écrivez n’importe quoi dans le .htaccess et que le site ne plante pas en « Internal Server Error 500 », c’est que le module (ou le fichier) est ignoré.

3. core/Controller.php et core/Model.php

• core/Controller.php – Classe mère des contrôleurs

<?php
namespace App\Core;

class Controller 
{
    /**
     * Affiche une vue avec un layout commun (header + footer)
     * 
     * @param string $view Chemin relatif dans views/ (ex: "client/index")
     * @param array  $data Variables à passer à la vue
     */
    protected function render(string $view, array $data = []): void 
    {
        // Rend les variables disponibles dans la vue (ex: $users, $title)
        extract($data);

        // Inclusion du layout et de la vue
        require_once ROOT_PATH . 'views/layouts/header.php';
        require_once ROOT_PATH . "views/{$view}.php";
        require_once ROOT_PATH . 'views/layouts/footer.php';
        
        // ⛔ STOPPE l'exécution pour éviter d'afficher du code après la vue
        exit;
    }

    /**
     * Redirection HTTP propre
     */
    protected function redirect(string $url, int $code = 302): void 
    {
        header("Location: {$url}", true, $code);
        exit;
    }

    /**
     * Retourne une réponse JSON (utile pour AJAX/API)
     */
    protected function json(mixed $data, int $code = 200): void 
    {
        header('Content-Type: application/json', true, $code);
        echo json_encode($data, JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
        exit;
    }
}

• core/Model.php – Classe mère des modèles (PDO sécurisé)

db = self::getConnection();
    }

    /**
     * Retourne une connexion PDO unique et partagée
     */
    private static function getConnection(): PDO 
    {
        if (self::$pdoInstance === null) {
            try {
                // 📦 Récupère la config (à adapter selon votre système de chargement)
                $host     = $_ENV['DB_HOST']     ?? '127.0.0.1';
                $dbname   = $_ENV['DB_NAME']     ?? 'mvc_app';
                $username = $_ENV['DB_USER']     ?? 'root';
                $password = $_ENV['DB_PASS']     ?? '';
                $charset  = $_ENV['DB_CHARSET']  ?? 'utf8mb4';

                $dsn = "mysql:host={$host};dbname={$dbname};charset={$charset}";
                
                $options = [
                    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION, // ⚠️ Lève des exceptions sur erreur SQL
                    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,       // Retourne des tableaux associatifs
                    PDO::ATTR_EMULATE_PREPARES   => false,                  // ⚠️ Utilise les vraies requêtes préparées (sécurité)
                    PDO::ATTR_PERSISTENT         => false,
                ];

                self::$pdoInstance = new PDO($dsn, $username, $password, $options);
            } catch (PDOException $e) {
                // 🔒 Ne jamais exposer l'erreur brute en production
                error_log('DB Connection Error: ' . $e->getMessage());
                throw new PDOException('Impossible de se connecter à la base de données.', 0, $e);
            }
        }

        return self::$pdoInstance;
    }

    /**
     * Exécute une requête préparée et retourne le statement
     */
    protected function query(string $sql, array $params = []): \PDOStatement 
    {
        $stmt = $this->db->prepare($sql);
        $stmt->execute($params);
        return $stmt;
    }

    /**
     * Retourne UN seul résultat
     */
    protected function fetch(string $sql, array $params = []): array|false 
    {
        return $this->query($sql, $params)->fetch();
    }

    /**
     * Retourne TOUS les résultats
     */
    protected function fetchAll(string $sql, array $params = []): array 
    {
        return $this->query($sql, $params)->fetchAll();
    }
}

4. Fichier core/Router.php et routers/web.php

• Rôle du Router dans le cycle MVC
• Le routeur a 3 missions principales :
• Parser l’URL demandée, quel que soit l’environnement (localhost/sous-dossier/Virtual Host)
• Faire correspondre cette URL à une route définie (ex: /client/5 → ClientController@show)
• Instancier et exécuter le bon contrôleur avec les bons paramètres

1. Connexion Base de Données (config/database.php)

• Rôle de config/database.php dans l’architecture MVC
Application PHP
↓
config/database.php ← « Où est la BDD ? Quels sont les accès ? »
↓
core/Model.php ← « Comment se connecter et exécuter des requêtes ? »
↓
PDO (PHP Data Objects) ← Driver de connexion réel
↓
MySQL / MariaDB
• Ses 3 missions principales :

Mission	Description	Pourquoi c’est crucial
🔐 Centraliser les credentials	Host, dbname, user, pass dans un seul endroit	Évite de disperser les mots de passe dans tout le code
♻️ Gérer une connexion unique	Pattern Singleton → une seule instance PDO pour toute l’app	Évite les fuites de connexions, améliore les performances
⚙️ Configurer PDO proprement	Options de sécurité, encodage, mode d’erreur	Bloque les injections SQL, garantit la cohérence des données

<?php
class Database {
    private static ?PDO $instance = null;

    private function __construct() {
        $host   = '127.0.0.1';
        $db     = 'base_test';
        $user   = 'root';
        $pass   = '';
        $charset = 'utf8mb4';

        $dsn = "mysql:host=$host;dbname=$db;charset=$charset";
        $options = [
            PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES   => false,
        ];

        try {
            self::$instance = new PDO($dsn, $user, $pass, $options);
        } catch (PDOException $e) {
            error_log($e->getMessage());
            die('Erreur de connexion à la base de données.');
        }
    }

    public static function getInstance(): PDO {
        if (self::$instance === null) {
            new self();
        }
        return self::$instance;
    }
}

2. Le Modèle Parent (core/Model.php)

• Rôle de core/Model.php dans l’architecture MVC
Contrôleur (ClientController)
↓
Modèle (Client extends Model) ← « Je veux récupérer des clients »
↓
core/Model.php (abstrait) ← « Voici comment se connecter et exécuter des requêtes »
↓
config/database.php (Database::getInstance())
↓
PDO → MySQL

<?php
require_once __DIR__ . '/../config/database.php';

abstract class Model {
    protected PDO $db;
    protected string $table;

    public function __construct() {
        $this->db = Database::getInstance();
    }
}

2. Le Contrôleur Parent (core/Controller.php)

<?php
/**
 * Classe mère abstraite de tous les contrôleurs
 * Fournit les méthodes de rendu, redirection et réponse JSON
 */
abstract class Controller {
    protected function render(string $view, array $data = []): void {
        extract($data);
        $viewPath = __DIR__ . '/../views/' . $view . '.php';

        if (!file_exists($viewPath)) {
            http_response_code(404);
            die("Vue introuvable : $view");
        }
        require_once $viewPath;
    }
}