La structure MVC de ThinkPHP 6 repose sur les contrôleurs pour gérer la logique de traitement des requêtes. Ce guide détaille la création, la configuration et l'utilisation des contrôleurs.

Définition d'un Contrôleur

Un contrôleur est une classe PHP située dans le répertoire app/controller. Par exemple, pour créer un contrôleur User :

namespace app\controller;

class User
{
   public function login()
   {
       return 'Authentification';
   }
}
   

Pour qu'une requête atteigne ce contrôleur, une route doit être définie dans route/app.php :

use think\facade\Route;

Route::get('user/login', 'user/login');
   

En accédant à http://votre-domaine/user/login, vous verrez le retour 'Authentification'.

Utilisation du Contrôleur de Base

ThinkPHP fournit une classe de contrôleur de base, app\BaseController, qui offre des fonctionnalités utilitaires. Les contrôleurs personnalisés peuvent hériter de cette classe.

namespace app\controller;

// Utilisation de l'héritage de BaseController
class User extends \app\BaseController
{
   public function login()
   {
       // Accès aux objets Request et App via l'héritage
       $actionName = $this->request->action();
       $basePath = $this->app->getBasePath();
       return 'Action: ' . $actionName . ', Chemin de base: ' . $basePath;
   }
}
   

Gestion des Actions Inconnues (Contrôleur Vide)

Si une méthode n'existe pas dans un contrôleur, la méthode spéciale __call peut être implémentée pour intercepter cet appel.

namespace app\controller;

class User extends \app\BaseController
{
   public function login()
   {
       return 'Connexion réussie';
   }

   // Méthode appelée pour les actions non définies
   public function __call($methodName, $arguments)
   {
       // $methodName contiendra le nom de l'action demandée
       // $arguments contiendra les paramètres passés à l'action
       return "Erreur : L'action '{$methodName}' n'est pas reconnue avec les arguments suivants : " . json_encode($arguments);
   }
}
   

Une requête comme http://votre-domaine/user/register?email=test@example.com, si 'register' n'est pas défini, déclenchera la méthode __call.

Génération Automatique de Contrôleurs

La console de ThinkPHP permet de générer des squelettes de contrôleurs. Pour créer un contrôleur Student :

php think make:controller Student
   

Cela crée le fichier app/controller/Student.php avec des méthodes CRUD prédéfinies.

<?php declare (strict_types = 1);

namespace app\controller;

use think\Request;
use think\Response;

class Student
{
   /**
    * Afficher la liste des étudiants.
    * @return Response
    */
   public function index(): Response
   {
       return Response::create('Liste des étudiants');
   }

   /**
    * Afficher le formulaire de création d'un étudiant.
    * @return Response
    */
   public function create(): Response
   {
       return Response::create('Formulaire de création');
   }

   /**
    * Enregistrer un nouvel étudiant.
    * @param Request $request
    * @return Response
    */
   public function save(Request $request): Response
   {
       return Response::create('Enregistrement étudiant');
   }

   /**
    * Afficher un étudiant spécifique.
    * @param int $id
    * @return Response
    */
   public function read(int $id): Response
   {
       return Response::create("Détails de l'étudiant ID: {$id}");
   }

   /**
    * Afficher le formulaire d'édition d'un étudiant.
    * @param int $id
    * @return Response
    */
   public function edit(int $id): Response
   {
       return Response::create("Formulaire d'édition étudiant ID: {$id}");
   }

   /**
    * Mettre à jour un étudiant existant.
    * @param Request $request
    * @param int $id
    * @return Response
    */
   public function update(Request $request, int $id): Response
   {
       return Response::create("Mise à jour étudiant ID: {$id}");
   }

   /**
    * Supprimer un étudiant.
    * @param int $id
    * @return Response
    */
   public function delete(int $id): Response
   {
       return Response::create("Suppression étudiant ID: {$id}");
   }
}
   </code?>

Pour utiliser ces méthodes, vous pouvez définir une route de type ressource :

use think\facade\Route;

Route::resource('students', 'Student');
   

Cela mappe automatiqeument les URLs HTTP aux méthodes du contrôleur Student.

Application de Middlewares aux Contrôleurs

Les middlewares permettent d'exécuter du code avant ou après le traitement d'une requête par le contrôleur. Pour créer un middleware d'authentification :

php think make:middleware Auth
   

Le fichier app/middleware/Auth.php contiendra la logique du middleware :

<?php declare (strict_types = 1);

namespace app\middleware;

use think\Request;
use think\Response;

class Auth
{
   /**
    * Gérer la requête entrante.
    * @param Request $request
    * @param \Closure $next
    * @return Response
    */
   public function handle(Request $request, \Closure $next): Response
   {
       echo 'Vérification d\'authentification... ';
       // Exemple : Redirection si le paramètre 'name' est 'think'
       if ($request-?>param('name') === 'think') {
           return redirect()->to('user/forbidden'); // Assurez-vous que cette route existe
       }

       // Passer la requête au prochain middleware ou au contrôleur
       $response = $next($request);
       // Vous pouvez aussi modifier la réponse ici
       return $response;
   }
}
   

Pour appliquer ce middleware à un contrôleur spécifique, déclarez-le dans la propriété $middleware du contrôleur :

namespace app\controller;

use app\BaseController;
use app\middleware\Auth; // Importation du middleware

class User extends BaseController
{
   // Déclaration des middlewares pour ce contrôleur
   protected array $middleware = [
       Auth::class, // Applique le middleware Auth à toutes les actions de ce contrôleur
   ];

   public function login(): string
   {
       return 'Connexion';
   }

   public function forbidden(): string
   {
       return 'Accès interdit';
   }
}
   

Une requête comme http://votre-domaine/user/login affichera d'abord "Vérification da'uthentification... " puis "Connexion". Si vous y ajoutez le paramètre ?name=think, vous serez redirigé vers /user/forbidden.