So implementieren Sie die automatische Zuweisung und Wiederverwendung von Berechtigungen in Laravel

Laravel ist ein weit verbreitetes PHP-Framework, das praktische Tools zur Implementierung häufiger Probleme wie der Berechtigungsverwaltung bereitstellt. In vielen Anwendungen ist eine differenzierte Kontrolle der Benutzerberechtigungen erforderlich, um sicherzustellen, dass sie nur Zugriff auf das haben, worauf sie zugreifen müssen. In diesem Artikel erfahren Sie, wie Sie Berechtigungen in Laravel automatisch zuweisen und widerrufen. Gleichzeitig stellen wir auch konkrete Codebeispiele zur Verfügung.

1. Verwenden Sie die polymorphe Assoziation in Laravel, um die automatische Zuweisung und Wiederverwendung von Berechtigungen zu realisieren.

Laravels Eloquent ORM bietet die Funktion der polymorphen Assoziation, was bedeutet, dass wir mehrere verschiedene Modelle mit demselben Datensatz verknüpfen können. Dies ist sehr nützlich für die automatische Zuweisung und Wiederverwendung von Berechtigungen.

Angenommen, wir müssen die Berechtigungen für „Artikel“ und „Kommentare“ in unserer Anwendung steuern und Benutzern Rollen zuweisen. Wir können die folgenden vier Modelle erstellen:

• User (Benutzer)
• Article (Artikel)
• Comment (Kommentar)
• Role (Rolle)

Dann können wir die polymorphe Assoziationsfunktion verwenden, um die drei Modelle zu kombinieren Assoziation mit Rollen:

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

Dieses Beispiel verwendet die polymorphe Assoziationsfunktion von Laravel, die es uns ermöglicht, Rollenbeziehungen für drei Modelle und ihre Datensätze zu definieren. Der nächste Schritt besteht darin, eine Zwischentabelle zu erstellen, um diese Beziehungen zu speichern:

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

Jetzt können wir das obige Modell mit der entsprechenden Rolle verknüpfen. Angenommen, wir hätten dem Ersteller des Beitrags beispielsweise die Rolle „Autor“ zugewiesen, könnten wir Folgendes tun:

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

Ähnlich könnten wir Folgendes tun, indem wir einen neuen Kommentar erstellen und dem Ersteller dieses Kommentars die Rolle „Kommentator“ zuweisen :

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

Code wie dieser ermöglicht es uns, mithilfe von Rollen zu steuern, wer welche Aktionen ausführen kann. Jetzt benötigen wir eine Möglichkeit, neuen Benutzern und ihren Beiträgen und Kommentaren automatisch entsprechende Rollen zuzuweisen und die Rollenzuweisungen automatisch zu entfernen, wenn diese Datensätze gelöscht werden.

2. Verwenden Sie Ereignis-Listener in Laravel, um die automatische Zuweisung und Wiederverwendung von Berechtigungen zu realisieren.

Um die automatische Zuweisung und Wiederverwendung von Berechtigungen zu realisieren, verwenden wir Ereignis-Listener im Laravel-Ereignissystem, um die Ereignisse zu erfassen, an denen wir interessiert sind. Ein Event-Listener ist ein Mechanismus, der anwendungsspezifische Ereignisantwortfunktionen registriert. Dieser Mechanismus ermöglicht es uns, sehr flexibel auf verschiedene Ereignisse in der Anwendung zu reagieren.

Laravel bietet beispielsweise UserCreating- und UserDeleting-Ereignisse, die automatisch ausgelöst werden, wenn Benutzer erstellt und gelöscht werden. Wir können einen Ereignis-Listener schreiben, um die erforderliche Rollenbeziehung zu erstellen, wenn der Benutzer erstellt wird, und diese Beziehung zu löschen, wenn sie gelöscht wird.

Zuerst müssen wir einen neuen Ereignis-Listener definieren:

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

Dieser Ereignis-Listener definiert zwei Methoden. Eine Methode (onUserCreating) wird beim Anlegen eines Benutzers automatisch ausgelöst und weist dem Benutzer die Rolle „Benutzer“ zu. Eine andere Methode (onUserDeleting) wird automatisch ausgelöst, wenn ein Benutzer alle mit dieser Rolle verbundenen Datensätze löscht.

Als nächstes müssen wir diese Ereignis-Listener bei unserem Anwendungsdienstanbieter registrieren:

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

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

    public function boot()
    {
        //
    }
}

Wenn wir nun einen Benutzer erstellen oder löschen, werden die entsprechenden Aktionen automatisch ausgeführt. Der letzte Schritt bei der Installation der Rolle besteht darin, einen ähnlichen Ereignis-Listener für Beiträge und Kommentare zu definieren.

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

Wir müssen diese Listener auch als entsprechende Ereignisse im Dienstanbieter registrieren:

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()
    {
        //
    }
}

Jetzt haben wir alle Schritte abgeschlossen, um die automatische Zuweisung und Wiederverwendung von Berechtigungen zu implementieren. Wenn wir anschließend Benutzer, Artikel oder Kommentare erstellen, werden die entsprechenden Rollen automatisch zugewiesen. Wenn diese Datensätze gelöscht werden, werden wir sie automatisch aus den zugehörigen Rollen entfernen.

Zusammenfassung:

In diesem Artikel haben wir vorgestellt, wie Berechtigungen in Laravel automatisch zugewiesen und wiederverwendet werden. Wir haben polymorphe Assoziationsfunktionen und Ereignis-Listener verwendet, um Benutzer, Rollen, Beiträge und Kommentare miteinander zu verknüpfen und ihnen automatisch Rollen zuzuweisen und wiederzuverwenden. Gleichzeitig stellen wir Ihnen auch detaillierte Codebeispiele zur Verfügung, damit Sie besser verstehen, wie Sie die Berechtigungsverwaltung in Laravel implementieren.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die automatische Zuweisung und Wiederverwendung von Berechtigungen in Laravel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!