Front controller
Le Front Controller est un fichier unique qui constitue le point d’entrée principal d’une application web reposant sur une architecture MVC.
Toutes les requêtes HTTP y sont redirigées afin qu’il analyse l’URL demandée et délègue le traitement au contrôleur et à l’action correspondants.
Dans notre cas, ce rôle est assuré par le fichier public/index.php.
Dans un premier temps, nous allons montrer comment extraire, à partir de l’URL, les informations relatives au contrôleur et à l’action.
Par exemple : utilisateur/create correspond au contrôleur utilisateur et à l’action create.
Définition : public/index.php
Ce fichier constitue le point d’entrée unique de l’application. Son rôle est pour l’instant de récupérer l’URL demandée par le navigateur et d’en extraire les informations nécessaires pour déterminer quel fichier PHP doit être exécuté.
récupérer l’URL demandée ;
supprimer le chemin correspondant au dossier
public;découper l’URL en différents segments ;
utiliser le premier segment comme contrôleur ;
utiliser le deuxième segment comme action ;
rechercher le fichier PHP correspondant.
https://localhost/sites/site-php-7-rewrite/public/utilisateur/show?id=2 => $controller = « utilisateur »; $action = « show »
/** * Routeur minimaliste * ------------------- * Rôle : * - Nettoyer l’URL * - Extraire contrôleur + action * - Inclure dynamiquement le bon fichier contrôleur */// Chargement du modèle (fonctions d’accès à la base de données)require '../app/models/model.php';
// Chargement des helpers (fonctions utilitaires) require '../app/helpers.php';
/* ------------------------------------------------------------- Construction du chemin demandé à partir de l’URL du client et du script d’entrée public/index.php------------------------------------------------------------- */// Récupère le chemin demandé, sans les paramètres GET$requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
// Récupère le dossier de base de l'application$basePath = str_replace('\\', '/', dirname($_SERVER['SCRIPT_NAME']));
// Supprime le chemin de base s'il est présentif (str_starts_with($requestUri, $basePath)) {
$requestUri = substr($requestUri, strlen($basePath));
}
// Normalise le chemin en ajoutant un seul / au début$path = '/' . ltrim($requestUri, '/');
/* ------------------------------------------------------------- Découpage du chemin en segments pour déterminer le contrôleur et l’action------------------------------------------------------------- */$params = $path === '/' ? [] : explode('/', trim($path, '/'));
// controleur et action par défaut si non précisés dans l'URL$controller = $params[0] ?? 'home';
$action = $params[1] ?? 'index';
/* ------------------------------------------------------------- Gestion des erreurs : contrôleur ou action manquants------------------------------------------------------------- */$controllerFile = "../app/controllers/$controller/$action.php";
if (!file_exists($controllerFile)) {
http_response_code(404);
$controllerFile = "../app/controllers/error/index.php";
}
/* ------------------------------------------------------------- Inclusion dynamique du fichier contrôleur------------------------------------------------------------- */require $controllerFile;
Construction du chemin :
$requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$basePath = str_replace('\\', '/', dirname($_SERVER['SCRIPT_NAME']));
if (str_starts_with($requestUri, $basePath)) {
$requestUri = substr($requestUri, strlen($basePath));
}
$path = '/' . ltrim($requestUri, '/');
Récupère l'URL demandée et remplace les \ par des / pour avoir un chemin uniforme, notamment sous Windows.
URL demandée : https://localhost/sites/site-php-7-rewrite/public/utilisateur/show?id=2
$_SERVER['REQUEST_URI'] : /sites/site-php-7-rewrite/public/utilisateur/show?id=2
$_SERVER['SCRIPT_NAME'] : /sites/site-php-7-rewrite/public/index.php
$requestUri (avant suppression de la base) : /sites/site-php-7-rewrite/public/utilisateur/show
$basePath : /sites/site-php-7-rewrite/public
$requestUri (après suppression) : /utilisateur/show
$path : /utilisateur/show
Résumé :
Ce fichier permet de simplifier l’ensemble du reste du code de l’application.
Il n’est désormais plus nécessaire de conserver le dossier utilisateur dans le dossier public, celui-ci peut donc être supprimé.
L’inclusion du modèle dans les contrôleurs ainsi que la création de la variable $page_base deviennent inutiles, puisque ces éléments sont désormais centralisés ou supprimés.
En contrepartie, il est nécessaire de modifier toutes les références aux liens du site dans les controlleurs :
require '../../app/views/utilisateur/index.php'; => require '../app/views/utilisateur/index.php';
header('location:../utilisateur/index.php'); => header('location:/utilisateur/index');
$relDir = '../'; => On supprime toutes les références au chemin relatif.
Il est nécessaire de créer un dossier error et d’y ajouter un fichier index.php, tant dans le répertoire controllers que dans views.
Méthode : asset()
Le problème des chemins relatifs
Jusqu’à présent, nous utilisions la variable $page_base dans la balise <base> pour indiquer au navigateur le dossier de référence de l’application.
Cette solution fonctionne, mais elle devient rapidement difficile à maintenir lorsque les vues sont organisées dans plusieurs dossiers.
Par exemple, une image peut être référencée ainsi :
<img src="images/logo.png" alt="Logo">
Mais si la vue se trouve dans un sous-dossier, le navigateur peut chercher l'image au mauvais endroit.
Il faudrait alors adapter les chemins en fonction de l'emplacement de chaque vue :
images/logo.png ../images/logo.png ../../images/logo.png
Cela rend les vues plus difficiles à écrire et à maintenir.
La solution : asset()
Pour éviter ce problème, nous créons un helper asset().
Il permet de construire l'URL d'une ressource statique à partir de son chemin :
<link rel="stylesheet" href="{{ asset('css/style.css') }}">
<img src="{{ asset('images/logo.png') }}" alt="Logo">
On indique uniquement le chemin de la ressource à partir du dossier public.
Le helper se charge ensuite de construire l'URL complète nécessaire pour accéder à cette ressource.
Pourquoi cela fonctionne ?
Dans notre application, toutes les requêtes passent par le script d'entrée :
public/index.php
Le helper asset() tient compte de l'emplacement de ce script pour déterminer le chemin de base de l'application.
À retenir
asset() permet donc de séparer l'emplacement d'une vue du chemin d'une ressource statique.
asset('css/style.css')→ permet d'accéder à une feuille de style.asset('js/app.js')→ permet d'accéder à un fichier JavaScript.asset('images/logo.png')→ permet d'accéder à une image.asset('utilisateur/show')→ permet d'accéder à une page.
Le principe est simple :
On indique le chemin de la ressource dans public, et asset() construit l'URL adaptée à l'application.
Cela rend les vues plus simples, plus homogènes et surtout plus faciles à déplacer ou à réorganiser.
app/helpers.php
function asset(string $path): string
{$basePath = str_replace('\\', '/', dirname($_SERVER['SCRIPT_NAME']));
return rtrim($basePath, '/') . '/' . ltrim($path, '/');
}
La fonction ajoute le dossier du SCRIPT_NAME devant le $path.
Méthode : app/controllers/error/index.php
// ==============================// VARIABLE POUR LA VUE// ==============================// Titre dynamique de la page$page_title = 'Error 404';
require '../app/views/error/index.php';
Méthode : app/views/error/index.php
<html lang='fr'>
require '../app/views/head.php';
<body>
require '../app/views/header.php';
<main>
<h1>Error 404</h1>
</main>
require '../app/views/footer.php';
</body>
</html>
Méthode :
Nous pouvons maintenant vérifier le bon fonctionnement du site et observer que les URLs sont réécrites, sans inclure l’extension des fichiers.
En saisissant une URL incorrecte, on peut contrôler l’apparition d’une erreur 404 via l’outil d’inspection du navigateur.