El sistema de eventos de Laravel es fenomenal cuando se trata de manejar datos complejos en nuestras aplicaciones web, ya que es la piedra angular para crear aplicaciones desacopladas y absolutamente complejas. Esta guía brinda puntos extremadamente detallados sobre la implementación y utilización de la escucha de eventos, especialmente en 2024, brindando una nueva perspectiva con el contenido más amplio y ejemplos de código detallados de escuchas de eventos en Laravel 11.

*(A) Comprender el núcleo detrás de los eventos y los oyentes
*
ASÍ QUE, DESGLOSELOS, los eventos en Laravel representan ocurrencias específicas dentro de una aplicación. Los oyentes son las clases que responderían a todos estos eventos de la aplicación. Este patrón sigue promoviendo una separación de preocupaciones y ha permitido un código más modular y comprobable.

*(B) Creando un evento
*
Comencemos creando un evento incluso complejo, para eso usaremos el comando Artisan para explicarlo mejor. Te sugerimos encarecidamente que lo hagas también

php artesano hacer: evento OrderPlaced

Este comando generará una nueva clase de evento en el directorio aplicación/Eventos. Examinemos una clase de evento más detallada

`Aplicación de espacio de nombres\Eventos;

usar Aplicación\Modelos\Orden;
utilizar Aplicación\Modelos\Usuario;
utilizar Illuminate\Foundation\Events\Dispatchable;
utilizar Illuminate\Queue\SerializesModels;
utilizar Illuminate\Broadcasting\InteractsWithSockets;
utilizar Illuminate\Broadcasting\PrivateChannel;
utilice Illuminate\Contracts\Broadcasting\ShouldBroadcast;

clase OrderPlaced implementa ShouldBroadcast
{
utilizar 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';
}

}`

En este ejemplo ampliado, hemos incluido los modelos de Orden y Usuario. El rasgo SerializesModels ha sido garantizar que nuestros modelos Eloquent se serialicen y deserialicen correctamente cuando el evento se pasa a los oyentes en cola. También implementamos la interfaz ShouldBroadcast y definimos los métodos broadcastOn y broadcastAs, lo que permite que este evento se transmita a websockets para obtener actualizaciones en tiempo real.

*Creación de múltiples oyentes
*
Para un solo evento, es posible que necesitemos varios oyentes. Creemos dos oyentes para nuestro evento OrderPlaced para ampliar aún más el ejemplo. Sólo quiero que se aseguren de entender la esencia de todo. Entonces, para eso, consulte el ejemplo de código a continuación

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

Así que ahora entenderás que esta línea de comando nos daría un par de nuevas clases de escucha en nuestro directorio app/Listeners. Ahora la cuestión es que, aquí abajo, examinaríamos el oyente SendOrderConfirmation y veríamos cómo avanza más

`Aplicación de espacio de nombres\Oyentes;

usar Aplicación\Eventos\OrderPlaced;
utilizar Aplicación\Correo\Confirmación de pedido;
utilizar Illuminate\Contracts\Queue\ShouldQueue;
utilizar Illuminate\Queue\InteractsWithQueue;
utilizar Illuminate\Support\Facades\Mail;
utilizar Iluminar\Soporte\Fachadas\Log;

la clase SendOrderConfirmation implementa ShouldQueue
{
utilizar InteractúaConQueue;

/**
 * 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()]);
}

}`

Este oyente ha estado implementando la interfaz ShouldQueue, indicando que debe estar en cola. Agregamos manejo de errores, registro y definimos un método fallido para manejar fallas. La propiedad $tries se configuraría para permitir múltiples intentos en caso de falla.
Ahora, veamos el oyente UpdateInventory

`Aplicación de espacio de nombres\Oyentes;

usar Aplicación\Eventos\OrderPlaced;
utilizar Illuminate\Contracts\Queue\ShouldQueue;
utilizar Illuminate\Queue\InteractsWithQueue;
utilizar Illuminate\Support\Facades\DB;
utilizar Iluminar\Soporte\Fachadas\Log;

la clase UpdateInventory implementa ShouldQueue
{
utilizar InteractúaConQueue;

/**
 * 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()]);
}

}`

Ahora, comprenderá que este oyente está ahí por razones como actualizar el inventario en función de los artículos del pedido, etc. Hemos incluido la actualización del inventario en una transacción de base de datos para garantizar la coherencia de los datos. También agregamos verificación de errores para evitar existencias negativas e incluimos el registro de actualizaciones y fallas exitosas.

*Registrar eventos y oyentes
*
Registraremos estos eventos y oyentes en EventServiceProvider

`usar Aplicación\Eventos\OrderPlaced;
utilizar Aplicación\Listeners\SendOrderConfirmation;
utilizar App\Listeners\UpdateInventory;

clase EventServiceProvider extiende ServiceProvider
{
/**
* Las asignaciones de detectores de eventos para la aplicación.
*
* @var matriz
*/
protegido $escuchar = [
Pedido realizado::clase => [
EnviarConfirmaciónPedido::clase,
ActualizarInventario::clase,
],
];

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

    //
}

}`

Envío de eventos:

Podemos enviar el evento desde un controlador o clase de servicio

`usar Aplicación\Eventos\OrderPlaced;
utilizar Aplicación\Modelos\Orden;
utilizar Illuminate\Http\Request;
utilizar Illuminate\Support\Facades\DB;

clase OrderController extiende el controlador
{
/**
* Realizar un nuevo pedido.
*
* @param \Illuminate\Http\Request $solicitud
* @return \Illuminate\Http\JsonResponse
*/
función pública placeOrder(Solicitud $solicitud)
{
$usuario = autenticación()->usuario();

    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]);
}

}`

En este ejemplo, hemos incluido la creación del pedido y el envío del evento en una transacción de base de datos para garantizar que ambos ocurran exitosamente o no ocurran en absoluto.