Le système d'événements de Laravel est phénoménal lorsqu'il s'agit de traiter les données complexes de nos applications Web, car il constitue la pierre angulaire de la création d'applications découplées et absolument complexes. Ce guide explique des points extrêmement détaillés sur la mise en œuvre et l'utilisation de l'écoute d'événements, en particulier en 2024, offrant une nouvelle perspective avec le contenu le plus complet et des exemples de code détaillés pour les auditeurs d'événements dans Laravel 11.

*(A) Comprendre le cœur des événements et des auditeurs
*
Alors, décomposons-les, les événements de Laravel représentent des occurrences spécifiques à l'intérieur d'une application. Les auditeurs sont les classes qui répondraient à tous ces événements d'application. Ce modèle continue de promouvoir une séparation des préoccupations et permet un code plus modulaire et testable.

*(B) Créer un événement
*
Commençons par créer un événement, même complexe, pour lequel nous utiliserons la commande Artisan pour mieux expliquer, nous vous suggérons fortement de le faire également

php artisan make:événement CommandePlaced

Cette commande générera une nouvelle classe d'événements dans le répertoire app/Events. Examinons une classe d'événements plus détaillée

`Application d'espace de noms\Événements ;

utiliser App\Models\Order;
utilisez App\Modèles\Utilisateur;
utilisez Illuminate\Foundation\Events\Dispatchable;
utilisez Illuminate\Queue\SerializesModels;
utilisez Illuminate\Broadcasting\InteractsWithSockets;
utilisez Illuminate\Broadcasting\PrivateChannel;
utilisez Illuminate\Contracts\Broadcasting\ShouldBroadcast;

la classe OrderPlaced implémente ShouldBroadcast
{
utilisez Dispatchable, InteractsWithSockets, SerializesModels ;

public $order;
public $user;

/**
 * Create a new event instance.
 *
 * @param  \App\Models\Order  $order
 * @param  \App\Models\User  $user
 * @return void
 */
public function __construct(Order $order, User $user)
{
    $this->order = $order;
    $this->user = $user;
}

/**
 * Get the channels the event should broadcast on.
 *
 * @return \Illuminate\Broadcasting\Channel|array
 */
public function broadcastOn()
{
    return new PrivateChannel('orders.'.$this->user->id);
}

/**
 * The event's broadcast name.
 *
 * @return string
 */
public function broadcastAs()
{
    return 'order.placed';
}

}`

Dans cet exemple développé, nous avons inclus à la fois les modèles Order et User. Le trait SerializesModels garantit que nos modèles Eloquents sont correctement sérialisés et désérialisés lorsque l'événement est transmis aux auditeurs en file d'attente. Nous avons également implémenté l'interface ShouldBroadcast et défini les méthodes broadcastOn et broadcastAs, permettant à cet événement d'être diffusé sur des websockets pour des mises à jour en temps réel.

*Création de plusieurs auditeurs
*
Pour un seul événement, nous pourrions vouloir plusieurs auditeurs. Créons deux écouteurs pour notre événement OrderPlaced afin d'élargir davantage l'exemple. Je veux juste que vous vous assuriez de bien comprendre l'essentiel. Donc, pour cela, veuillez consulter l'exemple de code ci-dessous

php artisan make:listener SendOrderConfirmation --event=OrderPlaced
php artisan make:listener UpdateInventory --event=OrderPlaced

Donc, vous comprendrez maintenant que cette ligne de commande nous apporterait quelques nouvelles classes d'écoute dans notre répertoire app/Listeners. Maintenant, le fait est que, ci-dessous, nous examinerions l'écouteur SendOrderConfirmation et verrons comment il progresse davantage

`espace de noms App\Listeners;

utiliser App\Events\OrderPlaced ;
utilisez App\Mail\OrderConfirmation;
utilisez Illuminate\Contracts\Queue\ShouldQueue;
utilisez Illuminate\Queue\InteractsWithQueue;
utilisez Illuminate\Support\Facades\Mail;
utilisez Illuminate\Support\Facades\Log;

la classe SendOrderConfirmation implémente ShouldQueue
{
utiliser InteractsWithQueue;

/**
 * The number of times the job may be attempted.
 *
 * @var int
 */
public $tries = 3;

/**
 * Handle the event.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @return void
 */
public function handle(OrderPlaced $event)
{
    $order = $event->order;
    $user = $event->user;

    try {
        Mail::to($user->email)->send(new OrderConfirmation($order));
        Log::info('Order confirmation email sent', ['order_id' => $order->id, 'user_id' => $user->id]);
    } catch (\Exception $e) {
        Log::error('Failed to send order confirmation email', ['order_id' => $order->id, 'user_id' => $user->id, 'error' => $e->getMessage()]);
        $this->fail($e);
    }
}

/**
 * Handle a job failure.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @param  \Throwable  $exception
 * @return void
 */
public function failed(OrderPlaced $event, $exception)
{
    Log::error('Order confirmation listener failed', ['order_id' => $event->order->id, 'user_id' => $event->user->id, 'error' => $exception->getMessage()]);
}

}`

