Suggestions d'optimisation pour la fonction d'autorisation de Laravel : comment améliorer les performances et la vitesse de réponse de la vérification des autorisations

Laravel est un framework PHP puissant avec des capacités flexibles de gestion des autorisations qui peuvent assurer la sécurité des sites Web et des applications. Cependant, dans certains systèmes plus complexes, la vérification des autorisations peut devenir un goulot d'étranglement en termes de performances, affectant la vitesse de réponse du système et l'expérience utilisateur. Cet article vous présentera quelques méthodes pour optimiser la fonction de vérification des autorisations de Laravel afin d'améliorer les performances du système et la vitesse de réponse, et fournira des exemples de code spécifiques.

Optimisation 1 : Utiliser la mise en cache

Laravel fournit un mécanisme de mise en cache qui peut mettre en cache les résultats des opérations lentes afin que les données puissent être obtenues rapidement. Pour la fonction de vérification des autorisations, nous pouvons utiliser le mécanisme de mise en cache de Laravel pour mettre en cache les données d'autorisation, les informations utilisateur et d'autres données couramment utilisées afin d'améliorer la vitesse de vérification.

Exemple de code utilisant le mécanisme de cache Laravel pour la vérification des autorisations :

$userPermissions = Cache::remember('user_permissions_'.$userId, 3600, function() use($userId) {
    // 获取用户对应的权限信息
    return User::find($userId)->permissions;
});
if(in_array('admin', $userPermissions)){
    //用户拥有admin权限
}

Dans l'exemple ci-dessus, nous utilisons la méthode Cache::remember pour mettre en cache les données, où le premier paramètre est le nom de la clé de cache et le deuxième paramètre est le cache. délai d'expiration (ici fixé à 1 heure), le troisième paramètre est la fonction de rappel pour obtenir les données, si le cache n'existe pas, la fonction de rappel sera exécutée et écrite dans le cache.

L'utilisation du cache peut éviter les requêtes fréquentes de la base de données, améliorer la vitesse de réponse et optimiser efficacement la fonction de vérification des autorisations de Laravel.

Optimisation 2 : Utiliser des associations polymorphes

Les associations polymorphes peuvent associer différents types de modèles via un tableau. Les associations peuvent être ajoutées, supprimées et modifiées à tout moment selon les besoins, ce qui améliore la flexibilité et l'évolutivité du système. Dans la fonction de vérification des autorisations, nous pouvons utiliser des relations d'association polymorphes pour établir la relation entre les utilisateurs, les rôles et les autorisations, rendant ainsi la vérification plus intelligente et efficace.

Ce qui suit est un exemple de code d'utilisation de l'association polymorphe Laravel pour la vérification des autorisations :

1 Définissez le modèle :

<?php

namespace App;

use IlluminateDatabaseEloquentModel;

class User extends Model
{
    public function permissions()
    {
        return $this->morphToMany('AppPermission', 'permissionable');
    }
}

class Role extends Model
{
    public function permissions()
    {
        return $this->morphToMany('AppPermission', 'permissionable');
    }
}

class Permission extends Model
{
    public function users()
    {
        return $this->morphedByMany('AppUser', 'permissionable');
    }

    public function roles()
    {
        return $this->morphedByMany('AppRole', 'permissionable');
    }
}

2. Utilisez l'association polymorphe pour la vérification :

$user = User::find($userId);
$userPermissions = $user->permissions;

if($userPermissions->contains('name', 'admin')){
    //用户拥有admin权限
}

Dans l'exemple ci-dessus, nous avons défini trois modèles représentant les utilisateurs. , rôles et autorisations respectivement. Dans le modèle d'autorisation, nous utilisons la méthode morphedByMany pour établir des relations polymorphes afin que les utilisateurs et les rôles puissent être associés à des autorisations. Lorsque nous utilisons des associations polymorphes pour la vérification, nous pouvons accéder directement à l'attribut d'autorisations de l'utilisateur ou du rôle, obtenir l'intégralité de sa liste d'autorisations et porter des jugements si nécessaire.

Optimisation 3 : optimiser les instructions de requête

