Optimisation des performances pour le projet d'autorisation Laravel

Cet article présente principalement l'optimisation des performances du projet Laravel-permission, qui a une certaine valeur de référence. Maintenant, je le partage avec tout le monde. Les amis dans le besoin peuvent s'y référer

<.>J'ai récemment étudié et analysé les performances des projets créés sur SWIS. Étonnamment, l’une des méthodes les plus gourmandes en performances est due à l’excellent package

. spatie/laravel-permission

Après avoir examiné plus d'informations et de recherches, j'ai découvert un problème de performances qui pourrait être considérablement amélioré. Maintenant que la solution est clairement énoncée, il est facile de coder des améliorations et de soumettre des demandes d'extraction.

Maintenant que cette solution a été fusionnée et publiée, voici une analyse de ce problème de performances et comment éviter de tels problèmes dans vos propres projets.

TL;DR : passez à la partie conclusion.

Glouton d'étranglement des performances

Si nous le regardons de manière abstraite

cela fait principalement deux choses : spatie/laravel-permission

1. Conserver une liste des autorisations appartenant à un modèle.

2. Vérifiez si un modèle dispose d'autorisations.

Le premier point est un peu exagéré de dire qu'il s'agit d'un goulot d'étranglement en termes de performances. Les données d'autorisation ici sont stockées dans la base de données et seront lues en cas de besoin. Ce processus est un peu lent mais n'est effectué qu'une seule fois. Les résultats seront mis en cache et pourront être utilisés directement dans les requêtes ultérieures.

Le deuxième point est effectivement un goulot d'étranglement du point de vue du goulot d'étranglement des performances. Ce goulot d'étranglement dépend de la nature des autorisations et de la taille du projet, puisque les autorisations seront vérifiées fréquemment. Toute lenteur lors de cette vérification deviendra un goulot d'étranglement des performances pour l'ensemble du projet.

Filtrage des classes de collection

La méthode de filtrage des collections d'autorisations est considérée comme la cause des faibles performances. Il fait ce qui suit :

$permission = $permissions
    ->where('id', $id)
    ->where('guard_name', $guardName)
    ->first();

Après modification :

$permission = $permissions
    ->filter(function ($permission) use ($id, $guardName) {
        return $permission->id === $id && $permission->guard_name === $guardName;
    })
    ->first();

Ces deux extraits de code réalisent la même chose, mais le second est plus rapide.

Tests de performances

Il existe environ 150 autorisations différentes dans l'application que je développe. Dans une requête normale, environ 50 autorisations doivent être vérifiées à l'aide de la méthode

. Bien entendu, certaines pages peuvent devoir vérifier environ 200 autorisations. hasPermissionTo

Voici quelques paramètres utilisés pour les tests de performances.

$users = factory(User::class, 150)->make();
$searchForTheseUsers = $users->shuffle()->take(50);

# 方法 1: where
foreach($searchForTheseUsers as $user) {
    $result = $users->where('id', '=', $user->id)->first();
}

# 方法 2: 过滤，传递一个模型作为回调
foreach($searchForTheseUsers as $searchUser) {
    $result = $users->filter(function($user) use ($searchUser) {
        return $user->id === $searchUser->id;
    })->first();
}

# 方法 3: 过滤，传递属性作为回调
foreach($searchForTheseUsers as $user) {
    $searchId = $user->id;
    $result = $users->filter(function($user) use ($searchId) {
        return $user->id === $searchId;
    })->first();
}

Les trois méthodes ci-dessus seront utilisées pour tester le filtrage de 1 attribut, 2 attributs et 3 attributs. Par conséquent, l'utilisation de la méthode 1 pour filtrer trois attributs ressemblera à ceci :

<. 🎜>Résultats

foreach($searchForTheseUsers as $user) {
    $result = $users
        ->where('id', '=', $user->id)
        ->where('firstname', '=', $user->firstname)
        ->where('lastname', '=', $user->lastname)->first();
}

Conclusion

	方法 #1	方法 #2	方法 #3
1个属性	0.190	0.139 (-27%)	0.072 (-62%)
2个属性	0.499	0.372 (-25%)	0.196 (-61%)
3个属性	0.488	0.603 (+25%)	0.198 (-59%)

Nous pouvons conclure que pour un projet, filtrer à plusieurs reprises une grande collection entraînera de sérieux goulots d'étranglement en termes de performances.

Le filtrage multi-attributs augmente considérablement le coût de calcul.

L'utilisation de

au lieu de

peut améliorer les performances de 60 %. Collection::filter()Collection::where()Attention : Passer le modèle complet au rappel du filtre est très gourmand en performances, il est préférable de passer des attributs individuels.

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'étude de chacun. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois !

Recommandations associées :

Utilisation de la requête de base de données coroutine de Swoole dans Laravel 5.6

Analyse du système d'apparence de façade de Laravel

Laravel+Redis implémente simplement un traitement à haute concurrence des files d'attente qui réussit le test de résistance

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!