So verwenden Sie das Hyperf-Framework zur Berechtigungskontrolle

So verwenden Sie das Hyperf-Framework zur Berechtigungssteuerung

Einführung:
Bei der Entwicklung einer Anwendung ist es häufig erforderlich, Berechtigungssteuerungsfunktionen zu implementieren, um Benutzern unterschiedliche Berechtigungen in verschiedenen Rollen zu erteilen. Das Hyperf-Framework ist ein leistungsstarkes PHP-Microservices-Framework, das viele leistungsstarke Funktionen und Erweiterungen bietet, einschließlich einer flexiblen Berechtigungssteuerung. In diesem Artikel untersuchen wir, wie das Hyperf-Framework zum Implementieren der Berechtigungskontrolle verwendet wird, und stellen spezifische Codebeispiele bereit.

1. Erstellen Sie eine Berechtigungstabelle
Zuerst müssen wir eine Berechtigungstabelle erstellen, um verschiedene Berechtigungsinformationen zu speichern. Datenbanktabellen können über die Datenmigrationsfunktion von Hyperf erstellt werden. Führen Sie den folgenden Befehl im Terminal aus, um die Migrationsdatei zu generieren:

php bin/hyperf.php gen:migration create_permissions_table

Fügen Sie dann den folgenden Inhalt in die generierte Migrationsdatei ein:

<?php

use HyperfDatabaseSchemaSchema;
use HyperfDatabaseSchemaBlueprint;
use HyperfDatabaseMigrationsMigration;
use HyperfDbConnectionDb;

class CreatetPermissionsTable extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        $tableName = 'permissions';
        $exists = Db::table('information_schema.TABLES')
            ->where('TABLE_SCHEMA', config('databases.default.dbname'))
            ->where('TABLE_NAME', $tableName)
            ->first();

        if (!$exists) {
            Schema::create($tableName, function (Blueprint $table) {
                $table->bigIncrements('id');
                $table->string('name')->unique()->comment('权限名称');
                $table->string('guard_name')->default('web')->comment('守卫名称');
                $table->timestamps();
            });
        }
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('permissions');
    }
}

Als nächstes müssen wir die Hauptkonfigurationsdatei des Projekts config/autoload/ hinzufügen. Berechtigungen.php Fügen Sie den folgenden Inhalt hinzu: <code>config/autoload/permissions.php中添加以下内容：

<?php

return [
    'default' => [
        'guard_name' => 'web',
        'permissions' => [
            // 在这里添加你的权限
            'create_post',
            'edit_post',
            'delete_post',
            // ...
        ],
    ],
];

然后在命令行中运行以下命令执行数据库迁移：

php bin/hyperf.php migrate

二、定义用户角色模型
在Hyperf框架中，我们需要定义一个用户模型，该模型用于管理用户的角色和权限。我们可以通过继承HyperfDatabaseModelModel类来创建一个用户模型。在终端中执行以下命令来生成用户模型：

php bin/hyperf.php gen:model User

然后在生成的用户模型文件中添加以下代码：

namespace AppModel;

use HyperfDbConnectionModelModel;
use HyperfUtilsApplicationContext;

class User extends Model
{
    protected $guarded = [];

    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }

    public function hasPermission($permission)
    {
        foreach ($this->roles as $role) {
            if ($role->hasPermission($permission)) {
                return true;
            }
        }
        return false;
    }

    public function givePermission($permission)
    {
        $permissionModel = Permission::where('name', $permission)->first();
        if (!$permissionModel) {
            throw new Exception("Permission {$permission} does not exist.");
        }
        $this->permissions()->sync($permissionModel, false);
    }

    public function revokePermission($permission)
    {
        $permissionModel = Permission::where('name', $permission)->first();
        if (!$permissionModel) {
            throw new Exception("Permission {$permission} does not exist.");
        }
        $this->permissions()->detach($permissionModel);
    }

    public function permissions()
    {
        return $this->belongsToMany(Permission::class, 'user_permissions');
    }
}

