l-1

PHP笔记

主页/PHP笔记/PHP问答/框架Laravel/Laravel中的授权角色：实用指南

Laravel中的授权角色：实用指南

Bug编译狮

Bug编译狮

《Laravel中的授权角色：实用指南》

在现代的Web开发中，权限控制是确保安全性和用户满意度的关键因素之一。Laravel是一个非常流行的PHP框架，它提供了强大的权限管理功能。本文将帮助你在Laravel项目中使用授权角色来实现用户认证和访问控制。

1. 安装Laravel

首先，你需要安装Laravel。你可以通过Composer来完成这个过程：

composer create-project --prefer-dist laravel/laravel my-laravel-app
cd my-laravel-app

2. 创建一个角色模型

接下来，我们需要创建一个角色模型来表示用户的权限。在app/Models目录下创建一个名为Role.php的文件，并添加以下代码：

<?php

namespace AppModels;

use IlluminateDatabaseEloquentModel;
use IlluminateSupportFacadesGate;

class Role extends Model
{
    protected $fillable = ['name', 'description'];

    public function users()
    {
        return $this->belongsToMany(User::class);
    }

    public function authorize($ability, $arguments = [])
    {
        if (Gate::check($ability . '.' . $arguments[0], $arguments[1])) {
            return true;
        }

        abort(403);
    }
}

3. 创建一个用户模型

同样，在app/Models目录下创建一个名为User.php的文件，并添加以下代码：

<?php

namespace AppModels;

use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use LaravelSoftDeletes;
use SpatiePermissionTraitsHasRoles;

class User extends Authenticatable
{
    use Notifiable, SoftDeletes, HasRoles;

    protected $fillable = [
        'name', 'email', 'password',
    ];

    protected $hidden = [
        'password', 'remember_token',
    ];

    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }

    public function authorize($ability, $arguments = [])
    {
        if (Gate::check($ability . '.' . $arguments[0], $arguments[1])) {
            return true;
        }

        abort(403);
    }
}

4. 配置路由和控制器

在routes/web.php文件中配置路由和控制器：

use AppHttpControllersAuthController;
use AppHttpControllersPostController;
use AppHttpControllersRoleController;
use AppHttpControllersUserController;

Route::get('/login', [AuthController::class, 'showLoginForm'])->name('login');
Route::post('/login', [AuthController::class, 'authenticate']);
Route::get('/register', [AuthController::class, 'showRegistrationForm'])->name('register');
Route::post('/register', [AuthController::class, 'store']);

Route::middleware(['auth:sanctum'])->group(function () {
    Route::apiResource('posts', PostController::class);
    Route::apiResource('roles', RoleController::class);
    Route::apiResource('users', UserController::class);
});

5. 创建控制器

在app/Http/Controllers目录下创建以下控制器：

  • AuthController
  • PostController
  • RoleController
  • UserController

AuthController

<?php

namespace AppHttpControllers;

use AppModelsUser;
use IlluminateHttpRequest;
use IlluminateSupportFacadesAuth;
use IlluminateSupportFacadesValidator;

class AuthController extends Controller
{
    public function showLoginForm()
    {
        return view('auth.login');
    }

    public function authenticate(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'email' => 'required|email',
            'password' => 'required',
        ]);

        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        }

        if (!Auth::attempt(['email' => $request['email'], 'password' => $request['password']])) {
            return redirect()->back()->withErrors(['message' => 'Invalid credentials'])->withInput();
        }

        return redirect()->intended('/');
    }

    public function logout()
    {
        Auth::logout();

        return redirect()->route('login');
    }
}

PostController

<?php

namespace AppHttpControllers;

use AppModelsPost;
use IlluminateHttpRequest;

class PostController extends Controller
{
    public function index()
    {
        $posts = Post::all();
        return view('posts.index', compact('posts'));
    }

    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'content' => 'required',
        ]);

        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        }

        $post = new Post();
        $post->title = $request['title'];
        $post->content = $request['content'];
        $post->save();

        return redirect()->route('posts.index');
    }
}

RoleController

<?php

namespace AppHttpControllers;

use AppModelsRole;
use IlluminateHttpRequest;

