• Définir l'auditeur
• Événement file d'attente des auditeurs
  • Accès manuel à la file d'attente
  • Gestion des tâches ayant échoué
• Distribution des événements
• Abonnés aux événements
• Rédaction des abonnés aux événements
  • Inscription à l'événement Auteur
• Introduction au système d'événements
• Les événements de Laravel fournissent une implémentation simple d'observateur qui peut s'abonner et surveiller divers événements qui se produisent dans l'application. Les classes d'événements sont généralement stockées dans le répertoire app/Events, et les écouteurs de ces classes d'événements sont stockés dans le répertoire app/Listeners. Si vous ne voyez pas ces répertoires dans votre application, ne vous inquiétez pas, ils seront créés automatiquement lorsque vous utiliserez les commandes de la console Artisan pour générer des événements et des écouteurs. Le système d'événements constitue un excellent moyen de découpler différents aspects de l'application, car un seul événement peut avoir plusieurs auditeurs indépendants les uns des autres. Par exemple, vous souhaiterez peut-être envoyer une notification Slack à vos utilisateurs chaque fois qu'une commande est expédiée. Plutôt que de coupler votre code de traitement de commande et votre code de notification Slack, vous pouvez simplement déclencher un événement OrderShipped qui peut être reçu par un auditeur et converti en notification Slack.
  • Enregistrement des événements et des auditeurs EventServiceProvider dans l'application Laravel Fournit un endroit pratique pour enregistrer tous les écouteurs d’événements. Parmi eux, l'attribut listen contient un tableau de tous les événements (clés) et les écouteurs (valeurs) correspondant aux événements. Bien entendu, vous pouvez ajouter plusieurs événements au tableau contenu dans l'attribut listen en fonction des besoins de votre application. Par exemple, ajoutons un événement OrderShipped :

  /**
   * 应用程序的事件监听器映射
   *
   * @var array
   */
   protected $listen = [ 
      'App\Events\OrderShipped' => [    
          'App\Listeners\SendShipmentNotification',  
          ],
      ];

Générer des événements et des auditeurs

Bien sûr, créer manuellement des fichiers d'événements et d'écouteurs est un problème. Ici, il vous suffit d'ajouter des écouteurs et des événements à EventServiceProvider, puis d'utiliser la commande event:generate. Cette commande générera tous les événements et écouteurs répertoriés dans EventServiceProvider. Bien entendu, les événements et auditeurs déjà existants resteront inchangés : EventServiceProvider 中，而后使用 event:generate 命令。这个命令会生成在 EventServiceProvider 中列出的所有事件和监听器。当然，已经存在的事件和监听器将保持不变：

php artisan event:generate

手动注册事件

通常，事件是在 EventServiceProvider 的 $listen 数组中注册；然而，你也可以在 EventServiceProvider 的 boot 方法中手动注册基于闭包的这些事件：

/**
 * 注册应用中的其它事件
 *
 * @return void
 */
 public function boot(){ 
    parent::boot();    
    Event::listen('event.name', function ($foo, $bar) {  
          //   
       });
  }

通配符事件监听器

你可以在注册监听器时使用 * 作为通配符参数，这样可以在同一个监听器上捕获多个事件。通配符监听器接收事件名作为其第一个参数，并将整个事件数据数组作为其第二个参数：

Event::listen('event.*', function ($eventName, array $data) { 
   //
});

定义事件

事件类是一个保存与事件相关信息的容器。例如，假设我们生成的 OrderShipped 事件接收一个 Eloquent ORM 对象：

<?php
    namespace App\Events;
    use App\Order;
    use Illuminate\Queue\SerializesModels;
    class OrderShipped{ 
       use SerializesModels;    
       public $order;    
     /**
     * 创建一个事件实例。
     *
     * @param  \App\Order  $order
     * @return void
     */   
    public function __construct(Order $order) 
       {    
           $this->order = $order;  
        }
    }

如你所见，这个事件类中没有包含其它逻辑。它只是一个购买的 Order 的实例的容器。如果使用 PHP 的 serialize 函数序列化事件对象，事件使用的 SerializesModels trait 将会优雅地序列化任何 Eloquent 模型。

定义监听器

