Eventos personalizados en Laravel

() translation by (you can also view the original English article)

En este artículo, vamos a explorar los conceptos básicos de la gestión de eventos en Laravel. Es una de las características importantes que usted, como desarrollador, debe tener en su arsenal en el marco deseado. A medida que avanzamos, también aprovecharemos esta oportunidad para crear un ejemplo del mundo real de un evento personalizado y un oyente, y ese es también el objetivo final de este artículo.

El concepto de eventos en Laravel se basa en un patrón de diseño de software muy popular: el patrón del observador. En este patrón, se supone que el sistema genera eventos cuando sucede algo, y usted puede definir oyentes que escuchen estos eventos y reaccionen en consecuencia. Es una característica realmente útil de una manera que le permite desacoplar componentes en un sistema que de otro modo hubiera resultado en un código estrechamente acoplado.

Por ejemplo, supongamos que desea notificar a todos los módulos en un sistema cuando alguien inicia sesión en su sitio. Por lo tanto, les permite reaccionar ante este evento de inicio de sesión, ya sea para enviar un correo electrónico o una notificación dentro de la aplicación, o para cualquier cosa que quiera reaccionar a este evento de inicio de sesión.

Conceptos básicos de eventos y oyentes

En esta sección, exploraremos la forma en que Laravel implementa eventos y oyentes en el marco central. Si está familiarizado con la arquitectura de Laravel, probablemente sepa que Laravel implementa el concepto de un proveedor de servicios que le permite inyectar diferentes servicios en una aplicación.

Del mismo modo, Laravel proporciona una clase EventServiceProvider.php integrada que nos permite definir asignaciones de escucha de eventos para una aplicación.

Continúa y selecciona el archivo app/Providers/EventServiceProvider.php

<?php
namespace App\Providers;
use Illuminate\Support\Facades\Event;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
class EventServiceProvider extends ServiceProvider
{
    /**
     * The event listener mappings for the application.
     *
     * @var array
     */
    protected $listen = [
        'App\Events\SomeEvent' => [
        'App\Listeners\EventListener',
        ],
    ];
    /**
     * Register any events for your application.
     *
     * @return void
     */
    public function boot()
    {
        parent::boot();
        //
    }
}

Echemos un vistazo de cerca a la propiedad $ listen, que le permite definir una matriz de eventos y oyentes asociados. Las teclas de matriz corresponden a eventos en un sistema, y sus valores corresponden a oyentes que se activarán cuando se genere el evento correspondiente en un sistema.

Prefiero ir a través de un ejemplo del mundo real para demostrarlo más. Como probablemente sepa, Laravel proporciona un sistema de autenticación integrado que facilita funciones como inicio de sesión, registro y similares.

Supongamos que desea enviar la notificación por correo electrónico, como medida de seguridad, cuando alguien inicia sesión en la aplicación. Si Laravel no admitió la función de escucha de eventos, es posible que haya terminado editando la clase principal o de alguna otra manera para conectar su código que envía un correo electrónico.

De hecho, estás en el lado más afortunado ya que Laravel te ayuda a resolver este problema usando el detector de eventos. Revisemos el archivo app/Providers/EventServiceProvider.php para que se vea como el siguiente.

<?php
namespace App\Providers;
use Illuminate\Support\Facades\Event;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
class EventServiceProvider extends ServiceProvider
{
    /**
     * The event listener mappings for the application.
     *
     * @var array
     */
    protected $listen = [
        'Illuminate\Auth\Events\Login' => [
        'App\Listeners\SendEmailNotification',
        ],
    ];
    /**
     * Register any events for your application.
     *
     * @return void
     */
    public function boot()
    {
        parent::boot();
        //
    }
}

Illuminate \ Auth \ Events \ Login es un evento que será generado por el complemento Auth cuando alguien inicie sesión en una aplicación. Hemos vinculado ese evento al oyente App \ Listeners \ SendEmailNotification, por lo que se activará en el evento de inicio de sesión.