Laravel fournit un générateur de requêtes riche qui peut facilement effectuer des requêtes et des opérations de données. Cependant, si l'instruction de requête est mal conçue, cela entraînera une faible efficacité des requêtes et affectera la vitesse de réponse du système. . Dans la fonction de vérification des autorisations, nous pouvons améliorer l'efficacité des requêtes en optimisant les instructions de requête, améliorant ainsi les performances du système.

Ce qui suit est un exemple de code pour optimiser l'instruction de requête :

$user = User::find($userId);
//获取用户对应的所有角色
$rolesRawSql = "SELECT r.* FROM roles r, role_user ru WHERE r.id = ru.role_id AND ru.user_id = ?";
$userRoles = DB::select($rolesRawSql, [$user->id]);
$roleIds = collect($userRoles)->pluck('id')->toArray();

//获取所有角色对应的权限
$permissionsRawSql = "SELECT p.* FROM permissions p, permission_role pr WHERE p.id = pr.permission_id AND pr.role_id IN (".implode(',', array_fill(0, count($roleIds), '?')).")";
$rolePermissions = DB::select($permissionsRawSql, $roleIds);
$permissionNames = collect($rolePermissions)->pluck('name')->toArray();

if(in_array('admin', $permissionNames)){
    //用户拥有admin权限
}

Dans l'exemple ci-dessus, nous interrogeons les données via des instructions SQL natives. En particulier pour les données contenant des requêtes liées à plusieurs niveaux, vous pouvez éviter d'utiliser les requêtes fournies par Laravel. Générateur pour améliorer la vitesse des requêtes.

Optimisation 4 : utiliser le cache et l'association polymorphe pour combiner

La combinaison du cache et de l'association polymorphe peut optimiser davantage la fonction de vérification des autorisations et améliorer les performances du système et la vitesse de réponse. Nous pouvons mettre en cache les données d'autorisation et utiliser des relations polymorphes pour créer des associations entre les utilisateurs, les rôles et les autorisations afin d'obtenir une vérification efficace des autorisations.

Ce qui suit est un exemple de code d'utilisation du cache et de l'association polymorphe pour la vérification des autorisations :

1 Définissez le modèle d'autorisation :

<?php

namespace App;

use IlluminateDatabaseEloquentModel;

class Permission extends Model
{
    public function roles()
    {
        return $this->morphedByMany('AppRole', 'permissionable');
    }

    public function users()
    {
        return $this->morphedByMany('AppUser', 'permissionable');
    }

    /**
     * 获取缓存中的权限数据
     *
     * @return mixed
     */
    public static function allPermissions()
    {
        return Cache::rememberForever('permissions', function () {
            return Permission::all();
        });
    }
}

2 Utilisez le cache et l'association polymorphe pour la vérification :

$user = User::find($userId);
$userPermissions = $user->permissions;
$allPermissions = Permission::allPermissions();

foreach($userPermissions as $permission){
    if($allPermissions->contains('id', $permission->id) && $allPermissions->where('id', $permission->id)->first()->name === 'admin'){
        //用户拥有admin权限
    }
}

Dans l'exemple ci-dessus, nous avons défini un. Méthode allPermissions dans le modèle Permission pour obtenir les données d'autorisation dans le cache. Si le cache n'existe pas, elles sont obtenues à partir de la base de données et écrites dans le cache. Lors de la vérification des autorisations, nous pouvons d'abord obtenir la liste des autorisations de l'utilisateur, puis utiliser une boucle pour déterminer un par un si le nom de l'autorisation est admin. Si tel est le cas, cela signifie que l'utilisateur dispose des autorisations d'administrateur.

Résumé

Cet article présente quatre méthodes pour optimiser la fonction de vérification des autorisations de Laravel, notamment l'utilisation du cache, l'utilisation de relations polymorphes, l'optimisation des instructions de requête et l'utilisation combinée du cache et des relations polymorphes. Ces méthodes peuvent améliorer efficacement les performances et la vitesse de réponse du système, améliorant ainsi l'expérience utilisateur. Dans le développement réel, nous pouvons choisir des méthodes d'optimisation appropriées en fonction des besoins réels et des caractéristiques du système, et les mettre en œuvre avec des exemples de code spécifiques.

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!