class RoleController extends Controller
{
    public function index()
    {
        $roles = Role::all();
        return view('roles.index', compact('roles'));
    }

    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|unique:roles,name',
            'description' => 'required',
        ]);

        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        }

        $role = new Role();
        $role->name = $request['name'];
        $role->description = $request['description'];
        $role->save();

        return redirect()->route('roles.index');
    }

    public function update(Request $request, $id)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|unique:roles,name,' . $id,
            'description' => 'required',
        ]);

        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        }

        $role = Role::find($id);
        $role->name = $request['name'];
        $role->description = $request['description'];
        $role->save();

        return redirect()->route('roles.index');
    }

    public function destroy($id)
    {
        $role = Role::find($id);
        $role->delete();

        return redirect()->route('roles.index');
    }
}

UserController

<?php

namespace AppHttpControllers;

use AppModelsUser;
use IlluminateHttpRequest;

class UserController extends Controller
{
    public function index()
    {
        $users = User::all();
        return view('users.index', compact('users'));
    }

    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|max:255',
            'email' => 'required|email|unique:users,email',
            'password' => 'required|min:8',
        ]);

        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        }

        $user = new User();
        $user->name = $request['name'];
        $user->email = $request['email'];
        $user->password = bcrypt($request['password']);
        $user->save();

        return redirect()->route('users.index');
    }

    public function update(Request $request, $id)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|max:255',
            'email' => 'required|email|unique:users,email,' . $id,
        ]);

        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        }

        $user = User::find($id);
        $user->name = $request['name'];
        $user->email = $request['email'];
        if ($request->has('password')) {
            $user->password = bcrypt($request['password']);
        }
        $user->save();

        return redirect()->route('users.index');
    }

    public function destroy($id)
    {
        $user = User::find($id);
        $user->delete();

        return redirect()->route('users.index');
    }

    public function assignRole(Request $request, $userId)
    {
        $roleId = $request->input('role_id');
        $user = User::find($userId);
        $user->assignRole($roleId);

        return redirect()->route('users.show', $userId);
    }

    public function removeRole(Request $request, $userId, $roleId)
    {
        $user = User::find($userId);
        $user->removeRole($roleId);

        return redirect()->route('users.show', $userId);
    }
}

6. 赋予用户角色

现在，你可以为用户分配角色。在app/Console/Kernel.php文件中运行以下命令：

php artisan make:command AssignRole

编辑生成的AssignRole类，添加以下代码：

<?php

namespace AppConsoleCommands;

use AppModelsRole;
use AppModelsUser;
use IlluminateConsoleCommand;

class AssignRole extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'assign-role {user} {role}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Assign a role to a user';

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $user = User::find($this->argument('user'));
        $role = Role::find($this->argument('role'));

        if (!$user || !$role) {
            $this->error('User or role not found.');
            return 1;
        }

        $user->assignRole($role->name);

        $this->info('Role assigned successfully.');
        return 0;
    }
}

然后，你可以使用以下命令为用户分配角色：

php artisan assign-role 1 admin

这样，你就成功地为用户分配了角色，并且可以通过Gates进行权限检查。

通过以上步骤，你可以在Laravel项目中使用授权角色来实现用户认证和访问控制。希望这篇指南对你有所帮助！

黑板Bug讲师

黑板Bug讲师

介绍

授权是任何Web应用程序的关键组成部分，确保用户具有执行特定操作的适当权限。Laravel，世界上最流行的PHP框架之一，通过内置功能以及如Spatie的Role & Permission等包提供了一种优雅且简单的处理授权的方式。在这篇指南中，我们将从基础到更高级的概念介绍如何在Laravel中实现基于角色的授权。

在Laravel中设置角色（roles）的操作。

首先，我们需要在我们的Laravel应用程序中定义角色基础设施。虽然Laravel本身没有内置的角色功能，但通过使用Gates和Policies，我们可以手动定义角色和权限，或者集成第三方包来实现这一点。

首先，使用迁移创建角色和权限表：

php artisan make:migration create_roles_table
php artisan make:migration create_permissions_table

您的迁移文件应定义角色和权限所需的列。一旦创建了这些迁移，就运行它们：

php artisan migrate

接下来，设置模型：

php artisan make:model Role
php artisan make:model Permission

然后，编辑。Roleand 是“并且”的意思。Permission模型用于定义关系。

为用户分配角色。

角色需要与用户关联。我们可以为我们的User模型添加一个方法，例如：

public function roles()
{
    return $this->belongsToMany(Role::class);
}

我们也需要为用户分配角色，可以通过以下方式实现：

$user->roles()->attach($roleId);

使用Gates进行授权

