Performance optimization for Laravel-permission project

This article mainly introduces the performance optimization of the Laravel-permission project, which has certain reference value. Now I share it with you. Friends in need can refer to it

I recently studied and analyzed the performance of projects created on SWIS. Surprisingly, one of the most performance-consuming methods is caused by the excellent spatie/laravel-permission package.

After reviewing more information and research, I discovered a performance issue that may be significantly improved. Now that the solution is clearly stated, it's easy to code improvements and submit pull requests.

Now that this solution has been merged and released, here is an analysis of this performance problem and how to avoid such problems in your own projects.

TL;DR: Jump to the conclusion part.

Performance bottleneck

If we look at it abstractly spatie/laravel-permission It mainly does two things Thing:

1. Keep a list of permissions belonging to a model.

2. Check whether a model has permissions.

The first point is that it is a bit far-fetched to say that it is a performance bottleneck. The permission data here is stored in the database and will be read when needed. This process is a bit slow but is only performed once. The results will be cached and can be used directly for subsequent requests.

The second point is indeed a bottleneck from the perspective of performance bottleneck. This bottleneck depends on the nature of the permissions and the size of the project, since permissions will be checked frequently. Any sluggishness during this check will become a performance bottleneck for the entire project.

Filter Collection Class

The method of filtering permission collections is considered to be the cause of low performance. It does the following:

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

After modification:

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

These two code snippets achieve the same thing, but the second one is faster.

Performance Test

There are about 150 different permissions in the app I'm developing. In a normal request, there are about 50 permissions that need to be checked using the hasPermissionTo method. Of course, some pages may need to check about 200 permissions.

The following are some settings used for performance testing.

$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();
}

The above three methods will be used to test filtering 1 attribute, 2 attributes, and 3 attributes. Therefore, using method 1 to filter three attributes will look like this:

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

Result

0.4880.603 (25%)0.198 (-59%)

	Method#1	Method#2	Method#3
1 attribute	0.190	0.139 (-27%)	0.072 ( -62%)
2 attributes	0.499	0.372 (-25%)	0.196 (-61%)
##3 attributes

Conclusion

We can conclude that for a project, repeatedly filtering a large collection will cause serious Performance bottleneck.

Multi-attribute filtering significantly increases the computational cost.

Using

Collection::filter() instead of Collection::where() can improve performance by 60%.

Warning: Passing the complete model to the filter callback is very performance intensive, it is better to pass individual attributes.

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

Using Swoole's coroutine database query in Laravel 5.6

##Laravel's Facade appearance system Analysis

laravel Redis simply implements high concurrency processing of queues that passes stress testing

The above is the detailed content of Performance optimization for Laravel-permission project. For more information, please follow other related articles on the PHP Chinese website!