Comment utiliser l'autorisation d'authentification de ThinkPHP6

ThinkPHP6 est un excellent framework PHP qui nous fournit de nombreux outils et fonctions efficaces. Parmi eux, l'autorisation Auth est une fonction très puissante qui peut nous aider à gérer les autorisations dans les applications. Cet article explique comment utiliser l'autorisation d'authentification de ThinkPHP6.

1. Installez le composant Auth

Tout d'abord, nous devons installer le composant Auth. Exécutez la commande suivante dans le terminal :

composer require topthink/think-auth

Une fois l'installation terminée, nous devons ajouter le fournisseur de services Auth dans le fichier de configuration :

// config/app.php

return [
    // ...
    'providers' => [
        // ...
        thinkuthServiceProvider::class,
    ],
];

Ensuite, nous devons exécuter la commande suivante pour générer le fichier de configuration Auth :

php think auth:config

2. Configurez le composant Auth

Le composant Auth peut être configuré pour répondre à différents besoins de gestion des autorisations :

// config/auth.php

return [
    'auth_on' => true,
    'auth_type' => 1,
    'auth_group' => 'auth_group',
    'auth_group_access' => 'auth_group_access',
    'auth_rule' => 'auth_rule',
    'auth_user' => 'user',
];

• auth_on : s'il faut activer l'authentification des autorisations, true pour activer, false pour fermer ;
auth_type : méthode d'authentification, 1 est l'authentification en temps réel (c'est-à-dire que les autorisations sont réacquises à chaque fois que les autorisations sont vérifiées), 2 est l'authentification de connexion (c'est-à-dire que les autorisations sont vérifiées après la connexion de l'utilisateur
• auth_group) ; : nom de la table de données du groupe d'utilisateurs
• auth_group_access : nom de la table d'association détaillée du groupe d'utilisateurs
• auth_rule : table des règles d'autorisation
• auth_user : table d'informations sur l'utilisateur ;

Créer des règles d'autorisation

Avant d'utiliser l'autorisation Auth, nous devons d'abord créer des règles d'autorisation. Les règles d'autorisation peuvent contrôler l'accès des utilisateurs à différentes ressources. Nous devons créer une table auth_rule dans la base de données, puis créer des règles d'autorisation en ajoutant des enregistrements.

// appmodelAuthRule.php

namespace appmodel;

use thinkModel;

class AuthRule extends Model
{
    //
}

Ensuite, nous devons créer la table auth_rule dans la base de données :

CREATE TABLE `auth_rule` (
    `id` INT NOT NULL AUTO_INCREMENT,
    `name` VARCHAR(100) NOT NULL COMMENT '规则',
    `title` VARCHAR(100) NOT NULL COMMENT '规则名称',
    `type` TINYINT(1) UNSIGNED NOT NULL DEFAULT '1' COMMENT '规则类型',
    `status` TINYINT(1) UNSIGNED NOT NULL DEFAULT '1' COMMENT '状态',
    `condition` TEXT COMMENT '规则表达式',
    PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='权限规则表';

Ensuite, nous pouvons ajouter des règles d'autorisation en :

use appmodelAuthRule;

$rule = new AuthRule;
$rule->name = 'admin/user/index';
$rule->title = '管理用户';
$rule->save();

$rule = new AuthRule;
$rule->name = 'admin/user/add';
$rule->title = '添加用户';
$rule->save();

$rule = new AuthRule;
$rule->name = 'admin/user/edit';
$rule->title = '编辑用户';
$rule->save();

$rule = new AuthRule;
$rule->name = 'admin/user/del';
$rule->title = '删除用户';
$rule->save();

Créer un groupe d'utilisateurs

En plus des règles d'autorisation, nous devons également créer Groupe d'utilisateurs. Un groupe d'utilisateurs est un ensemble d'utilisateurs disposant des mêmes droits d'accès. Nous devons créer une table auth_group dans la base de données, puis créer des groupes d'utilisateurs en ajoutant des enregistrements.

// appmodelAuthGroup.php

namespace appmodel;

use thinkModel;

class AuthGroup extends Model
{
    //
}

Ensuite, nous devons créer la table auth_group dans la base de données :

CREATE TABLE `auth_group` (
    `id` INT NOT NULL AUTO_INCREMENT,
    `title` VARCHAR(100) NOT NULL COMMENT '组名',
    `status` TINYINT(1) UNSIGNED NOT NULL DEFAULT '1' COMMENT '状态',
    PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='用户组表';

Ensuite, nous pouvons ajouter des groupes d'utilisateurs en :

use appmodelAuthGroup;

$group = new AuthGroup;
$group->title = '管理员';
$group->save();

$group = new AuthGroup;
$group->title = '普通用户';
$group->save();

Créer les détails du groupe d'utilisateurs

Maintenant, nous avons créé des règles d'autorisation et des utilisateurs. groupes. Ensuite, nous devons attribuer les règles aux groupes d'utilisateurs. Nous devons créer une table auth_group_access dans la base de données, puis créer les détails du groupe d'utilisateurs en ajoutant des enregistrements.

// appmodelAuthGroupAccess.php

namespace appmodel;

use thinkModel;

class AuthGroupAccess extends Model
{
    //
}

Ensuite, nous devons créer la table auth_group_access dans la base de données :

CREATE TABLE `auth_group_access` (
    `uid` INT NOT NULL COMMENT '用户id',
    `group_id` INT NOT NULL COMMENT '用户组id',
    UNIQUE KEY `uid_group_id` (`uid`, `group_id`),
    KEY `uid` (`uid`),
    KEY `group_id` (`group_id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4 COMMENT='用户组明细表';

Nous pouvons ensuite attribuer des règles d'autorisation aux groupes d'utilisateurs via :

use appmodelAuthGroupAccess;

$access = new AuthGroupAccess;
$access->uid = 1;
$access->group_id = 1;
$access->save();

$access = new AuthGroupAccess;
$access->uid = 2;
$access->group_id = 2;
$access->save();

$access = new AuthGroupAccess;
$access->uid = 3;
$access->group_id = 2;
$access->save();

Autorisation via Auth

Maintenant, nous avons créé des règles d'autorisation et des utilisateurs. groupes et des règles attribuées aux groupes d'utilisateurs. Ensuite, nous pouvons utiliser l'autorisation Auth pour vérifier si l'utilisateur dispose de droits d'accès.

// 授权验证
use thinkacadeSession;
use thinkacadeRequest;
use thinkacadeConfig;
use thinkacadeDb;
use thinkuthAuth;

class BaseController extends Controller
{
    protected function initialize()
    {
        parent::initialize();

        // 如果用户未登录，则跳转到登录页面
        if (!Session::has('user')) {
            $this->redirect('/login');
        }

        $uid = Session::get('user.id');

        // 如果是超级管理员，则直接通过权限验证
        if ($uid == Config::get('admin_id')) {
            return true;
        }

        $auth = new Auth;
        $route = strtolower(Request::controller() . '/' . Request::action());
        if (!$auth->check($route, $uid)) {
            $this->error('无权限');
        }
    }
}

Tout d'abord, nous devons obtenir les informations de connexion de l'utilisateur de la session. Si l'utilisateur n'est pas connecté, accédez à la page de connexion.

Ensuite, nous obtenons l'uid de l'utilisateur actuel. Si l'utilisateur actuel est un super administrateur, la vérification des autorisations sera transmise directement.

Sinon, nous créons une instance Auth et obtenons la route pour la requête en cours. Ensuite, nous utilisons la méthode Auth check pour vérifier si l'utilisateur actuel dispose de droits d'accès. Sinon, une erreur d'absence d'autorisation est générée.

Résumé

Dans cet article, nous avons appris comment utiliser l'autorisation Auth dans ThinkPHP6. Nous utilisons le composant Auth pour implémenter la gestion des autorisations et créer des règles d'autorisation et des groupes d'utilisateurs. Enfin, nous utilisons l'autorisation Auth pour vérifier que l'utilisateur dispose des droits d'accès. Si vous avez besoin de fonctions de gestion des autorisations plus avancées, vous pouvez y parvenir en étendant le composant Auth.

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!