Créer son application Web en PHP (et Composer) : Partie 1

Disons-le franchement, coder un site web entier n'a jamais été simple, et tout particulièrement lorsqu'il s'agit du choix de l'architecture du site. Si certains tentent vainement de parvenir à un modèle MVC (Modèle - Vue - Contrôleur) avec du PHP, d'autres vont intégrer un framework, le plus souvent Laravel ou Symfony, qui s'avèrera être trop gros pour le projet en question.

Si vous vous reconnaissez dans ces situations, alors vous êtes au bon endroit ! Dans cette série, vous verrez comment créer une application PHP avec une structure complexe, sans que votre codebase devienne incompréhensible et horrible à maintenir au fur et à mesure que le projet grandisse. Bien entendu, je vous invite à aller vous familiariser avec SOLID, qui constitue le corollaire de ce projet, si vous n'en avez jamais entendu parler. Je précise également que je ne ferai pas un tutoriel de A-Z sur la création d'une véritable application Web. Vous aurez ici simplement les fondements de la création. Je vous laisserai quelques pistes de réflexion à la fin, pour que vous puissiez compléter votre application Web selon vos envies. Cette première partie concernera les fondements de votre application web, à savoir la configuration de base (I.), ainsi que les fonctionnalités primitives du site (II.).

I/ La gestion des dépendances : Composer

Pour commencer, je vous invite à installer Composer, qui est un gestionnaire de dépendances pour PHP. Cela va vous permettre d'installer plusieurs librairies (des dépendances), qui seront utiles au développement de votre application PHP. Par exemple, vous avez des librairies pour le routage, la gestion des erreurs, ou même des moteurs de template. Pas de panique, nous reviendrons sur ces notions plus tard dans l'article.

Une fois Composer installé, ouvrez un terminal de commandes (tapez "cmd" dans la barre de recherche Windows le cas échéant), et entrez "composer init". Un programme va alors se lancer en ligne de commandes pour configurer votre projet. Rentrez alors les différentes informations demandées. Vous pouvez également procéder à la configuration en créant le fichier à la main. Ouvrez un éditeur de code, et tapez ceci dans un fichier, que vous nommerez composer.json et que vous placerez à la racine de votre site :

// Composer.json
{
    "name": "project/project",
    "autoload": {
        "psr-4": {
            "Project\\": "src/"
        }
    },
    "authors": [
        {
            "name": "John DOE",
            "email": "john.doe@example.com"
        }
    ],
    "require": {}
}

Évidemment, pensez à personnaliser vos informations si vous le souhaitez.

Remarque : le champ autoload est très important ; c'est ce qui vous permettra de charger toutes vos classes au chargement de la page. Si vous êtes en ligne de commandes, veillez à bien l'ajouter lorsque Composer vous demandera : "Add PSR-4 autoload mapping?".

Une fois la configuration terminée, allez à la racine de votre site dans le gestionnaire de fichier, et créez 3 dossiers : un public/, un views/ et un src/. À l'intérieur du dossier src/, créez les dossiers suivants : Controllers/, Domains/, et Templates/. Ensuite, placez l'index de votre site (nommé index.php) dans le dossier public/. Et enfin, finalisez la configuration initiale en créant un fichier .htaccess, avec le contenu suivant :

# .htaccess
DirectoryIndex ./public/index.php

Vous venez de terminer la configuration intiale de votre site ! Maintenant, voyons comment ajouter les fonctionnalités essentielles du site, telles que le routage et la gestion des requêtes HTTP.

II/ Ajouter les fonctionnalités primaires du site

Avant d'aller plus loin, vous allez devoir dans un premier temps ajouter ces lignes de code à votre fichier index.php :

<?php
// public/index.php
require __DIR__ . '/../src/Bootstrap.php';

Cette ligne fait simplement appel au fichier Bootstrap.php, que vous allez ensuite créer au sein de votre dossier src/.

<?php
// src/Bootstrap.php
namespace Project;
require __DIR__ . './../vendor/autoload.php';

Vous êtes maintenant prêts pour la suite !

A. La gestion HTTP (Requêtes et Réponses)

Cette section vous permettra de mieux gérer vos superglobales ($_POST, $_GET) afin de traiter au mieux les requêtes et la réponse que le serveur renvoie. Pour éviter de réinventer la roue, vous allez avoir besoin d'une librairie qui vous permet de router vos adresses ; c'est là que Composer entre en jeu ! Ouvrez votre terminal en vous positionnant à la racine de votre projet, et entrez la ligne suivante :

composer require sabre/http

Exécutez cette commande, et Composer installera la librairie Sabre dans votre projet, et en fera une dépendance. Dans cet exemple, j'utilise Sabre, mais vous pouvez très bien en utiliser une autre si vous voulez. Si vous ouvrez votre fichier composer.json, vous remarquez que la ligne suivante a été ajoutée au sein de la partie "require" :