Laravel的Gate是闭包，用于确定用户是否被授权执行特定的操作。以下是一个简单的示例：

Gate::define('edit-article', function ($user, $article) {
    return $user->id === $article->user_id;
});

为了检查此授权，我们使用：

if (Gate::allows('edit-article', $article)) {
    // The user can edit the article
}

定义政策

政策是一组组织围绕特定模型或资源的授权逻辑的类。要创建一个策略：

php artisan make:policy ArticlePolicy --model=Article

这会产生包含多个模板方法的策略。你可以定义类似于的方法。update()哪个可以检查用户是否有必要的权限以执行角色：

public function update(User $user, Article $article)
{
    return $user->roles->contains('editor');
}

该方法现在可以在使用控制器时使用了。authorize方法：

$this->authorize('update', $article);

高级角色和权限设置的Spatie包

对于更复杂的应用，通常使用Spatie的Laravel-Permission包会更容易一些。通过composer安装该包并发布其资产后，你可以用简单的命令添加角色和权限：

use SpatiePermissionModelsRole;
use SpatiePermissionModelsPermission;

$role = Role::create(['name' => 'editor']);
$permission = Permission::create(['name' => 'edit articles']);

它还提供了用于使用角色和权限保护路由的中间件：

Route::group(['middleware' => ['role:editor']], function () {
    // Routes here will require the 'editor' role
});

授权授权指引 Blade

在我的观点中，你可以利用Laravel内置的Blade指令来根据用户的角色或权限显示内容：

@role('editor')
    <!-- Content for editors -->
@endrole

@can('edit articles')
    <!-- Content for users who can edit articles -->
@endcan

测试授权

测试在确保应用授权功能正确运行方面至关重要。Laravel 通过内置特性提供了写测试的便利：

$response = $this->actingAs($user)->get('/article/edit/1');
$response->assertStatus(403);

此检查是否正确阻止未经授权的用户访问受保护的路由。

结论。

综上所述，理解并实施Laravel中的角色授权对于确保应用内操作的安全至关重要。通过设置角色和权限、使用Gate和Policy等方法，以及利用如Spatie这样的复杂场景包，Laravel开发人员可以有效地管理访问控制。

长工码奴1523

长工码奴1523

Laravel 是一个非常流行的 PHP 开发框架，它提供了丰富的功能和强大的 API。其中的一个关键特性是权限管理，通过授权角色（roles）来控制用户对资源的访问。

在 Laravel 中，创建和管理角色非常简单。下面是一些基本的步骤和示例代码：

1. 创建角色

首先，你需要定义一个新的角色。这个角色将用于指定哪些用户可以访问哪些特定的资源。你可以使用 Role 类来定义角色。

use IlluminateSupportFacadesGate;

class Role {
    public $name;
    public $guard_name;

    /**
     * Create a new role instance.
     *
     * @param string $name
     * @param string $guard_name
     */
    public function __construct($name, $guard_name)
    {
        $this->name = $name;
        $this->guard_name = $guard_name;
    }

    /**
     * Determine if the user has the role.
     *
     * @param IlluminateContractsAuthAuthenticatable $user
     * @return bool
     */
    public function can($ability, $guard = null)
    {
        return Gate::allows($this->name . '.' . $ability, $guard);
    }
}

2. 使用角色

一旦你创建了角色，就可以为不同的控制器设置这些角色。这样，只有具有相应角色的用户才能访问它们。

// controller.php
public function index()
{
    // ...

    foreach (config('auth.roles') as $role => $guards) {
        if ($this->hasRole($role)) {
            $this->authorize($role, $guards);
        } else {
            abort(403);
        }
    }

    // ...
}

protected function hasRole($role)
{
    return in_array($role, config('auth.role_names'));
}

示例代码

以下是一个简单的例子，展示了如何在控制器中检查用户是否具有某个角色，并根据需要进行权限验证：

public function index(Request $request)
{
    // ...

    if ($request->hasRole('admin')) {
        // 用户具有管理员权限，允许访问
    } elseif ($request->hasRole('editor')) {
        // 用户具有编辑权限，允许访问
    } else {
        // 其他用户被拒绝访问
    }

    // ...
}

在这个例子中，我们检查 $request->hasRole('admin') 来判断用户是否具有管理员权限，然后根据结果决定是否允许访问。

这就是 Laravel 角色系统的基本用法。你可以根据需要扩展和定制这个系统，以满足不同场景的需求。

最新更新