Laravel-Installationsberechtigungsverwaltung

Laravel ist ein sehr beliebtes PHP-Entwicklungsframework. Es bietet viele praktische Tools und Komponenten, die die Entwicklungseffizienz erheblich verbessern können. Bei der Entwicklung von Anwendungen ist häufig eine Benutzerrechteverwaltung erforderlich. Laravel bietet eine sehr praktische Berechtigungsverwaltungsfunktion, mit deren Hilfe wir die Berechtigungskontrolle schnell und sicher implementieren können.

In diesem Artikel wird die Installation und Konfiguration der Laravel-Berechtigungsverwaltung unter folgenden Aspekten vorgestellt:

1. Installation von Laravel-Berechtigungsverwaltungskomponenten
2. Datenbankmigration
3. Benutzerauthentifizierung
4. Rollen- und Berechtigungsverwaltung
5. Middleware
6. Routenschutz

1. Installieren Sie die Laravel-Berechtigungsverwaltungskomponente

In Laravel können wir die Spatie/Laravel-Berechtigungskomponente über Composer installieren, um die Berechtigungsverwaltungsfunktion zu implementieren. Wir können den folgenden Befehl im Stammverzeichnis des Projekts ausführen, um diese Komponente zu installieren:

composer require spatie/laravel-permission

Nachdem die Installation abgeschlossen ist, müssen wir den Dienstanbieter dieser Komponente in der Datei config/app.php hinzufügen:

'providers' => [
    // ...
    SpatiePermissionPermissionServiceProvider::class,
],

At Gleichzeitig in derselben Datei die Fassade dieser Komponente hinzufügen in:

'aliases' => [
    // ...
    'Permission' => SpatiePermissionFacadesPermission::class,
    'Role' => SpatiePermissionFacadesRole::class,
],

2. Datenbankmigration

Nach der Installation der Komponente müssen wir die Datenbankmigration ausführen, um berechtigungsbezogene Tabellen zu erstellen. Wir können den Befehl artisan verwenden, um die Datenbankmigrationsdatei zu generieren:

php artisan make:migration create_permission_tables

Öffnen Sie dann die generierte Migrationsdatei und fügen Sie den folgenden Code hinzu:

class CreatePermissionTables extends Migration
{
    public function up()
    {
        Schema::create('permissions', function (Blueprint $table) {
            $table->increments('id');
            $table->string('name');
            $table->string('guard_name');
            $table->timestamps();
        });

        Schema::create('roles', function (Blueprint $table) {
            $table->increments('id');
            $table->string('name');
            $table->string('guard_name');
            $table->timestamps();
        });

        Schema::create('model_has_roles', function (Blueprint $table) {
            $table->integer('role_id')->unsigned();
            $table->morphs('model');
            $table->string('model_type')->nullable();
            $table->string('guard_name');
            $table->foreign('role_id')->references('id')->on('roles')
                  ->onDelete('cascade');
            $table->primary(['role_id', 'model_id', 'model_type']);
        });

        Schema::create('model_has_permissions', function (Blueprint $table) {
            $table->integer('permission_id')->unsigned();
            $table->morphs('model');
            $table->string('model_type')->nullable();
            $table->string('guard_name');
            $table->foreign('permission_id')->references('id')->on('permissions')
                  ->onDelete('cascade');
            $table->primary(['permission_id', 'model_id', 'model_type']);
        });

        Schema::create('role_has_permissions', function (Blueprint $table) {
            $table->integer('permission_id')->unsigned();
            $table->integer('role_id')->unsigned();
            $table->string('guard_name');
            $table->foreign('permission_id')->references('id')->on('permissions')
                  ->onDelete('cascade');
            $table->foreign('role_id')->references('id')->on('roles')
                  ->onDelete('cascade');
            $table->primary(['permission_id', 'role_id']);
        });
    }

    public function down()
    {
        Schema::dropIfExists('permissions');
        Schema::dropIfExists('roles');
        Schema::dropIfExists('model_has_roles');
        Schema::dropIfExists('model_has_permissions');
        Schema::dropIfExists('role_has_permissions');
    }
}

Dann können wir den Migrationsbefehl ausführen:

php artisan migrate

Auf diese Weise werden die zugehörigen Tabellen werden in der Datenbank erstellt.

3. Benutzerauthentifizierung