三、定义角色模型
在Hyperf框架中，我们也需要定义一个角色模型，该模型用于管理角色和权限。同样，我们可以通过继承HyperfDatabaseModelModel类来创建一个角色模型。在终端中执行以下命令来生成角色模型：

php bin/hyperf.php gen:model Role

然后在生成的角色模型文件中添加以下代码：

namespace AppModel;

use HyperfDbConnectionModelModel;

class Role extends Model
{
    protected $guarded = [];

    public function users()
    {
        return $this->belongsToMany(User::class);
    }

    public function permissions()
    {
        return $this->belongsToMany(Permission::class);
    }

    public function hasPermission($permission)
    {
        return $this->permissions->contains('name', $permission);
    }

    public function givePermission($permission)
    {
        $permissionModel = Permission::where('name', $permission)->first();
        if (!$permissionModel) {
            throw new Exception("Permission {$permission} does not exist.");
        }
        $this->permissions()->sync($permissionModel, false);
    }

    public function revokePermission($permission)
    {
        $permissionModel = Permission::where('name', $permission)->first();
        if (!$permissionModel) {
            throw new Exception("Permission {$permission} does not exist.");
        }
        $this->permissions()->detach($permissionModel);
    }
}

四、定义权限模型
在Hyperf框架中，我们还需要定义一个权限模型，该模型用于管理权限信息。同样地，我们可以通过继承HyperfDatabaseModelModel类来创建一个权限模型。在终端中执行以下命令来生成权限模型：

php bin/hyperf.php gen:model Permission

然后在生成的权限模型文件中添加以下代码：

namespace AppModel;

use HyperfDbConnectionModelModel;

class Permission extends Model
{
    protected $guarded = [];

    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}

五、定义权限中间件
接下来，我们需要创建一个权限中间件，用于检查用户是否有足够的权限访问某个路由。在终端中执行以下命令来生成中间件：

php bin/hyperf.php gen:middleware PermissionMiddleware

然后在生成的中间件文件中添加以下代码：

namespace AppMiddleware;

use HyperfHttpMessageStreamSwooleStream;
use HyperfHttpServerContractRequestInterface;
use HyperfUtilsContext;
use PsrContainerContainerInterface;
use PsrHttpMessageResponseInterface;
use PsrHttpServerMiddlewareInterface;
use PsrHttpServerRequestHandlerInterface;

class PermissionMiddleware implements MiddlewareInterface
{
    protected $container;

    protected $request;

    public function __construct(ContainerInterface $container, RequestInterface $request)
    {
        $this->container = $container;
        $this->request = $request;
    }

    public function process($request, RequestHandlerInterface $handler): ResponseInterface
    {
        $user = $this->request->getAttribute('user');
        $permissions = $this->request->route->permission;

        if ($user && $user->hasPermission($permissions)) {
            return $handler->handle($request);
        }

        return $this->response(403, 'Forbidden');
    }

    protected function response($code, $message)
    {
        $data = [
            'code' => $code,
            'message' => $message,
        ];

        return Context::get(ResponseInterface::class)->withBody(new SwooleStream(json_encode($data)));
    }
}

六、使用权限中间件
在路由定义中，我们可以通过使用->middleware('permission:xxx')

php bin/hyperf.php gen:controller PermissionController

Führen Sie dann den folgenden Befehl in der Befehlszeile aus, um die Datenbankmigration durchzuführen:

namespace AppController;

use AppMiddlewarePermissionMiddleware;
use HyperfHttpServerAnnotationController;
use HyperfHttpServerAnnotationMiddleware;
use HyperfHttpServerAnnotationRequestMapping;

/**
 * @Controller
 * @Middleware(PermissionMiddleware::class)
 */
class PermissionController
{
    /**
     * @RequestMapping(path="/permission", methods="get")
     * @Middleware("permission:create_post")
     */
    public function createPost()
    {
        // 处理创建文章的逻辑
    }

    /**
     * @RequestMapping(path="/permission", methods="get")
     * @Middleware("permission:edit_post")
     */
    public function editPost()
    {
        // 处理编辑文章的逻辑
    }