Por supuesto, debe definir la clase de escucha App \ Listeners \ SendEmailNotification en primer lugar. Como siempre, Laravel le permite crear un código de plantilla de un oyente utilizando el comando artesanal.

1	php artisan event:generate

Este comando genera clases de eventos y escucha listadas bajo la propiedad $ listen.

En nuestro caso, el evento Illuminate \ Auth \ Events \ Login ya existe, por lo que solo crea la clase de escucha App \ Listeners \ SendEmailNotification. De hecho, también habría creado la clase de evento Illuminate \ Auth \ Events \ Login si no existía en primer lugar.

Echemos un vistazo a la clase de oyente creada en la app/ Listeners / SendEmailNotification.php.

<?php
namespace App\Listeners;
use Illuminate\Auth\Events\Login;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
class SendEmailNotification
{
    /**
     * Create the event listener.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }
    /**
     * Handle the event.
     *
     * @param  Login  $event
     * @return void
     */
    public function handle(Login $event)
    {
        
    }
}

Es el método de handle que se invocará con las dependencias apropiadas siempre que se active el oyente. En nuestro caso, el argumento $ event debe contener información contextual sobre el inicio de sesión de sesión de sesión en la información del usuario.

Y podemos usar el objeto $ event para llevar a cabo un procesamiento posterior en el método de handle. En nuestro caso, queremos enviar la notificación por correo electrónico al usuario que inició sesión.

El método handle revisado puede ser algo así como:

public function handle(Login $event)
{
    // get logged in user's email and username
    $email = $event->user->email;
    $username = $event->user->name;
    
    // send email notification about login
}

Así es como se supone que debes usar la función de eventos en Laravel. A partir de la siguiente sección, avanzaremos y crearemos un evento personalizado y una clase de oyente asociada.

Crear un evento personalizado

El escenario de ejemplo que vamos a usar para nuestro ejemplo es algo como esto:

Una aplicación necesita borrar cachés en un sistema en ciertos puntos. Lanzaremos el evento CacheClear junto con la información contextual cuando una aplicación haga lo anterior. Pasaremos las claves del grupo de caché junto con un evento que se borró.
Otros módulos en un sistema pueden escuchar el evento CacheClear y desearían implementar un código que calienta cachés relacionados.

Revisemos el archivo de la app / Providers / EventServiceProvider.php y registremos nuestro evento personalizado y las asignaciones de oyentes.

<?php
namespace App\Providers;
use Illuminate\Support\Facades\Event;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
class EventServiceProvider extends ServiceProvider
{
    /**
     * The event listener mappings for the application.
     *
     * @var array
     */
    protected $listen = [
        'App\Events\ClearCache' => [
        'App\Listeners\WarmUpCache',
        ],
    ];
    /**
     * Register any events for your application.
     *
     * @return void
     */
    public function boot()
    {
        parent::boot();
        //
    }
}

Como puede ver, hemos definido el evento App \ Events \ ClearCache y la clase de escucha asociada App \ Listeners \ WarmUpCache debajo de la propiedad $ listen.

Luego, necesitamos crear archivos de clase asociados. Recuerde que siempre puede usar el comando artesanal para generar un código de plantilla base.

1	php artisan event:generate

Eso debería haber creado la clase de evento en laapp / Events / ClearCache.php y la clase de escucha en la app / Listeners / WarmUpCache.php.

Con algunos cambios, la clase de la app / Eventos / ClearCache.php debería verse así:

<?php
namespace App\Events;
use Illuminate\Broadcasting\Channel;
use Illuminate\Queue\SerializesModels;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
class ClearCache
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    
    public $cache_keys = [];
    /**
     * Create a new event instance.
     *
     * @return void
     */
    public function __construct(Array $cache_keys)
    {
        $this->cache_keys = $cache_keys;
    }
    /**
     * Get the channels the event should broadcast on.
     *
     * @return Channel|array
     */
    public function broadcastOn()
    {
        return new PrivateChannel('channel-name');
    }
}

