Laravel Tutorial

[Video] Phân Quyền-Hướng dẫn viết chức năng phân quyền người dùng theo role Lâp Trình PHP/Laravel

Mở bài

Trong quá trình phát triển ứng dụng web, việc phân quyền người dùng (Authorization) là yếu tố vô cùng quan trọng giúp đảm bảo tính bảo mật và tổ chức cho hệ thống. Khi ứng dụng của bạn có nhiều nhóm người dùng như Admin, Nhân viên, Khách hàng hay Sinh viên, thì không thể để tất cả họ cùng truy cập vào các chức năng quan trọng như nhau.

Laravel – một framework PHP mạnh mẽ – đã tích hợp sẵn cơ chế phân quyền linh hoạt, giúp lập trình viên dễ dàng kiểm soát quyền truy cập theo từng role hoặc permission.
Trong bài viết này, chúng ta sẽ cùng nhau đi sâu vào:

Hiểu rõ khái niệm phân quyền (Authorization) trong Laravel.
Cách xây dựng chức năng phân quyền theo role.
Cách áp dụng middleware, policy và gate trong dự án thực tế.
Và cuối cùng là ví dụ mô phỏng hệ thống quản lý thư viện có phân quyền người dùng rõ ràng.

Bài viết này được viết dành cho lập trình viên PHP/Laravel ở mọi cấp độ — từ người mới bắt đầu cho đến người đang phát triển hệ thống doanh nghiệp chuyên nghiệp.

Phân biệt Authentication và Authorization

Trước khi bắt đầu, bạn cần hiểu rõ sự khác nhau giữa hai khái niệm quan trọng:

Authentication (Xác thực): Là bước đăng nhập, xác minh danh tính người dùng có tồn tại hay không.
→ Ví dụ: Người dùng nhập email và mật khẩu để vào hệ thống.
Authorization (Phân quyền): Là bước kiểm tra quyền truy cập sau khi người dùng đã được xác thực.
→ Ví dụ: Admin có quyền thêm sách, còn sinh viên chỉ có quyền xem sách.

Laravel đã hỗ trợ cả hai phần này rất mạnh mẽ, giúp bạn vừa dễ cài đặt vừa an toàn.

Xây dựng chức năng phân quyền theo Role

Giả sử bạn đang xây dựng ứng dụng quản lý thư viện với ba loại người dùng:

Admin: Quản lý toàn hệ thống (người dùng, sách, danh mục).
Librarian (Thủ thư): Quản lý việc mượn, trả sách.
Student: Chỉ có quyền xem và mượn sách.

Bước 1: Cập nhật Database

Đầu tiên, bạn cần tạo bảng roles và thêm trường role_id vào bảng users.


// database/migrations/create_roles_table.php
Schema::create('roles', function (Blueprint $table) {
    $table->id();
    $table->string('name'); // Admin, Librarian, Student
    $table->timestamps();
});

Thêm trường role_id vào bảng users:


Schema::table('users', function (Blueprint $table) {
    $table->unsignedBigInteger('role_id')->default(3); // Mặc định là Student
    $table->foreign('role_id')->references('id')->on('roles');
});

💡 Lưu ý: bạn có thể dùng Seeder để tự động thêm 3 role mặc định:


DB::table('roles')->insert([
    ['name' => 'Admin'],
    ['name' => 'Librarian'],
    ['name' => 'Student'],
]);

Bước 2: Tạo Middleware kiểm tra Role

Laravel cung cấp middleware để chặn người dùng truy cập nếu không đủ quyền.

Tạo middleware cho từng vai trò:


php artisan make:middleware RoleMiddleware

Trong file app/Http/Middleware/RoleMiddleware.php:


namespace App\Http\Middleware;

use Closure;
use Illuminate\Support\Facades\Auth;

class RoleMiddleware
{
    public function handle($request, Closure $next, ...$roles)
    {
        if (!Auth::check()) {
            return redirect('login');
        }

        if (!in_array(Auth::user()->role->name, $roles)) {
            return redirect('/')->with('error', 'Bạn không có quyền truy cập!');
        }

        return $next($request);
    }
}

Đăng ký middleware trong app/Http/Kernel.php:


protected $routeMiddleware = [
    'role' => \App\Http\Middleware\RoleMiddleware::class,
];

Bước 3: Áp dụng middleware vào route

Bây giờ bạn có thể dễ dàng phân quyền theo từng route bằng cách chỉ định role:


use App\Http\Controllers\BookController;
use App\Http\Controllers\CategoryController;
use App\Http\Controllers\OrderController;

Route::get('/', [LandingPageController::class, 'index']); // Public

// Admin
Route::middleware(['auth', 'role:Admin'])->group(function () {
    Route::get('/admin/categories', [CategoryController::class, 'index']);
    Route::get('/admin/books', [BookController::class, 'index']);
});

