Démarrage rapide avec les événements du modèle Laravel

Les événements de modèle Laravel vous permettent de surveiller plusieurs points clés du cycle de vie du modèle et même d'empêcher l'enregistrement ou la suppression d'un modèle. La documentation Laravel Model Events fournit un aperçu de la façon d'utiliser les hooks pour associer les événements correspondants aux types d'événements associés, mais l'objectif principal de cet article est la construction et la configuration des événements et des écouteurs, avec quelques détails supplémentaires.

Aperçu des événements

Eloquent propose de nombreux événements qui vous permettent de les connecter à l'aide de hooks et d'ajouter des fonctionnalités personnalisées à vos modèles. Le modèle commence par les événements suivants :

récupéré

création

créé

mise à jour

mis à jour

sauvegarde

enregistré

suppression

supprimé

restauration

restauré

De la documentation, nous pouvons en apprendre davantage sur eux tous Comment est-il implémenté ? Vous pouvez également accéder à la classe de base de Model pour voir comment ils sont implémentés :

Lorsque le modèle existant est récupéré de la base de données, l'événement récupéré sera déclenché. Lorsqu'un nouveau modèle est enregistré pour la première fois, les événements de création et de création se déclenchent. Si la méthode save est appelée sur un modèle qui existe déjà dans la base de données, l'événement update/mis à jour sera déclenché. Quoi qu’il en soit, dans les deux cas, les événements sauvegardés/sauvegardés se déclencheront.

Le document donne un bon aperçu des événements modèles et explique comment utiliser les hooks pour associer des événements, mais si vous êtes débutant ou n'êtes pas familier avec la façon d'utiliser les hooks pour connecter les écouteurs d'événements à ces personnalisations, les événements modèles sont associés, veuillez lire plus loin dans cet article.

Enregistrement d'événements

Pour associer un événement à votre modèle, la première chose que vous devez faire est d'enregistrer l'objet événement à l'aide de la propriété $dispatchesEvents, qui sera finalement déclenché par la méthode HasEvents::fireCustomModelEvent(), qui sera appelée par la méthode fireModelEvent(). La méthode fireCustomModelEvent() ressemblait à l'origine à ceci :

/**
 * 为给定的事件触发一个自定义模型。
 *
 * @param  string  $event
 * @param  string  $method
 * @return mixed|null
 */
protected function fireCustomModelEvent($event, $method)
{
    if (! isset($this->dispatchesEvents[$event])) {
        return;
    }
    $result = static::$dispatcher->$method(new $this->dispatchesEvents[$event]($this));
    if (! is_null($result)) {
        return $result;
    }
}

Certains événements, tels que la suppression, seront détectés pour déterminer si l'événement renverra false, puis quittera l'opération. Par exemple, vous pouvez utiliser ce hook pour effectuer une détection et empêcher la création ou la suppression d’un utilisateur.

En utilisant le modèle AppUser par exemple, voici comment configurer votre événement de modèle :

protected $dispatchesEvents = [
    'saving' => \App\Events\UserSaving::class,
];

Vous pouvez utiliser la commande artisan make:event pour créer cet événement pour vous, mais en gros ce sera votre Le résultat final est :

<?php
namespace App\Events;
use App\User;
use Illuminate\Queue\SerializesModels;
class UserSaving
{
    use SerializesModels;
    public $user;
    /**
     *  创建一个新的事件实例
     *
     * @param \App\User $user
     */
    public function __construct(User $user)
    {
        $this->user = $user;
    }
}

Notre événement fournit une propriété publique $user afin que vous puissiez accéder à l'instance du modèle User pendant l'événement de sauvegarde.

La prochaine chose que vous devez faire pour que cela fonctionne est de configurer un véritable auditeur pour cet événement. Nous définissons l'heure de déclenchement du modèle Lorsque le modèle User déclenche l'événement de sauvegarde, l'écouteur sera appelé.

Créer un écouteur d'événement

Maintenant, nous définissons le modèle utilisateur et enregistrons un écouteur d'événement pour écouter le déclenchement de l'événement de sauvegarde. Même si j'ai pu le faire rapidement avec des observateurs modèles, je souhaite vous guider dans la configuration des écouteurs d'événements pour les déclencheurs d'événements individuels.

Les écouteurs d'événements sont comme les autres écouteurs d'événements dans Laravel. La méthode handle() recevra une instance de la classe d'événements AppEventsUserSaving.

Vous pouvez le créer manuellement ou utiliser la commande php artisan make:listener. Quoi qu'il en soit, vous allez créer une classe d'écoute comme celle-ci :

