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éfinitionpublic/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 »

1
<?php
2
3
/**
4
 * Routeur minimaliste
5
 * -------------------
6
 * Rôle :
7
 *  - Nettoyer l’URL
8
 *  - Extraire contrôleur + action
9
 *  - Inclure dynamiquement le bon fichier contrôleur
10
 */
11
12
// Chargement du modèle (fonctions d’accès à la base de données)
13
require '../app/models/model.php';
14
// Chargement des helpers (fonctions utilitaires) 
15
require '../app/helpers.php';
16
17
/* -------------------------------------------------------------
18
   Construction du chemin demandé à partir de 
19
   l’URL du client et du script d’entrée public/index.php
20
------------------------------------------------------------- */
21
22
// Récupère le chemin demandé, sans les paramètres GET
23
$requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
24
25
// Récupère le dossier de base de l'application
26
$basePath = str_replace('\\', '/', dirname($_SERVER['SCRIPT_NAME']));
27
28
// Supprime le chemin de base s'il est présent
29
if (str_starts_with($requestUri, $basePath)) {
30
   $requestUri = substr($requestUri, strlen($basePath));
31
}
32
33
// Normalise le chemin en ajoutant un seul / au début
34
$path = '/' . ltrim($requestUri, '/');
35
36
/* -------------------------------------------------------------
37
   Découpage du chemin en segments pour 
38
   déterminer le contrôleur et l’action
39
------------------------------------------------------------- */
40
41
$params = $path === '/' ? [] : explode('/', trim($path, '/'));
42
43
// controleur et action par défaut si non précisés dans l'URL
44
$controller = $params[0] ?? 'home';
45
$action = $params[1] ?? 'index';
46
47
/* -------------------------------------------------------------
48
   Gestion des erreurs : contrôleur ou action manquants
49
------------------------------------------------------------- */
50
51
$controllerFile = "../app/controllers/$controller/$action.php";
52
53
if (!file_exists($controllerFile)) {
54
   http_response_code(404);
55
   $controllerFile = "../app/controllers/error/index.php";
56
}
57
58
/* -------------------------------------------------------------
59
   Inclusion dynamique du fichier contrôleur
60
------------------------------------------------------------- */
61
62
require $controllerFile;
63

Construction du chemin :

1
$requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
2
$basePath = str_replace('\\', '/', dirname($_SERVER['SCRIPT_NAME']));
3
if (str_starts_with($requestUri, $basePath)) {
4
   $requestUri = substr($requestUri, strlen($basePath));
5
}
6
$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éthodeasset()

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

1
function asset(string $path): string
2
{
3
    $basePath = str_replace('\\', '/', dirname($_SERVER['SCRIPT_NAME']));
4
5
    return rtrim($basePath, '/') . '/' . ltrim($path, '/');
6
}

La fonction ajoute le dossier du SCRIPT_NAME devant le $path.

Méthodeapp/controllers/error/index.php

1
<?php
2
3
// ==============================
4
// VARIABLE POUR LA VUE
5
// ==============================
6
7
// Titre dynamique de la page
8
$page_title = 'Error 404';
9
10
require '../app/views/error/index.php';
11

Méthodeapp/views/error/index.php

1
<!DOCTYPE html>
2
<html lang='fr'>
3
4
<?php require '../app/views/head.php'; ?>
5
6
<body>
7
    <?php require '../app/views/header.php'; ?>
8
9
    <main>
10
        <h1>Error 404</h1>
11
    </main>
12
13
    <?php require '../app/views/footer.php'; ?>
14
</body>
15
16
</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.