接下来，让我们看一下例子中事件的监听器。事件监听器在 handle 方法中接收实例。 event:generate 命令会自动加载正确的事件类，并且在 handle 方法中加入事件的类型提示。在 handle 方法中，你可以执行任何必要的响应事件的操作：

<?php
    namespace App\Listeners;
    use App\Events\OrderShipped;
    class SendShipmentNotification{  
      /**
     * 创建事件监听器。
     *
     * @return void
     */  
   public function __construct()
      {      
        // 
      }  
     /**
     * 处理事件。
     *
     * @param  \App\Events\OrderShipped  $event
     * @return void
     */ 
    public function handle(OrderShipped $event) 
       {    
           // 使用 $event->order 来访问 order ...  
        }
     }

{tip} 你的事件监听器也可以在构造函数中加入任何依赖关系的类型提示。所有的事件监听器都是通过 Laravel 的 服务容器 来解析的，因此所有的依赖都将会被自动注入。

停止事件传播

有时，你可以通过在监听器的 handle 方法中返回 false

<?php
    namespace App\Listeners;
    use App\Events\OrderShipped;
    use Illuminate\Contracts\Queue\ShouldQueue;
    class SendShipmentNotification implements ShouldQueue{
        //
     }

Inscription manuelle des événements

Habituellement, les événements sont enregistrés dans le tableau $listen de EventServiceProvider, cependant, vous pouvez également les enregistrer dans le du EventServiceProvider ; boot< Enregistrez manuellement ces événements en fonction des fermetures dans la méthode /code> : 🎜

<?php
    namespace App\Listeners;
    use App\Events\OrderShipped;
    use Illuminate\Contracts\Queue\ShouldQueue;
    class SendShipmentNotification implements ShouldQueue{
       /**
     * The name of the connection the job should be sent to.
     *
     * @var string|null
     */  
   public $connection = 'sqs'; 
     /**
     * The name of the queue the job should be sent to.
     *
     * @var string|null
     */   
   public $queue = 'listeners';   
     /**
     * The time (seconds) before the job should be processed.
     *
     * @var int
     */ 
    public $delay = 60;
  }

🎜

Écouteur d'événements génériques

🎜Vous pouvez enregistrer l'écouteur dans Utilisez * comme paramètres génériques pour capturer plusieurs événements sur le même écouteur. L'écouteur générique reçoit le nom de l'événement comme premier argument et l'intégralité du tableau de données d'événement comme deuxième argument : 🎜

<?php
    namespace App\Listeners;
    use App\Events\OrderShipped;
    use Illuminate\Queue\InteractsWithQueue;
    use Illuminate\Contracts\Queue\ShouldQueue;
    class SendShipmentNotification implements ShouldQueue{
        use InteractsWithQueue;  
      /**
     * 处理事件。
     *
     * @param  \App\Events\OrderShipped  $event
     * @return void
     */   
    public function handle(OrderShipped $event)
        {     
           if (true) { 
                  $this->release(30);  
                  }  
          }
     }

🎜🎜🎜

🎜

Définir des événements

🎜La classe d'événement est un conteneur qui enregistre les informations liées à l'événement. Par exemple, supposons que l'événement OrderShipped que nous avons généré reçoive un objet ORM Eloquent : 🎜

<?php
    namespace App\Listeners;use App\Events\OrderShipped;
    use Illuminate\Queue\InteractsWithQueue;
    use Illuminate\Contracts\Queue\ShouldQueue;
    class SendShipmentNotification implements ShouldQueue{ 
       use InteractsWithQueue;   
       /**
     * 处理事件。
     *
     * @param  \App\Events\OrderShipped  $event
     * @return void
     */   
    public function handle(OrderShipped $event) 
       {    
           // 
        }  
    /**
     * 处理失败任务。
     *
     * @param  \App\Events\OrderShipped  $event
     * @param  \Exception  $exception
     * @return void
     */  
    public function failed(OrderShipped $event, $exception)
        {   
             //  
         }
     }

🎜Comme vous pouvez le voir, aucune autre logique n'est incluse dans cette classe d'événement. Il s'agit simplement d'un conteneur pour les instances achetées de Order. Si vous utilisez la fonction serialize de PHP pour sérialiser un objet événement, le trait SerializesModels utilisé par l'événement sérialisera gracieusement tout modèle Eloquent. 🎜🎜🎜🎜