    /**
     * @RequestMapping(path="/permission", methods="get")
     * @Middleware("permission:delete_post")
     */
    public function deletePost()
    {
        // 处理删除文章的逻辑
    }
}

2. Definieren Sie das Benutzerrollenmodell

Im Hyperf-Framework müssen wir a definieren Benutzermodell, das zur Verwaltung von Benutzerrollen und -berechtigungen verwendet wird. Wir können ein Benutzermodell erstellen, indem wir die Klasse HyperfDatabaseModelModel erben. Führen Sie den folgenden Befehl im Terminal aus, um das Benutzermodell zu generieren:

$user = User::find(1);

if ($user->hasPermission('edit_post')) {
    // 给用户权限来编辑文章
} else {
    // 权限不足
}

Fügen Sie dann den folgenden Code in die generierte Benutzermodelldatei ein:

rrreee
3. Definieren Sie das Rollenmodell

Im Hyperf-Framework müssen wir auch eine Rolle definieren Modell. Wird zum Verwalten von Rollen und Berechtigungen verwendet. Ebenso können wir ein Rollenmodell erstellen, indem wir die Klasse HyperfDatabaseModelModel erben. Führen Sie im Terminal den folgenden Befehl aus, um das Rollenmodell zu generieren: 🎜rrreee🎜 Fügen Sie dann den folgenden Code in die generierte Rollenmodelldatei ein: 🎜rrreee🎜 4. Definieren Sie das Berechtigungsmodell 🎜 Im Hyperf-Framework müssen wir auch eine Berechtigung definieren Modell. Wird zum Verwalten von Berechtigungsinformationen verwendet. Ebenso können wir ein Berechtigungsmodell erstellen, indem wir die Klasse HyperfDatabaseModelModel erben. Führen Sie den folgenden Befehl im Terminal aus, um das Berechtigungsmodell zu generieren: 🎜rrreee🎜 Fügen Sie dann den folgenden Code in die generierte Berechtigungsmodelldatei ein: 🎜rrreee🎜 5. Berechtigungs-Middleware definieren 🎜 Als nächstes müssen wir eine Berechtigungs-Middleware erstellen, um zu überprüfen, ob die Der Benutzer verfügt über ausreichende Berechtigungen, um auf eine bestimmte Route zuzugreifen. Führen Sie den folgenden Befehl im Terminal aus, um die Middleware zu generieren: 🎜rrreee🎜 Fügen Sie dann den folgenden Code in die generierte Middleware-Datei ein: 🎜rrreee🎜 6. Berechtigungs-Middleware verwenden 🎜 In der Routendefinition können wir -&gt ;middleware verwenden ('permission:xxx'), um die entsprechende Berechtigungs-Middleware für das Routing festzulegen. Führen Sie den folgenden Befehl im Terminal aus, um die Routing-Datei zu generieren: 🎜rrreee🎜 Fügen Sie dann den folgenden Code in die generierte Routing-Datei ein: 🎜rrreee🎜 7. Anwendungsbeispiele 🎜 Wo eine Berechtigungskontrolle erforderlich ist, können wir überprüfen, ob sich der Benutzer im befindet Gehen Sie wie folgt vor: Sie verfügen über ausreichende Berechtigungen: 🎜rrreee🎜 8. Zusammenfassung🎜In diesem Artikel werden die detaillierten Schritte zur Verwendung des Hyperf-Frameworks zur Berechtigungssteuerung vorgestellt und spezifische Codebeispiele bereitgestellt. Mithilfe der vom Hyperf-Framework bereitgestellten Berechtigungsverwaltungsfunktionen können wir problemlos flexible Berechtigungskontrollfunktionen für unsere Anwendungen implementieren. Ich hoffe, dieser Artikel ist hilfreich für Sie, vielen Dank fürs Lesen! 🎜

Das obige ist der detaillierte Inhalt vonSo verwenden Sie das Hyperf-Framework zur Berechtigungskontrolle. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!