<?php
namespace App\Listeners;
use App\Events\UserSaving as UserSavingEvent;
class UserSaving
{
    /**
     * 处理事件。
     *
     * @param  \App\Events\UserSavingEvent $event
     * @return mixed
     */
    public function handle(UserSavingEvent $event)
    {
        app(&#39;log&#39;)->info($event->user);
    }
}

Je viens d'ajouter un appel de journalisation pour faciliter l'inspection du modèle transmis à l'auditeur. Pour ce faire, nous devons également enregistrer un écouteur dans l'attribut EventServiceProvider::$listen :

<?php
namespace App\Providers;
use Illuminate\Support\Facades\Event;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
class EventServiceProvider extends ServiceProvider
{
    /**
     * 应用的事件监听器。
     * 
     * @var array
     */
    protected $listen = [
        \App\Events\UserSaving::class => [
            \App\Listeners\UserSaving::class,
        ],
    ];
    // ...
}

Maintenant, lorsque le modèle appelle l'événement de sauvegarde, l'écouteur d'événement que nous avons enregistré sera également déclenché et exécuté.

Essayez l'écoute d'événement

Nous pouvons rapidement générer du code d'écoute d'événement via la session de bricolage :

php artisan tinker
>>> factory(\App\User::class)->create();
=> App\User {#794
     name: "Aiden Cremin",
     email: "josie05@example.com",
     updated_at: "2018-03-15 03:57:18",
     created_at: "2018-03-15 03:57:18",
     id: 2,
   }

Si vous avez correctement enregistré l'événement et l'auditeur, Vous devriez voir l'expression JSON du modèle dans le fichier laravel.log :

[2018-03-15 03:57:18] local.INFO: {"name":"Aiden Cremin","email":"josie05@example.com"}

Une chose à noter est que le modèle n'a pas d'attributs Create_at ou Updated_at pour le moment. Si save() est à nouveau appelé sur le modèle, il y aura un nouvel enregistrement avec un horodatage sur le journal, car l'événement de sauvegarde se déclenche sur les enregistrements nouvellement créés ou sur les enregistrements existants :

>>> $u = factory(\App\User::class)->create();
=> App\User {#741
     name: "Eloisa Hirthe",
     email: "gottlieb.itzel@example.com",
     updated_at: "2018-03-15 03:59:37",
     created_at: "2018-03-15 03:59:37",
     id: 3,
   }
>>> $u->save();
=> true
>>>

Arrêter une sauvegarde opération

Certains événements de modèle permettent d'effectuer des opérations de blocage. Pour donner un exemple ridicule, supposons que nous n'autorisons aucun modèle d'utilisateur à enregistrer son attribut $user->name. Le contenu est Paul :

/**
 * 处理事件。
 *
 * @param  \App\Events\UserSaving $event
 * @return mixed
 */
public function handle(UserSaving $event)
{
    if (stripos($event->user->name, 'paul') !== false) {
        return false;
    }
}

Dans la méthode Model::save() d'Eloquent, il. sera basé sur Le résultat renvoyé de la surveillance des événements détermine s'il faut arrêter la sauvegarde :

public function save(array $options = [])
{
    $query = $this->newQueryWithoutScopes();
    // 如果 "saving" 事件返回 false ，我们将退出保存并返回
    // false，表示保存失败。这为服务监听者提供了一个机会，
    // 当验证失败或者出现其它任何情况，都可以取消保存操作。
    if ($this->fireModelEvent('saving') === false) {
        return false;
    }

Cette save() est un bon exemple. Elle vous indique comment personnaliser les événements dans le cycle de vie du modèle et effectuer passivement l'enregistrement des données de journal. ou Planification des tâches.

Utilisation d'observateurs

Si vous écoutez plusieurs événements, vous trouverez peut-être plus pratique d'utiliser une classe d'observateur pour stocker les événements regroupés par type. Voici un exemple d'Observateur Eloquent :

<?php
namespace App\Observers;
use App\User;
class UserObserver
{
    /**
     * 监听 User 创建事件。
     *
     * @param  \App\User  $user
     * @return void
     */
    public function created(User $user)
    {
        //
    }
    /**
     * 监听 User 删除事件。
     *
     * @param  \App\User  $user
     * @return void
     */
    public function deleting(User $user)
    {
        //
    }
}

Vous pouvez enregistrer un observateur dans la méthode boot() du fournisseur de services AppServiceProvider.

/**
 * 运行所有应用服务。
 *
 * @return void
 */
public function boot()
{
    User::observe(UserObserver::class);
}

推荐教程：《Laravel教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!