🎜

Définir les auditeurs

🎜Ensuite, jetons un coup d'œil à l'exemple d'événement auditeur. Les écouteurs d'événements reçoivent des instances dans la méthode handle. La commande event:generate chargera automatiquement la classe d'événement correcte et ajoutera l'indice de type d'événement dans la méthode handle. Dans la méthode handle, vous pouvez effectuer toutes les opérations nécessaires en réponse à l'événement : 🎜

<?php
    namespace App\Http\Controllers;
    use App\Order;use App\Events\OrderShipped;
    use App\Http\Controllers\Controller;
    class OrderController extends Controller{   
       /**
     * 将传递过来的订单发货
     *
     * @param  int  $orderId
     * @return Response
     */   
   public function ship($orderId)
       {     
          $order = Order::findOrFail($orderId);        
          // 订单发货逻辑 ...        
          event(new OrderShipped($order));    
        }
       }

🎜{tip} Votre écouteur d'événement peut également ajouter des indices de type pour toutes les dépendances dans le constructeur. Tous les écouteurs d'événements sont résolus via le conteneur de services de Laravel, donc toutes les dépendances seront automatiquement injectées. 🎜

🎜

Arrêter la propagation des événements

🎜Parfois, vous pouvez passer la méthode handle dans l'écouteur Renvoyez false pour empêcher l'événement d'être acquis par d'autres écouteurs. 🎜🎜🎜🎜🎜🎜🎜

File d'attente de l'écouteur d'événements

Si votre écouteur doit effectuer des tâches lentes telles que l'envoi d'e-mails ou l'envoi de requêtes HTTP, vous pouvez choisir de le placer dans la file d'attente pour traitement. Avant de commencer à utiliser un écouteur de file d'attente, assurez-vous de pouvoir configurer des files d'attente et démarrer un écouteur de file d'attente sur votre serveur ou votre environnement de développement local.

Pour spécifier l'écouteur pour démarrer la file d'attente, vous pouvez ajouter l'interface ShouldQueue à la classe d'écoute. Les auditeurs générés par la commande Artisan event:generate ont cette interface importée dans l'espace de noms actuel, vous pouvez donc l'utiliser directement : ShouldQueue 接口。由 Artisan 命令 event:generate 生成的监听器已经将此接口导入到当前命名空间中，因此你可以直接使用：

<?php
    namespace App\Listeners;
    class UserEventSubscriber{  
      /**
     * 处理用户登录事件。
     */   
   public function onUserLogin($event) {}    
      /**
     * 处理用户注销事件。
     */   
   public function onUserLogout($event) {}   
    /**
     * 为订阅者注册监听器
     *
     * @param  \Illuminate\Events\Dispatcher  $events
     */   
    public function subscribe($events) 
       {      
         $events->listen(         
            'Illuminate\Auth\Events\Login',           
            'App\Listeners\UserEventSubscriber@onUserLogin'       
           );        
          $events->listen(         
             'Illuminate\Auth\Events\Logout',            
             'App\Listeners\UserEventSubscriber@onUserLogout'    
              );  
         }
      }

就是这个！当这个监听器被事件调用时，事件调度器会自动使用 Laravel 的 队列系统。如果在队列中执行监听器时没有抛出异常，任务会在执行完成后自动从队列中删除。

自定义队列连接 & 队列名称

如果你想要自定义事件监听器所使用的队列的连接和名称，你可以在监听器类中定义 $connection， $queue 或 $delay 属性：

<?php
    namespace App\Providers;
    use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
    class EventServiceProvider extends ServiceProvider{   
     /**
     * 应用中事件监听器的映射。
     *
     * @var array
     */   
   protected $listen = [  
         //  
        ];  
     /**
     * 需要注册的订阅者类。
     *
     * @var array
     */ 
    protected $subscribe = [ 
           'App\Listeners\UserEventSubscriber',   
          ];
      }

手动访问队列

如果你需要手动访问监听器下面队列任务的 delete 和 release 方法，你可以通过使用 IlluminateQueueInteractsWithQueue trait 来实现。这个 trait 会默认加载到生成的监听器中，并提供对这些方法的访问：