Como probablemente hayas notado, hemos agregado una nueva propiedad $ cache_keys que se usará para guardar información que se transmitirá junto con un evento. En nuestro caso, pasaremos los grupos de caché que fueron enrojecidos.

A continuación, echemos un vistazo a la clase de oyente con un método de handle actualizado en la app / Listeners / WarmUpCache.php.

<?php
namespace App\Listeners;
use App\Events\ClearCache;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
class WarmUpCache
{
    /**
     * Create the event listener.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }
    /**
     * Handle the event.
     *
     * @param  ClearCache  $event
     * @return void
     */
    public function handle(ClearCache $event)
    {
        if (isset($event->cache_keys) && count($event->cache_keys)) {
            foreach ($event->cache_keys as $cache_key) {
                // generate cache for this key
                // warm_up_cache($cache_key)
            }
        }
    }
}

Cuando se invoca al oyente, el método de handle se pasa con la instancia del evento asociado. En nuestro caso, debería ser la instancia del evento ClearCache que se pasará como primer argumento para el método handle.

A continuación, solo se trata de iterar a través de cada tecla de caché y calentar los cachés asociados.

Ahora, tenemos todo en su lugar para probar cosas en contra. Creemos rápidamente un archivo de controlador en la app / Http / Controllers / EventController.php para demostrar cómo se puede generar un evento.

<?php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Library\Services\Contracts\CustomServiceInterface;
use App\Post;
use Illuminate\Support\Facades\Gate;
use App\Events\ClearCache;
class EventController extends Controller
{
    public function index()
    {
        // ...
        
        // you clear specific caches at this stage
        $arr_caches = ['categories', 'products'];
        
        // want to raise ClearCache event
        event(new ClearCache($arr_caches));
        
        // ...
    }
}

En primer lugar, hemos pasado una matriz de claves de caché como primer argumento al crear una instancia del evento ClearCache.

La función de asistente de eventos se usa para generar un evento desde cualquier lugar dentro de una aplicación. Cuando se levanta el evento, Laravel llama a todos los oyentes que escuchan ese evento en particular.

En nuestro caso, el oyente App \ Listeners \ WarmUpCache está configurado para escuchar el evento App \ Events \ ClearCache. Por lo tanto, el método handle del escucha de App \ Listeners \ WarmUpCache se invoca cuando el evento se genera desde un controlador. ¡El resto es calentar los cachés que fueron eliminados!

Así es como puede crear eventos personalizados en su aplicación y trabajar con ellos.

¿Qué es un suscriptor de evento?

El suscriptor del evento le permite suscribirse a múltiples oyentes de eventos en un solo lugar. Si desea agrupar lógicamente oyentes de eventos o si desea incluir eventos en crecimiento en un solo lugar, es el suscriptor del evento que está buscando.

Si hubiéramos implementado los ejemplos discutidos hasta ahora en este artículo usando el suscriptor del evento, podría verse así.

<?php
// app/Listeners/ExampleEventSubscriber.php
namespace App\Listeners;
class ExampleEventSubscriber
{
    /**
     * Handle user login events.
     */
    public function sendEmailNotification($event) {
        // get logged in username
        $email = $event->user->email;
        $username = $event->user->name;
        
        // send email notification about login...
    }
    /**
     * Handle user logout events.
     */
    public function warmUpCache($event) {
        if (isset($event->cache_keys) && count($event->cache_keys)) {
            foreach ($event->cache_keys as $cache_key) {
                // generate cache for this key
                // warm_up_cache($cache_key)
            }
        }
    }
    /**
     * Register the listeners for the subscriber.
     *
     * @param  Illuminate\Events\Dispatcher  $events
     */
    public function subscribe($events)
    {
        $events->listen(
            'Illuminate\Auth\Events\Login',
            'App\Listeners\ExampleEventSubscriber@sendEmailNotification'
        );
        
        $events->listen(
            'App\Events\ClearCache',
            'App\Listeners\ExampleEventSubscriber@warmUpCache'
        );
    }
}

