Le modèle de conception Page Controller est une approche architecturale courante utilisée dans les systèmes Web. Il organise le flux de contrôle en dédiant un contrôleur spécifique pour gérer la logique d'une page ou d'une requête individuelle. Cette approche permet d'isoler les responsabilités, facilitant ainsi la maintenance et l'évolution de la base de code.

Qu'est-ce que le contrôleur de page ?

Dans le modèle Page Controller, chaque page (ou un groupe de pages ayant un comportement similaire) possède son propre contrôleur, responsable de :

1. Traitement de la demande : Traitement des données envoyées par le client.
2. Exécuter la logique spécifique à la page : valider une entrée, interagir avec des modèles ou effectuer des calculs.
3. Rendu d'une réponse : transmission des données traitées à une vue (modèle) et renvoi de la réponse finale au client.

Avantages du modèle

1. Flux simple : chaque page est mappée à son propre contrôleur dédié.
2. Séparation des préoccupations : chaque contrôleur ne gère que sa propre logique.
3. Maintenabilité : les modifications apportées à une page affectent uniquement son contrôleur associé.
4. Évolutivité : l'ajout de nouvelles pages est simple et ne perturbe pas les fonctionnalités existantes.

Structure de base

Une implémentation typique implique les composants suivants :

• Contrôleurs : fichiers PHP contenant la logique de pages spécifiques.
• Routes : un mécanisme de routage pour mapper les URL aux contrôleurs.
• Vues : modèles utilisés pour afficher l'interface utilisateur.

Couler

1. Le client envoie une requête à une URL spécifique.
2. Le système de routage identifie le contrôleur approprié pour la demande.
3. Le contrôleur exécute la logique requise et délègue le rendu de la réponse à une vue.
4. La vue génère la sortie finale et la renvoie au client.

Exemple de mise en œuvre

Structure des fichiers

/htdocs
    /src
        /Controllers
            HomeController.php
            AboutController.php
        /Services
            ViewRenderer.php
        /Views
            home.html.php
            about.html.php
    /public
        index.php
    /routes.php
    composer.json

Chargeur automatique

{
    "autoload": {
        "psr-4": {
            "App\\": "htdocs/"
        }
    }
}

composer dump-autoload

Modèle

Modèle pour la page d'accueil et about.html.php.

    


    
= htmlspecialchars($title) ?>
    
= htmlspecialchars($content) ?>

ViewRenderer

namespace App\Services;

class ViewRenderer {

    public function render(string $view, array $data = []): void {
        extract($data); // Turns array keys into variables
        include __DIR__ . "/../../Views/{$view}.html.php";
    }
}

Contrôleur domestique

Gère la logique de la page d'accueil.

namespace App\Controllers;

use App\Services\ViewRenderer;

class HomeController {

    public function __construct(private ViewRenderer $viewRenderer)
    {
    }

    public function handleRequest(): void {
        $data = [
            'title' => 'Welcome to the Site',
            'content' => 'Homepage content.',
        ];

        $this->viewRenderer->render('home', $data);
    }
}

À propos du contrôleur

Gère la logique de la page « À propos de nous ».

namespace App\Controllers;

use App\Services\ViewRenderer;

class AboutController
{

    public function __construct(private ViewRenderer $viewRenderer)
    {
    }

    public function handleRequest(): void {
        $data = [
            'title' => 'About Us',
            'content' => 'Information about the company.',
        ];

        $this->viewRenderer->render('about', $data);
    }
}

routes.php

Définit les mappages de routes vers les contrôleurs.

use App\Controllers\HomeController;
use App\Controllers\AboutController;

// Define the routes in an associative array
return [
    '/' => HomeController::class,
    '/about' => AboutController::class,
];

index.php

Le point d’entrée de l’application.

require_once __DIR__ . '/../vendor/autoload.php';

use App\Services\ViewRenderer;

// Include the routes
$routes = require_once __DIR__ . '/../routes.php';

// Instantiate the view rendering service
$viewRenderer = new ViewRenderer();

// Get the current route from the request URI
$requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

// Check if the route exists and resolve the controller
if (isset($routes[$requestUri])) {
    $controllerClass = $routes[$requestUri];
    $controller = new $controllerClass($viewRenderer);
    $controller->handleRequest();
} else {
    http_response_code(404);
    echo "Page not found.";
}

Avantages et inconvénients

Avantages

• Organisation : les contrôleurs sont modulaires, chacun gérant une page spécifique.
• Réutilisabilité : les vues peuvent être réutilisées sur différents contrôleurs.
• Débogage : les erreurs sont plus faciles à tracer puisque chaque page possède son propre contrôleur dédié.

Inconvénients

• Nombre accru de contrôleurs : Les grands projets peuvent conduire à une prolifération de contrôleurs, nécessitant une meilleure organisation.
• Duplication de code : la logique commune entre les contrôleurs peut être répétée. Cela peut être atténué en utilisant une classe de contrôleur de base.

Quand utiliser le modèle de contrôleur de page ?

• Systèmes simples : idéal pour les applications Web de petite et moyenne taille où chaque page a une logique spécifique.
• Projets modulaires : lorsque vous souhaitez isoler la logique pour une maintenance plus facile.
• Sans frameworks : Idéal pour les projets PHP sans frameworks robustes (comme Laravel ou Symfony).

Pour les projets plus complexes, où il existe une réutilisation logique importante ou plusieurs points d'entrée, des modèles tels que Front Controller ou une architecture MVC complète peuvent être plus adaptés.