rrreee

处理失败任务

有时事件监听器的队列任务可能会失败。如果监听器的队列任务超过了队列中定义的最大尝试次数，则会在监听器上调用 failed 方法。 failed 方法接收事件实例和导致失败的异常作为参数：

rrreee

分发事件

如果要分发事件，你可以将事件实例传递给辅助函数 event 。该辅助函数将会把事件分发到所有该事件相应的已经注册了的监听器上。 eventrrreee

C'est tout ! Lorsque cet écouteur est appelé par un événement, le répartiteur d'événements utilise automatiquement le système de file d'attente de Laravel. Si aucune exception n'est levée lors de l'exécution de l'écouteur dans la file d'attente, la tâche sera automatiquement supprimée de la file d'attente une fois l'exécution terminée.

Connexion à la file d'attente personnalisée et nom de la file d'attente

Si vous souhaitez personnaliser la connexion et le nom de la file d'attente utilisée par l'écouteur d'événements, vous peut définir les attributs $connection, $queue ou $delay dans la classe d'écoute :

rrreee

Accès manuel à la file d'attente

Si vous devez accéder manuellement au suppression de la tâche de file d'attente sous les méthodes d'écoute et release, vous pouvez y parvenir en utilisant le trait IlluminateQueueInteractsWithQueue. Ce trait est chargé par défaut dans l'écouteur généré et donne accès à ces méthodes :

rrreee

Gestion des tâches ayant échoué

Parfois, la tâche de file d'attente de l'écouteur d'événements peut échouer. Si les tâches en file d'attente de l'écouteur dépassent le nombre maximum de tentatives défini dans la file d'attente, la méthode failed est appelée sur l'écouteur. La méthode failed reçoit une instance d'événement et l'exception qui a provoqué l'échec en tant que paramètres :

rrreee

🎜

🎜🎜Distribution d'événements🎜🎜Si vous souhaitez distribuer un événement, vous pouvez transmettre l'instance d'événement à la fonction d'assistance event. Cette fonction d'assistance distribuera l'événement à tous les auditeurs enregistrés correspondant à l'événement. La fonction d'assistance event peut être utilisée globalement et vous pouvez l'appeler n'importe où dans l'application : 🎜rrreee🎜🎜{tip} Lors du test, il vous suffit d'affirmer qu'un événement spécifique est distribué sans le déclencher réellement. auditeur. Les assistants de test intégrés de Laravel facilitent cette tâche. 🎜🎜🎜🎜🎜🎜🎜🎜🎜Abonné à l'événement🎜🎜🎜🎜🎜🎜🎜

Abonnés aux événements d'écriture

Les abonnés aux événements sont des classes qui peuvent s'abonner à plusieurs événements en leur sein, c'est-à-dire qu'ils peuvent définir plusieurs gestionnaires d'événements dans une seule classe. Les abonnés doivent définir une méthode subscribe qui reçoit une instance de répartiteur d'événements. Vous pouvez enregistrer des écouteurs d'événements en appelant la méthode listen sur un répartiteur d'événements donné : subscribe 方法，这个方法接收一个事件分发器实例。你可以调用给定事件分发器上的 listen 方法来注册事件监听器：

rrreee

注册事件订阅者

在编写完订阅者之后，就可以通过事件分发器对订阅者进行注册。你可以在 EventServiceProvider 中的 $subscribe 属性中注册订阅者。例如，让我们将 UserEventSubscriberrrreee

Enregistrer les abonnés à l'événement

🎜Après avoir écrit l'abonné, vous pouvez enregistrer l'abonné via le distributeur d'événements. Vous pouvez enregistrer des abonnés dans l'attribut $subscribe dans EventServiceProvider. Par exemple, ajoutons UserEventSubscriber à la liste des tableaux : 🎜rrreee🎜Cet article est apparu pour la première fois sur le site Web 🎜LearnKu.com🎜. 🎜🎜

← rassembler

Stockage de fichiers →

soumettre

Site Web PHP chinois

MaisonCoursArticleQuestions et réponsesDictionnaireManuelTéléchargerrecherche APPTélécharger