Comment implémenter l'allocation et le recyclage automatiques des autorisations dans Laravel

Laravel est un framework PHP largement utilisé qui fournit des outils pratiques pour mettre en œuvre des problèmes courants tels que la gestion des autorisations. Dans de nombreuses applications, un contrôle précis des autorisations des utilisateurs est nécessaire pour garantir qu'ils ne peuvent accéder qu'à ce dont ils ont besoin. Dans cet article, nous explorerons comment attribuer et révoquer automatiquement des autorisations dans Laravel. Parallèlement, nous fournirons également des exemples de codes spécifiques.

1. Utilisez l'association polymorphe dans Laravel pour réaliser l'allocation et le recyclage automatiques des autorisations

L'ORM Eloquent de Laravel fournit la fonction d'association polymorphe, ce qui signifie que nous pouvons associer plusieurs modèles différents au même ensemble de données. Ceci est très utile pour l’attribution et le recyclage automatiques des autorisations.

Par exemple, supposons que nous devions contrôler les autorisations sur les « articles » et les « commentaires » dans notre application et attribuer des rôles aux utilisateurs. On peut créer les quatre modèles suivants :

• Utilisateur
• Article
• Commentaire
• Rôle

Ensuite, on peut utiliser la fonction d'association polymorphe pour combiner les trois modèles Association avec des rôles :

class User extends Model
{
    public function roles()
    {
        return $this->morphToMany(Role::class, 'model', 'model_has_roles');
    }
}

class Article extends Model
{
    public function roles()
    {
        return $this->morphToMany(Role::class, 'model', 'model_has_roles');
    }
}

class Comment extends Model
{
    public function roles()
    {
        return $this->morphToMany(Role::class, 'model', 'model_has_roles');
    }
}

Cet exemple utilise la fonction polymorphe de Laravel fonction d'association, nous permettant de définir des relations de rôle sur trois modèles et leurs enregistrements. L'étape suivante consiste à créer une table intermédiaire pour contenir ces relations :

class CreateModelHasRolesTable extends Migration
{
    public function up()
    {
        Schema::create('model_has_roles', function (Blueprint $table) {
            $table->unsignedBigInteger('role_id');
            $table->unsignedBigInteger('model_id');
            $table->string('model_type');
            $table->foreign('role_id')->references('id')->on('roles')->onDelete('cascade');
            $table->primary(['role_id', 'model_id', 'model_type']);
        });
    }
}

Nous pouvons maintenant associer le modèle ci-dessus au rôle correspondant. Par exemple, en supposant que nous ayons attribué le rôle « Auteur » au créateur de la publication, nous pourrions faire ceci :

$article->roles()->syncWithoutDetaching([
    Role::where('name', 'author')->first()->id
]);

De même, en créant un nouveau commentaire et en attribuant le rôle « Commentateur » au créateur de ce commentaire, nous pourrions faire ceci :

$comment = new Comment();
$comment->content = 'This is a new comment.';
$comment->user_id = Auth::user()->id;
$comment->save();
$comment->roles()->syncWithoutDetaching([
    Role::where('name', 'commenter')->first()->id
]);

Un code comme celui-ci nous permet d'utiliser des rôles pour contrôler qui peut effectuer quelles actions. Nous avons désormais besoin d'un moyen d'attribuer automatiquement les rôles appropriés aux nouveaux utilisateurs et à leurs publications et commentaires, et de supprimer automatiquement les attributions de rôles lorsque ces enregistrements sont supprimés.

2. Utilisez des écouteurs d'événements dans Laravel pour réaliser l'allocation et le recyclage automatiques des autorisations

Afin de réaliser l'allocation et le recyclage automatiques des autorisations, nous utilisons des écouteurs d'événements dans le système d'événements Laravel pour capturer les événements qui nous intéressent. Un écouteur d'événements est un mécanisme qui enregistre les fonctions de réponse aux événements spécifiques à l'application. Ce mécanisme nous permet de répondre de manière très flexible aux différents événements de l'application.

