Eventos personalizados em Laravel

Neste artigo, vamos explorar os fundamentos do gerenciamento de eventos no Laravel. Também criaremos um exemplo do mundo real de um evento e ouvinte personalizados.

O conceito de eventos no Laravel é baseado em um padrão de projeto de software muito popular – o padrão observador. Nesse padrão, o sistema gera eventos quando algo acontece e você pode definir ouvintes que ouvem esses eventos e reagem de acordo. É um recurso realmente útil que permite desacoplar componentes em um sistema que, de outra forma, resultaria em um código fortemente acoplado.

Por exemplo, digamos que você queira notificar todos os módulos em um sistema quando alguém fizer login em seu site. Assim, ele permite que eles reajam a esse evento de login, seja para enviar um e-mail ou notificação no aplicativo ou qualquer coisa que queira reagir a esse evento de login.

Noções básicas de eventos e ouvintes

Nesta seção, exploraremos a maneira do Laravel de implementar eventos e ouvintes no framework principal. Se você está familiarizado com a arquitetura do Laravel, provavelmente sabe que o Laravel implementa o conceito de um provedor de serviços que permite injetar diferentes serviços em uma aplicação.

Da mesma forma, o Laravel fornece um built-in EventServiceProvider.php classe que nos permite definir mapeamentos de ouvinte de eventos para um aplicativo.

Vá em frente e puxe o app/Providers/EventServiceProvider.php Arquivo.

 [
            SendEmailVerificationNotification::class,
        ],
    ];

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

        //
    }
}

Vamos dar uma olhada de perto no $listen propriedade, que permite definir uma matriz de eventos e ouvintes associados. As chaves de array correspondem a eventos em um sistema, e seus valores correspondem a listeners que serão acionados quando o evento correspondente for gerado em um sistema.

Eu prefiro passar por um exemplo do mundo real para demonstrá-lo ainda mais. Como você provavelmente sabe, o Laravel fornece um sistema de autenticação embutido que facilita recursos como login, registro e afins.

Suponha que você deseja enviar uma notificação por e-mail, como medida de segurança, quando alguém fizer login no aplicativo. Se o Laravel não suportasse o recurso de ouvinte de eventos, você pode ter editado a classe principal ou alguma outra maneira de conectar seu código que envia um e-mail.

Na verdade, você está no lado mais sortudo, pois o Laravel o ajuda a resolver esse problema usando o ouvinte de eventos. Vamos revisar o app/Providers/EventServiceProvider.php arquivo para se parecer com o seguinte.

 [
            SendEmailVerificationNotification::class,
        ],
        IlluminateAuthEventsLogin::class => [
            SendEmailNotification::class,
        ]
    ];

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

        //
    }
}

IlluminateAuthEventsLogin é um evento que será gerado pelo Auth plugin quando alguém faz login em um aplicativo. Ligamos esse evento ao AppListenersSendEmailNotification ouvinte, então ele será acionado no login evento.

É claro que você precisa definir o AppListenersSendEmailNotification classe de ouvinte em primeiro lugar. Como sempre, o Laravel permite que você crie um código de modelo de um ouvinte usando o artisan comando.

php artisan event:generate

Este comando gera classes de eventos e ouvintes listadas no $listen propriedade.

No nosso caso, o IlluminateAuthEventsLogin evento já existe, então ele apenas cria o AppListenersSendEmailNotification classe de ouvinte. Na verdade, teria criado o IlluminateAuthEventsLogin classe de evento também se ela não existisse em primeiro lugar.

Vamos dar uma olhada na classe listener criada em app/Listeners/SendEmailNotification.php.

É o handle método que será invocado com dependências apropriadas sempre que o ouvinte for acionado.  No nosso caso, o $event O argumento deve conter informações contextuais sobre o evento de login — informações do usuário conectado.
E podemos usar o $event objeto para realizar processamento adicional no handle método.  No nosso caso, queremos enviar uma notificação por e-mail para o usuário logado.
A revista handle método pode ser algo 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
}
Então é assim que você deve usar o recurso de eventos no Laravel.  Na próxima seção, criaremos um evento personalizado e uma classe de ouvinte associada.
Criar um evento personalizado
O cenário de exemplo que vamos usar para o nosso exemplo é algo assim:

Um aplicativo precisa limpar os caches em um sistema em determinados pontos.  Vamos levantar o CacheClear evento junto com as informações contextuais quando um aplicativo faz o mencionado acima.  Passaremos as chaves do grupo de cache junto com um evento que foi limpo.
Outros módulos em um sistema podem escutar o CacheClear evento e gostaria de implementar o código que aquece os caches relacionados.