"require": {
        "sabre/http": "^7.0"
}

Maintenant, retournez dans votre fichier Bootstrap.php, et intégrez les classes Request et Response de Sabre. Votre fichier Bootstrap.php, devrait se trouver comme ceci :

Les différentes méthodes et fonctionnalités sont décrites sur le Github de Sabre, mais pour les besoins du projet, je vais vous lister les méthodes essentielles.

S'agissant de l'objet Request, nous allons nous concentrer sur la méthode getQueryParameters(). En l'appelant, vous aurez les divers paramètres POST et GET de la requête, par exemple :

<?php
// src/Bootstrap.php
// Le haut de fichier est coupé pour ne pas surcharger l'exemple.
// URL : http://example.com/?action=param
use Sabre\HTTP;
$request = HTTP\Sapi::getRequest();
var_dump($request->getQueryParameters());
// Affiche "'action' => string 'param' (length=5)"

Cela équivaut alors à faire var_dump($_GET) en PHP "normal".

Ensuite, concernant l'objet Response, vous allez pouvoir manipuler la réponse texte (logique...), le code et les en-têtes HTTP. Comment ? Un exemple sera certainement plus communicatif :

<?php
// src/Bootstrap.php
// Le haut de fichier est coupé pour ne pas surcharger l'exemple.
// URL : http://example.com/?action=param

use Sabre\HTTP;
$response= HTTP\Response();
$response->setBody('test');
$response->setHeader('Content-Type', 'text/html');

// Souvent renvoyé par défaut, vous n'aurez pas besoin de le préciser en pratique.
// Cela va servir lorsque vous avez des en-têtes spécifiques à envoyer. C'est pareil pour le code HTTP.

$response->setStatus(200);var_dump($response->getBody(), $response->getStatus(), $response->getHeaders());
/*
file:string 'test' (length=4)
file:int 200
file:array (size=1)
  'Content-Type' => 
    array (size=1)
      0 => string 'text/html' (length=9)
*/

Et voilà ! Vous êtes maintenant en mesure de gérer les requêtes et réponses HTTP. Passons maintenant au Routage !

B. Le routage

Pour commencer, voyons comment gérer les chemins des différentes pages du site. Pour ce projet, j'utiliserai FastRoute. Encore une fois, vous pouvez utiliser une autre librairie. Pour intégrer FastRoute à votre projet, retournez dans votre terminal à la racine de votre site, et entrez la commande suivante :

composer require nikic/fast-route

Par ailleurs, la partie "require" de votre fichier composer.json devrait ressembler à ça maintenant.

"require": {
        "sabre/http": "^7.0",
        "nikic/fast-route": "^1.3"
}

Maintenant, positionnez-vous dans le dossier src/, et créez-y 1 nouveau fichier : Routes.php.

Retournez ensuite dans votre fichier Bootstrap.php et modifiez-le comme suit :

<?php
// src/Bootstrap.php

namespace Project;
require __DIR__ . './../vendor/autoload.php';

use Sabre\HTTP;
$request = HTTP\Sapi::getRequest();
$response = new HTTP\Response();

$routeDefinitionCallback = function(\FastRoute\RouteCollector $r) {
    $routes = include('Routes.php');
    foreach ($routes as $route) {
        $r->addRoute($route[0], $route[1], $route[2]);
    }
};

$dispatcher = \FastRoute\simpleDispatcher($routeDefinitionCallback);
$routeInfo = $dispatcher->dispatch($request->getMethod(), $request->getPath());
switch ($routeInfo[0]) {
    case \FastRoute\Dispatcher::NOT_FOUND:
        $response->setBody('404 - Not found');
        $response->setStatus(404);
        break;
    case \FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
        $response->setBody('405 - Method not allowed');
        $response->setStatus(405);
        break;
    case \FastRoute\Dispatcher::FOUND:
        $className = $routeInfo[1][0];
        $method = $routeInfo[1][1];
        $vars = $routeInfo[2];
        
        $class = new $className;
        $response->setBody($class->$method($vars));
        break;
}
echo $response->getBody();

Veillez à bien toujours mettre le namespace en premier, sans quoi PHP vous renverra une jolie erreur ^^.

Vous avez maintenant un gestionnaire de routes prêt à l'emploi ! Toutefois cela va s'avérer complexe de rajouter du HTML, et cela ne peut tenir dans la valeur de retour de la fonction show(). C'est pourquoi nous verrons comment faire à l'occasion du prochain article à ce sujet, qui devrait arriver dans une semaine, tout au plus. Le suspens est à son comble... Restez à l'affût sur Kévin1026.com !