Concept et Architecture

Introduction

BowPHP est un framework PHP léger, conçu pour offrir une structure claire et modulaire. Lorsqu'une requête arrive, elle suit un chemin bien défini appelé cycle de vie d'une requête. Ce cycle est organisé pour séparer les responsabilités, rendre le code facile à maintenir et améliorer les performances.

Le cycle de vie d'une requête expliqué

Chaque requête passe par plusieurs étapes avant de générer une réponse pour l'utilisateur.

Voici les étapes principales :

1. Requête HTTP : L'utilisateur envoie une requête via son navigateur ou une API.
2. Request : Le framework capture cette requête et extrait les données nécessaires (URL, paramètres, corps, etc.).
3. Kernel : Le Kernel est le cœur du framework. Il :

• Charge les fichiers de configuration situés dans le dossier config (comme config/database.php).
• Initialise les modules nécessaires à l'application.

4. Application : Elle démarre le Kernel et prépare l'environnement pour traiter la requête.
5. Routeur :

• Le routeur détecte la route correspondant à la requête (par exemple, /users/42 ou /api/login).
• Il associe cette route à un contrôleur et une méthode spécifique, définis directement dans le code des routes.
• Si des middlewares sont définis pour cette route, ils sont exécutés avant d'appeler le contrôleur.

6. Middleware : Les middlewares effectuent des traitements spécifiques, comme vérifier l'authentification ou valider les données.
7. Contrôleur : Une fois la route validée, le contrôleur exécute la logique métier (par exemple, récupérer des données ou effectuer une action).
8. Modèle : Si des données sont nécessaires, le modèle interagit avec la base de données pour les récupérer ou les mettre à jour.
9. Vue : Le contrôleur renvoie les données récupérées au composant Vue, qui génère le contenu final (HTML, JSON, etc.).
10. Réponse HTTP : La réponse est envoyée à l'utilisateur.

Le rôle du routeur en détail

Le routeur est un composant clé de BowPHP. Il agit comme une "boussole" qui oriente chaque requête vers le bon contrôleur et la bonne méthode.

Détection de la route

Le routeur examine l'URL de la requête et détermine quelle route correspond. Les routes sont définies dans des fichiers dédiés.

Exemple de définition de route :

routes/app.php

$app->get('/users/:id', 'UserController::show');
$app->post('/api/login', 'AuthController::login');

astuce

Ici :

• La requête GET /users/42 est associée à la méthode show du UserController.
• La requête POST /api/login est associée à la méthode login du AuthController.

Bow supporte aussi le routage par attributs PHP 8, qui permet de déclarer les routes directement sur la classe contrôleur sans fichier de routes centralisé :

use Bow\Router\Attributes\{Controller, Get};

#[Controller(prefix: '/api/users', middleware: ['auth'])]
final class UserController
{
    #[Get('/:id', name: 'show', where: ['id' => '\d+'])]
    public function show(int $id) { /* ... */ }
}

// Dans routes/app.php
$app->register(UserController::class);

Voir Routage > Routage par attributs pour le détail des attributs disponibles.

Association au contrôleur

Une fois la route détectée, le routeur :