Es el método de suscribe el responsable de registrar oyentes. El primer argumento del método subscribe es la instancia de la clase Illuminate \ Events \ Dispatcher que puede usar para vincular eventos con oyentes utilizando el método listen.

El primer argumento del método listen es un evento que desea escuchar, y el segundo argumento es un oyente al que se llamará cuando se produzca el evento.

De esta forma, puede definir múltiples eventos y oyentes en la clase del suscriptor.

La clase de suscriptor del evento no se recogerá automáticamente. Debe registrarlo en la clase EventServiceProvider.php debajo de la propiedad $ subscriber, como se muestra en el siguiente fragmento.

<?php
namespace App\Providers;
use Illuminate\Support\Facades\Event;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
class EventServiceProvider extends ServiceProvider
{
    /**
     * The subscriber classes to register.
     *
     * @var array
     */
    protected $subscribe = [
        'App\Listeners\ExampleEventSubscriber',
    ];
    /**
     * Register any events for your application.
     *
     * @return void
     */
    public function boot()
    {
        parent::boot();
        //
    }
}

Así que esa fue la clase de suscriptor del evento a su disposición, y con eso hemos llegado al final de este artículo también.

Conclusión

Hoy hemos discutido algunas de las características más interesantes de Laravel: eventos y oyentes. Se basan en el patrón de diseño del observador que le permite generar eventos en toda la aplicación y permitir que otros módulos escuchen esos eventos y reaccionen en consecuencia.

¿Acaba de ponerse al día con Laravel o desea expandir su conocimiento, sitio o aplicación con extensiones? Tenemos una variedad de cosas que puedes estudiar en Envato Market.

¡Siéntete libre de expresar tus pensamientos usando el feed a continuación!

1	<?php
2	namespace App\Listeners;
3	use App\Events\ClearCache;
4	use Illuminate\Queue\InteractsWithQueue;
5	use Illuminate\Contracts\Queue\ShouldQueue;
6	class WarmUpCache
7	{
8	/**
9	* Create the event listener.
10	*
11	* @return void
12	*/
13	public function __construct()
14	{
15	//
16	}
17	/**
18	* Handle the event.
19	*
20	* @param ClearCache $event
21	* @return void
22	*/
23	public function handle(ClearCache $event)
24	{
25	if (isset($event->cache_keys) && count($event->cache_keys)) {
26	foreach ($event->cache_keys as $cache_key) {
27	// generate cache for this key
28	// warm_up_cache($cache_key)
29	}
30	}
31	}
32	}

1	<?php
2	// app/Listeners/ExampleEventSubscriber.php
3	namespace App\Listeners;
4	class ExampleEventSubscriber
5	{
6	/**
7	* Handle user login events.
8	*/
9	public function sendEmailNotification($event) {
10	// get logged in username
11	$email = $event->user->email;
12	$username = $event->user->name;
13
14	// send email notification about login...
15	}
16	/**
17	* Handle user logout events.
18	*/
19	public function warmUpCache($event) {
20	if (isset($event->cache_keys) && count($event->cache_keys)) {
21	foreach ($event->cache_keys as $cache_key) {
22	// generate cache for this key
23	// warm_up_cache($cache_key)
24	}
25	}
26	}
27	/**
28	* Register the listeners for the subscriber.
29	*
30	* @param Illuminate\Events\Dispatcher $events
31	*/
32	public function subscribe($events)
33	{
34	$events->listen(
35	'Illuminate\Auth\Events\Login',
36	'App\Listeners\ExampleEventSubscriber@sendEmailNotification'
37	);
38
39	$events->listen(
40	'App\Events\ClearCache',
41	'App\Listeners\ExampleEventSubscriber@warmUpCache'
42	);
43	}
44	}