Vamos revisitar o app/Providers/EventServiceProvider.php e registre nossos mapeamentos personalizados de eventos e ouvintes.
 [
            SendEmailVerificationNotification::class,
        ],
        ClearCache::class => [
            WarmUpCache::class,
        ],
    ];

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

        //
    }
}
Como você pode ver, definimos o AppEventsClearCache evento e classe de ouvinte associada AppListenersWarmUpCache debaixo de $listen propriedade.
Em seguida, precisamos criar arquivos de classe associados.  Lembre-se de que você sempre pode usar o artisan comando para gerar um código de modelo base.
php artisan event:generate
Isso deveria ter criado a classe de evento em app/Events/ClearCache.php e a classe de ouvinte em app/Listeners/WarmUpCache.php.
Com algumas mudanças, o app/Events/ClearCache.php classe deve ficar assim:
cache_keys = $cache_keys;
    }

    /**
     * Get the channels the event should broadcast on.
     *
     * @return IlluminateBroadcastingChannel|array
     */
    public function broadcastOn()
    {
        return new PrivateChannel('channel-name');
    }
}
Como você deve ter notado, adicionamos uma nova propriedade $cache_keys que será usado para armazenar as informações que serão passadas junto com um evento.  No nosso caso, passaremos os grupos de cache que foram liberados.
Em seguida, vamos dar uma olhada na classe listener com atualização handle método em app/Listeners/WarmUpCache.php.
cache_keys) && count($event->cache_keys)) {
            foreach ($event->cache_keys as $cache_key) {
                // generate cache for this key
                // warm_up_cache($cache_key)
            }
        }
    }
}
Quando o ouvinte é invocado, o handle é passado com uma instância do evento associado.  No nosso caso, deve ser uma instância do ClearCache classe de evento, que será passada como o primeiro argumento para o handle método.
Em seguida, é apenas uma questão de iterar por cada chave de cache e aquecer os caches associados.
Agora, temos tudo no lugar para testar as coisas.  Vamos criar rapidamente um arquivo de controlador em app/Http/Controllers/EventController.php para demonstrar como você pode criar um evento.

Em primeiro lugar, passamos um array de chaves de cache como o primeiro argumento ao criar uma instância do ClearCache evento.
o event A função auxiliar é usada para gerar um evento de qualquer lugar dentro de um aplicativo.  Quando o evento é gerado, o Laravel chama todos os ouvintes que estão ouvindo esse evento em particular.
No nosso caso, o AppListenersWarmUpCache listener está configurado para ouvir o AppEventsClearCache evento.  Assim, o handle método do AppListenersWarmUpCache listener é invocado quando o evento é gerado de um controlador.  O resto é para aquecer as caches que foram limpas!
É assim que você pode criar eventos personalizados em seu aplicativo e trabalhar com eles.
O que é um assinante de evento?
O assinante de eventos permite que você assine vários ouvintes de eventos em um único local.  Se você deseja agrupar logicamente ouvintes de eventos ou deseja conter eventos crescentes em um único local, é o assinante de eventos que você está procurando.
Se tivéssemos implementado os exemplos discutidos até agora neste artigo usando o assinante do evento, poderia ser assim.
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  IlluminateEventsDispatcher  $events
     */
    public function subscribe($events)
    {
        $events->listen(
            Login::class,
            [ExampleEventSubscriber::class, 'sendEmailNotification']
        );
         
        $events->listen(
            ClearCache::class,
            [ExampleEventSubscriber::class, 'warmUpCache']
        );
    }
}
É o subscribe método que é responsável por registrar os ouvintes.  O primeiro argumento do subscribe O método é uma instância do IlluminateEventsDispatcher classe, que você pode usar para vincular eventos com ouvintes usando o listen método.
O primeiro argumento do listen O método é um evento que você deseja ouvir, e o segundo argumento é um ouvinte que será chamado quando o evento for gerado.
Dessa forma, você pode definir vários eventos e ouvintes na própria classe de assinante.
A classe de assinante do evento não será selecionada automaticamente.  Você precisa registrá-lo no EventServiceProvider.php classe sob o $subscribe propriedade, conforme mostrado no trecho a seguir.

Então essa era a classe de inscritos do evento à sua disposição, e com isso chegamos ao final deste artigo também.
Conclusão
Hoje discutimos alguns dos recursos interessantes do Laravel—eventos e ouvintes.  Eles são baseados no padrão de design do observador, que permite que você gere eventos em todo o aplicativo e permita que outros módulos escutem esses eventos e reajam de acordo.