// Librarian
Route::middleware(['auth', 'role:Admin,Librarian'])->group(function () {
    Route::get('/orders', [OrderController::class, 'index']);
    Route::get('/orders/create', [OrderController::class, 'create']);
});

// Student
Route::middleware(['auth', 'role:Student'])->group(function () {
    Route::get('/my-books', [BookController::class, 'myBooks']);
});

Cách viết này rất gọn gàng, dễ bảo trì và mở rộng trong tương lai.

Bước 4: Sử dụng Policy trong Laravel

Nếu bạn muốn kiểm soát chi tiết hơn (ví dụ: chỉ cho phép người dùng chỉnh sửa dữ liệu của chính họ), thì Policy là lựa chọn tuyệt vời.

Tạo Policy cho model:


php artisan make:policy BookPolicy --model=Book

Trong BookPolicy.php:


public function update(User $user, Book $book)
{
    return $user->role->name === 'Admin' || $user->id === $book->created_by;
}

public function delete(User $user, Book $book)
{
    return $user->role->name === 'Admin';
}

Đăng ký Policy trong AuthServiceProvider:


protected $policies = [
    Book::class => BookPolicy::class,
];

Trong Controller hoặc View, bạn chỉ cần gọi:


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

Hoặc trong Blade:


@can('delete', $book)
    <button>Xóa</button>
@endcan

Bước 5: Gán Role khi tạo người dùng

Trong Controller khi đăng ký tài khoản mới, bạn có thể tự động gán role mặc định là Student:


protected function create(array $data)
{
    return User::create([
        'name' => $data['name'],
        'email' => $data['email'],
        'password' => Hash::make($data['password']),
        'role_id' => 3, // Student
    ]);
}

Nếu là admin tạo tài khoản, bạn có thể thêm select box để chọn role:


<select name="role_id">
    <option value="1">Admin</option>
    <option value="2">Librarian</option>
    <option value="3">Student</option>
</select>

Bước 6: Hiển thị giao diện phù hợp theo Role

Laravel Blade cho phép bạn dễ dàng hiển thị nội dung khác nhau dựa theo quyền của người dùng.


@if (Auth::user()->role->name == 'Admin')
    <a href="/admin/dashboard">Trang quản trị</a>
@elseif (Auth::user()->role->name == 'Librarian')
    <a href="/orders">Quản lý mượn sách</a>
@else
    <a href="/books">Xem sách</a>
@endif

Bạn cũng có thể sử dụng Blade directive tùy chỉnh để code gọn hơn:


Blade::if('role', function ($roles) {
    return in_array(Auth::user()->role->name, explode(',', $roles));
});

Sau đó dùng trong view:


@role('Admin,Librarian')
    <a href="/admin/books">Quản lý sách</a>
@endrole

Bước 7: Kiểm tra hoạt động

Sau khi hoàn thiện, bạn hãy đăng nhập thử bằng các tài khoản khác nhau:

Admin: Có thể truy cập tất cả trang quản lý.
Librarian: Truy cập được trang quản lý sách và đơn mượn.
Student: Chỉ xem được danh sách và mượn sách.

Nếu thử truy cập sai quyền, hệ thống sẽ tự động redirect về trang chủ với thông báo lỗi.

Một số lời khuyên khi triển khai phân quyền

Không nên hard-code quyền trong controller.
Thay vào đó, hãy dùng middleware hoặc policy để dễ bảo trì.
Luôn kiểm tra quyền ở cả backend và frontend.
Không nên chỉ ẩn nút trên giao diện – người dùng vẫn có thể truy cập trực tiếp qua URL.
Nếu ứng dụng phức tạp, nên dùng gói Spatie Laravel Permission.
Gói này hỗ trợ tạo role và permission chi tiết, lưu vào DB, và thao tác cực kỳ dễ dàng:
```
composer require spatie/laravel-permission
```
Tách logic phân quyền ra file riêng.
Điều này giúp code sạch, dễ mở rộng khi số role tăng lên.

Kết luận

Phân quyền người dùng là bước không thể thiếu trong mọi hệ thống web hiện đại. Với Laravel, bạn không cần phải viết từ đầu — framework đã cung cấp đầy đủ công cụ để bạn triển khai nhanh chóng, bảo mật và linh hoạt.

Từ việc tạo role, thêm middleware, áp dụng policy, đến việc tùy chỉnh giao diện hiển thị theo quyền, tất cả đều có thể hoàn thiện chỉ trong vài giờ.

Nếu bạn đang phát triển ứng dụng thực tế như hệ thống quản lý thư viện, website học tập hay hệ thống quản lý nhân sự, hãy áp dụng ngay hướng dẫn này để đảm bảo mọi người dùng chỉ thấy và thao tác được trong phạm vi của mình.

🚀 Bắt tay vào code ngay hôm nay:
php artisan make:middleware RoleMiddleware
Và chỉ trong vài dòng lệnh, bạn đã sở hữu một hệ thống phân quyền mạnh mẽ và chuyên nghiệp trong Laravel!

Mục Lục