Par exemple, Laravel fournit des événements UserCreating et UserDeleting, qui sont automatiquement déclenchés lorsque des utilisateurs sont créés et supprimés. Nous pouvons écrire un écouteur d'événements pour créer la relation de rôle requise lorsque l'utilisateur est créé et supprimer cette relation lorsqu'elle est supprimée.

Tout d'abord, nous devons définir un nouvel écouteur d'événement :

class UserEventListener
{
    public function onUserCreating(UserCreating $event)
    {
        $user = $event->user;
        $roles = Role::where('name', 'user')->get();

        foreach ($roles as $role) {
            $user->roles()->create([
                'role_id' => $role->id,
            ]);
        }
    }

    public function onUserDeleting(UserDeleting $event)
    {
        $user = $event->user;
        $user->roles()->detach();
    }
}

Cet écouteur d'événement définit deux méthodes. Une méthode (onUserCreating) est automatiquement déclenchée lors de la création d'un utilisateur et attribue le rôle "Utilisateur" à l'utilisateur. Une autre méthode (onUserDeleting) se déclenche automatiquement lorsqu'un utilisateur supprime et supprime tous les enregistrements liés à ce rôle.

Ensuite, nous devons enregistrer ces écouteurs d'événements auprès de notre fournisseur de services d'application :

class AppServiceProvider extends ServiceProvider
{
    protected $listen = [
        UserCreating::class => [
            UserEventListener::class,
        ],

        UserDeleting::class => [
            UserEventListener::class,
        ],
    ];

    public function boot()
    {
        //
    }
}

Désormais, lorsque nous créons ou supprimons un utilisateur, les actions appropriées seront automatiquement effectuées. La dernière étape de l'installation du rôle consiste à définir un écouteur d'événement similaire pour les publications et les commentaires.

class ArticleEventListener
{
    public function onArticleCreating(ArticleCreating $event)
    {
        $article = $event->article;
        $roles = Role::where('name', 'author')->get();

        foreach ($roles as $role) {
            $article->roles()->create([
                'role_id' => $role->id,
            ]);
        }
    }

    public function onArticleDeleting(ArticleDeleting $event)
    {
        $article = $event->article;
        $article->roles()->detach();
    }
}

class CommentEventListener
{
    public function onCommentCreating(CommentCreating $event)
    {
        $comment = $event->comment;
        $roles = Role::where('name', 'commenter')->get();

        foreach ($roles as $role) {
            $comment->roles()->create([
                'role_id' => $role->id,
            ]);
        }
    }

    public function onCommentDeleting(CommentDeleting $event)
    {
        $comment = $event->comment;
        $comment->roles()->detach();
    }
}

Nous devons également enregistrer ces auditeurs en tant qu'événements correspondants dans le fournisseur de services :

class AppServiceProvider extends ServiceProvider
{
    protected $listen = [
        UserCreating::class => [
            UserEventListener::class,
        ],

        UserDeleting::class => [
            UserEventListener::class,
        ],

        ArticleCreating::class => [
            ArticleEventListener::class,
        ],

        ArticleDeleting::class => [
            ArticleEventListener::class,
        ],

        CommentCreating::class => [
            CommentEventListener::class,
        ],

        CommentDeleting::class => [
            CommentEventListener::class,
        ],
    ];

    public function boot()
    {
        //
    }
}

Maintenant, nous avons terminé toutes les étapes pour mettre en œuvre l'attribution et le recyclage automatiques des autorisations. Après cela, lorsque nous créons des utilisateurs, des articles ou des commentaires, les rôles correspondants seront automatiquement attribués. Lorsque ces enregistrements seront supprimés, nous les supprimerons automatiquement des rôles associés.

Résumé :

Dans cet article, nous avons présenté comment attribuer et recycler automatiquement les autorisations dans Laravel. Nous avons utilisé une fonctionnalité d'association polymorphe et des écouteurs d'événements pour associer les utilisateurs, les rôles, les publications et les commentaires et leur attribuer et recycler automatiquement des rôles. Dans le même temps, nous vous fournissons également des exemples de code détaillés pour vous aider à mieux comprendre la méthode de mise en œuvre de la gestion des autorisations dans 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!