Als nächstes müssen wir die Benutzerauthentifizierungsfunktion in der Anwendung implementieren. Laravel hat uns ein sehr praktisches Benutzerauthentifizierungssystem zur Verfügung gestellt. Wir müssen nur den folgenden Befehl ausführen:

php artisan make:auth

Dieser Befehl generiert eine Seite mit Benutzeranmeldung, Registrierung, Passwortänderung und anderen Funktionen. Durch diese Vorgänge können wir Benutzer erstellen und verwalten.

4. Rollen- und Berechtigungsverwaltung

Bei der Laravel-Berechtigungsverwaltung sind Rollen und Berechtigungen sehr wichtige Konzepte. Wir können Benutzerzugriffskontrollregeln über Rollen und Berechtigungen definieren.

1. Rollen erstellen

Wir können die Rollenfassade verwenden, um Rollen zu erstellen. Zum Beispiel:

use SpatiePermissionModelsRole;

$role = Role::create(['name' => 'admin']);

Der obige Code erstellt eine Rolle mit dem Namen „admin“.

2. Berechtigungen erstellen

Ähnlich können wir die Berechtigungsfassade verwenden, um Berechtigungen zu erstellen:

use SpatiePermissionModelsPermission;

$permission = Permission::create(['name' => 'create posts']);

Der obige Code erstellt eine Berechtigung namens „Beiträge erstellen“.

3. Berechtigungen für Rollen erteilen

Da wir nun über Rollen und Berechtigungen verfügen, müssen wir auch Rollen Berechtigungen erteilen. Wir können dies mit der Methode „givePermissionTo“ der Rolle tun:

$role = Role::findByName('admin');
$permission = Permission::findByName('create posts');
$role->givePermissionTo($permission);

4. Überprüfen Sie, ob der Benutzer über die Berechtigungen verfügt

Nachdem wir nun die Rolle und Berechtigungen definiert haben, können wir die von der Laravel-Berechtigungsverwaltung bereitgestellte Methode „can“ verwenden, um zu überprüfen, ob Der Benutzer hat die Berechtigungen. Zum Beispiel:

$user->can('create posts');

Der obige Code gibt einen booleschen Wert zurück, der angibt, ob der aktuelle Benutzer über die Berechtigung „Beiträge erstellen“ verfügt.

5. Überprüfen Sie, ob der Benutzer eine Rolle hat

Ebenso können wir auch die Methode hasRole verwenden, um zu überprüfen, ob der Benutzer eine bestimmte Rolle hat. Zum Beispiel:

$user->hasRole('admin');

Der obige Code gibt einen booleschen Wert zurück, der angibt, ob der aktuelle Benutzer die Rolle „Administrator“ hat.

5. Middleware

Wir können die Middleware von Laravel verwenden, um unsere Routen und Controller zu schützen und eine Berechtigungskontrolle zu erreichen. Hier ist der Beispielcode:

Route::group([
    'middleware' => ['role:admin'],
], function () {
    Route::get('/admin', function () {
        //
    });
});

Route::group([
    'middleware' => ['permission:create posts'],
], function () {
    Route::get('/new-post', function () {
        //
    });
});

Der obige Code schützt die Routen „/admin“ und „/new-post“ und ermöglicht den Zugriff nur Benutzern mit der Rolle „admin“ und der Berechtigung „Beiträge erstellen“.

6. Routenschutz

Schließlich müssen wir unsere Routen und Controller schützen. Um dies zu erreichen, können wir die Methoden „can“ und „authorise“ verwenden.

public function store(Request $request)
{
    $this->authorize('create', Post::class);

    // ...
}

public function edit(Request $request, Post $post)
{
    if (! $request->user()->can('edit', $post)) {
        abort(403);
    }

    // ...
}

Der obige Code schützt die Speicher- und Bearbeitungsmethoden und ermöglicht den Zugriff nur Benutzern mit den Berechtigungen „Erstellen“ und „Bearbeiten“.

Zusammenfassung

Im Allgemeinen ist die Berechtigungsverwaltung von Laravel sehr bequem und sicher. Wir können die Berechtigungskontrolle implementieren, indem wir die Komponente spatie/laravel-permission installieren und die vielen von Laravel bereitgestellten Methoden und Funktionen verwenden, um Rollen und Berechtigungen zu verwalten. Durch Middleware und Routenschutz können wir unsere Anwendungen einfach schützen und den Benutzerzugriff einschränken.

Das obige ist der detaillierte Inhalt vonLaravel-Installationsberechtigungsverwaltung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!