Guide d'utilisation des événements et des hooks ThinkPHP6 : implémentation du déclenchement et de la surveillance

Guide d'utilisation des événements et des hooks ThinkPHP6 : implémentation du déclenchement et de la surveillance

Présentation
Pendant le processus de développement, nous devons souvent gérer certains événements, tels que l'envoi de rappels par e-mail après l'inscription réussie de l'utilisateur ou la mise à jour du cache après le produit. est retiré des étagères, etc. attendez. Afin de mieux gérer ces événements, ThinkPHP6 fournit des mécanismes d'événement et de hook, rendant le déclenchement et la surveillance d'événements plus flexibles et plus pratiques.

1. Événements et auditeurs
Les événements font référence à des événements qui se produisent pendant l'exécution du programme, tels qu'une inscription réussie d'un utilisateur, une passation de commande réussie, etc. Les auditeurs répondent aux événements, c'est-à-dire effectuent des opérations spécifiques après qu'un événement se soit produit. Les événements et les auditeurs dans ThinkPHP6 sont gérés à l'aide du mode observateur, qui dissocie le déclenchement des événements et les opérations correspondantes.

1. Enregistrer un auditeur d'événement
   Dans ThinkPHP6, vous pouvez enregistrer des auditeurs d'événement en définissant une classe d'écoute. La classe d'écoute se trouve dans le répertoire app/listener Lors de la définition, vous devez hériter de la classe thinklistenerListener et implémenter sa méthode handle(). Par exemple, nous définissons une classe UserRegisteredListener pour écouter les événements de réussite de l'enregistrement des utilisateurs :

namespace applistener;

use thinklistenerListener;

class UserRegisteredListener extends Listener
{
    // 定义事件监听方法
    public function handle($event)
    {
        // 处理事件的操作
        // 比如发送邮件通知
        // ...
    }
}

Dans la méthode handle(), vous pouvez écrire les opérations qui doivent être effectuées après que l'événement correspondant se soit produit.

2. La relation correspondante entre les événements enregistrés et les auditeurs
   Dans ThinkPHP6, vous pouvez spécifier la relation correspondante entre les événements et les auditeurs dans le fichier de définition d'événement. Le fichier de définition d'événement se trouve dans le fichier app/event.php et la relation correspondante entre les événements et les écouteurs est définie via un tableau de configuration.

return [
    'bind' => [
        'UserRegistered' => [
            'applistenerUserRegisteredListener',
        ],
    ],
];

La configuration ci-dessus indique que lorsque l'événement UserRegistered se produit, la méthode handle() de UserRegisteredListener sera déclenchée.

2. Déclenchement d'événements
Lorsqu'un événement se produit, nous pouvons avertir le système en déclenchant l'événement, exécutant ainsi l'écouteur correspondant.

1. Comment déclencher des événements
   ThinkPHP6 propose deux façons de déclencher des événements :

(1) Déclenchement direct : Déclenchez des événements directement via la méthode dispatch() de la classe système.

use thinkacadeEvent;

// 触发 UserRegistered 事件，可以传递参数
Event::dispatch('UserRegistered', $userData);

(2) Déclenchement au sein du conteneur : Déclenchez l'événement via la méthode event() du conteneur S'il est appelé dans le constructeur, l'injection automatique de dépendances peut être utilisée.

use thinkacadeevent;

// 通过容器内触发 UserRegistered 事件，可以传递参数
app('event')->trigger('UserRegistered', $userData);

2. Créer un objet événement
   Dans la méthode de traitement de l'écouteur d'événement, nous pouvons recevoir les paramètres transmis lorsque l'événement est déclenché en définissant l'objet événement. La création d'un objet événement encapsule les paramètres pour une utilisation facile dans les écouteurs.

namespace applistener;

use thinklistenerListener;
use appeventUserRegisteredEvent; // 引入事件类

class UserRegisteredListener extends Listener
{
    public function handle($event)
    {
        // 将传递的参数封装为事件对象
        $userRegisteredEvent = new UserRegisteredEvent($event);
        
        // 使用事件对象的属性
        $username = $userRegisteredEvent->username;
        // ...
    }
}

3. Hooks
Les hooks sont des nœuds clés réservés dans le système En enregistrant des opérations sur les nœuds hook, les fonctions étendues correspondantes peuvent être obtenues. Les nœuds hook sont généralement situés dans les parties centrales du système, telles que le début de la demande, la fin de la demande, la résolution de l'itinéraire, etc. Le mécanisme de hook dans ThinkPHP6 est implémenté via un middleware, ce qui permet un contrôle plus flexible du processus.

1. Enregistrer le hook
   Dans ThinkPHP6, les hooks peuvent être enregistrés via un middleware. Le middleware hérite de la classe thinkMiddleware. Vous pouvez personnaliser le middleware et implémenter les opérations correspondantes dans le middleware.

namespace appmiddleware;

use thinkacadeEvent;

class MyMiddleware
{
    public function handle($request, Closure $next)
    {
        // 钩子操作
        // ...

        return $next($request);
    }
}

Dans la méthode handle() ci-dessus, vous pouvez écrire les opérations que le nœud hook correspondant doit effectuer. Une fois le middleware enregistré, il peut être configuré dans le middleware global ou le middleware de routage du système.

2. Enregistrer les hooks globaux
   Les hooks globaux font référence aux hooks qui seront déclenchés tout au long du cycle de vie de la demande système. Dans ThinkPHP6, les hooks globaux peuvent être enregistrés via l'élément de configuration middleware dans le fichier config/app.php.

'middleware' => [
    // 注册全局钩子
    ppmiddlewareMyMiddleware::class,
    // ...
]

3. Enregistrer le hook de routage
   Un hook de routage est un hook qui sera déclenché uniquement lorsqu'un itinéraire spécifique correspond. Dans ThinkPHP6, les hooks de routage peuvent être enregistrés en spécifiant un middleware dans la route.

Route::rule('index', 'index/index')->middleware(ppmiddlewareMyMiddleware::class);

4. Résumé
Grâce au mécanisme d'événement et de hook, nous pouvons gérer de manière plus flexible les événements qui se produisent dans le programme et effectuer les opérations correspondantes après que l'événement se soit produit. Dans ThinkPHP6, nous pouvons écouter les événements en enregistrant des auditeurs et effectuer des opérations spécifiques lorsque des événements se produisent. Dans le même temps, nous pouvons également enregistrer un middleware pour implémenter les hooks correspondants afin d'obtenir un contrôle de processus plus raffiné.

De cette façon, nous pouvons découpler et séparer différentes parties du système et améliorer l'évolutivité et la maintenabilité du système.

Ce qui précède est le contenu pertinent du guide d'utilisation des événements et des hooks ThinkPHP6. J'espère qu'il vous sera utile pour comprendre et appliquer le mécanisme d'événement et de hook dans ThinkPHP6.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!