Cet écouteur a implémenté l'interface ShouldQueue, indiquant qu'il doit être mis en file d'attente. Nous avons ajouté la gestion des erreurs, la journalisation et défini une méthode d'échec pour gérer les échecs. La propriété $tries serait définie pour autoriser plusieurs tentatives en cas d'échec.
Maintenant, regardons l'écouteur UpdateInventory

`espace de noms App\Listeners;

utiliser App\Events\OrderPlaced ;
utilisez Illuminate\Contracts\Queue\ShouldQueue;
utilisez Illuminate\Queue\InteractsWithQueue;
utilisez Illuminate\Support\Facades\DB;
utilisez Illuminate\Support\Facades\Log;

la classe UpdateInventory implémente ShouldQueue
{
utiliser InteractsWithQueue;

/**
 * Handle the event.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @return void
 */
public function handle(OrderPlaced $event)
{
    $order = $event->order;

    DB::transaction(function () use ($order) {
        foreach ($order->items as $item) {
            $product = $item->product;

            if ($product->stock quantity) {
                throw new \Exception("Insufficient stock for product: {$product->id}");
            }

            $product->decrement('stock', $item->quantity);
            Log::info("Inventory updated", ['product_id' => $product->id, 'quantity' => $item->quantity]);
        }
    });
}

/**
 * Handle a job failure.
 *
 * @param  \App\Events\OrderPlaced  $event
 * @param  \Throwable  $exception
 * @return void
 */
public function failed(OrderPlaced $event, $exception)
{
    Log::error('Failed to update inventory', ['order_id' => $event->order->id, 'error' => $exception->getMessage()]);
}

}`

Maintenant, vous comprendrez que cet auditeur est là pour des raisons telles que la mise à niveau de l'inventaire en fonction des articles commandés, etc. Nous avons enveloppé la mise à jour de l'inventaire dans une transaction de base de données pour garantir la cohérence des données. Nous avons également ajouté une vérification des erreurs pour éviter les stocks négatifs et inclus la journalisation des mises à jour réussies et des échecs.

*Enregistrement d'événements et d'auditeurs
*
Nous enregistrerons ces événements et auditeurs dans EventServiceProvider

`utiliser App\Events\OrderPlaced;
utilisez App\Listeners\SendOrderConfirmation;
utilisez App\Listeners\UpdateInventory;

la classe EventServiceProvider étend ServiceProvider
{
/**
* Les mappages d'écouteurs d'événements pour l'application.
*
* Tableau @var
*/
protégé $écouter = [
OrderPlaced::class => [
SendOrderConfirmation::classe,
UpdateInventory :: classe,
],
];

/**
 * Register any events for your application.
 *
 * @return void
 */
public function boot()
{
    parent::boot();

    //
}

}`

Répartition des événements :

Nous pouvons envoyer l'événement à partir d'un contrôleur ou d'une classe de service

`utiliser App\Events\OrderPlaced;
utilisez App\Models\Order;
utilisez Illuminate\Http\Request;
utilisez Illuminate\Support\Facades\DB;

class OrderController étend Controller
{
/**
* Passez une nouvelle commande.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\JsonResponse
*/
fonction publique placeOrder(Request $request)
{
$utilisateur = auth()->utilisateur();

    DB::transaction(function () use ($request, $user) {
        $order = Order::create($request->all());
        $order->user()->associate($user);
        $order->save();

        event(new OrderPlaced($order, $user));
    });

    return response()->json(['message' => 'Order placed successfully', 'order_id' => $order->id]);
}

}`

Dans cet exemple, nous avons encapsulé la création de commande et la répartition des événements dans une transaction de base de données pour garantir que les deux se produisent avec succès ou pas du tout.