• Valide les paramètres de l'URL (comme :id).
• Exécute les middlewares définis pour cette route (s'il y en a).
• Appelle le contrôleur et la méthode associés à la route.

Une architecture modulaire

astuce

BowPHP repose sur une architecture modulaire. Chaque module est indépendant, possède sa propre configuration et remplit un rôle spécifique. Cela rend l'application facile à gérer et à étendre. Le routeur en est un exemple ; le module Database, qui gère les connexions à la base de données, en est un autre.

Le contrat : Bow\Configuration\Configuration

Tous les modules suivent le même contrat : chacun expose une classe qui étend Bow\Configuration\Configuration et implémente deux méthodes :

• create(Loader $config) — déclare les liaisons dans le container
• run() — démarre le module (utile pour les ressources eager)

Le Kernel (votre app/Kernel.php, qui étend Bow\Configuration\Loader) liste ces providers dans sa méthode configurations(). Au démarrage, le Kernel les instancie, charge les fichiers config/*.php, puis appelle create() puis run() sur chacun.

Exemple : Le module Database

Prenons le cas du module Database, qui gère les connexions à la base de données :

Fichier de configuration : config/database.php

Ce fichier contient les paramètres nécessaires pour se connecter à la base de données. Voici un exemple simple :

config/database.php

return [
  'default' => 'mysql',
  'connections' => [
    'mysql' => [
      'driver' => 'mysql',
      'host' => '127.0.0.1',
      'port' => 3306,
      'database' => 'bowphp_app',
      'username' => 'root',
      'password' => '',
      'charset' => 'utf8mb4',
      'collation' => 'utf8mb4_unicode_ci',
    ],
  ],
];

Classe Bow\Database\DatabaseConfiguration

Cette classe (qui étend Bow\Configuration\Configuration) lit config/database.php, configure les connexions PDO et expose db / database dans le container.

Enregistrement dans le Kernel

app/Kernel.php

namespace App;

use Bow\Configuration\Loader;
use Bow\Database\DatabaseConfiguration;

class Kernel extends Loader
{
    public function configurations(): array
    {
        return [
            DatabaseConfiguration::class,
            // ... d'autres providers (Cache, Mail, Queue, etc.)
        ];
    }
}

Au démarrage, le Kernel charge config/database.php, instancie DatabaseConfiguration puis appelle ses méthodes create() et run(). La connexion est alors prête à être utilisée par les contrôleurs, les modèles Barry et les autres composants.

Visualisation avec un diagramme

Voici une représentation visuelle pour mieux comprendre le cycle de vie d'une requête et l'intégration modulaire (exemple avec Database) :

┌─────────────────────────────────────────────────────────────────────────────┐
│                              Framework Bow                                  │
│                                                                             │
│  ┌─────────────┐    ┌──────────┐    ┌────────────┐    ┌─────────────────┐   │
│  │   Request   │───▶│  Kernel  │───▶│  Routeur   │───▶│   Middleware    │   │
│  └─────────────┘    └──────────┘    └────────────┘    └─────────────────┘   │
│        ▲                 │                                     │            │
│        │                 │ Charge les                          │            │
│        │                 │ modules                             ▼            │
│        │                 │                            ┌─────────────────┐   │
│        │                 ▼                            │   Contrôleur    │   │
│        │          ┌────────────┐                      └─────────────────┘   │
│        │          │   Config   │                               │            │
│        │          └────────────┘                               │            │
│        │                                                       ▼            │
│  ┌─────────────┐                                      ┌─────────────────┐   │
│  │   Réponse   │◀───────────────────────────────────▶│     Modèle       │   │
│  │    HTTP     │                                      └─────────────────┘   │
│  └─────────────┘                                               │            │
│        ▲                                                       │            │
│        │                                                       ▼            │
│        │         ┌─────────────┐                      ┌─────────────────┐   │
│        └─────────│     Vue     │◀─────────────────────│ Base de données │   │
│                  └─────────────┘                      └─────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Flux : Request → Kernel → Routeur → Middleware → Contrôleur → Modèle → Vue → Réponse

Résumé des points importants

Résumé

• Cycle de vie structuré : Une requête suit un chemin précis (Request → Kernel → Routeur → Middleware → Contrôleur → Modèle → Vue → Réponse).
• Rôle du routeur : Le routeur détecte la route correspondant à la requête et appelle le contrôleur et la méthode associés.
• Kernel : Orchestre le chargement des configurations depuis le dossier config et initialise les modules.
• Modularité : Chaque composant (routeur, base de données, etc.) est indépendant, ce qui simplifie la gestion et améliore la maintenabilité.

Merci aux contributeurs

Merci d'avoir envisagé de contribuer à BowPHP ! Le guide de contribution se trouve dans la documentation.

• Franck DAKIA
• Merci aux collaborateurs

Il manque quelque chose ?

Si vous rencontrez des problèmes avec la documentation ou si vous avez des suggestions pour améliorer la documentation ou le projet en général, veuillez déposer une issue pour nous, ou envoyer un tweet mentionnant le compte Twitter @bowframework ou sur directement sur le github.