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 '規(guī)則',
    `title` VARCHAR(100) NOT NULL COMMENT '規(guī)則名稱',
    `type` TINYINT(1) UNSIGNED NOT NULL DEFAULT '1' COMMENT '規(guī)則類型',
    `status` TINYINT(1) UNSIGNED NOT NULL DEFAULT '1' COMMENT '狀態(tài)',
    `condition` TEXT COMMENT '規(guī)則表達式',
    PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='權(quán)限規(guī)則表';

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 '狀態(tài)',
    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.

// 授權(quán)驗證
use thinkacadeSession;
use thinkacadeRequest;
use thinkacadeConfig;
use thinkacadeDb;
use thinkuthAuth;

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

        // 如果用戶未登錄，則跳轉(zhuǎn)到登錄頁面
        if (!Session::has('user')) {
            $this->redirect('/login');
        }

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

        // 如果是超級管理員，則直接通過權(quán)限驗證
        if ($uid == Config::get('admin_id')) {
            return true;
        }

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

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!