Laravel中如何实现用户间关联关系？同一User模型多角色多对多关联方案咨询

Got it, let's break this down step by step since you're dealing with a single users table with multiple roles and self-referential many-to-many relationships in Laravel. Here's how to set this up properly:

Since bosses, supervisors, and other non-owner users can belong to multiple owners, and owners can manage multiple users, you'll need a pivot table to maintain this many-to-many association. Generate the migration first:

php artisan make:migration create_user_owner_table

Then update the migration file with this structure:

public function up()
{
    Schema::create('user_owner', function (Blueprint $table) {
        $table->unsignedBigInteger('user_id'); // The user (boss/supervisor/etc.)
        $table->unsignedBigInteger('owner_id'); // The owner they're associated with
        $table->timestamps();

        // Add foreign key constraints
        $table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');
        $table->foreign('owner_id')->references('id')->on('users')->onDelete('cascade');

        // Prevent duplicate associations between the same user and owner
        $table->unique(['user_id', 'owner_id']);
    });
}

public function down()
{
    Schema::dropIfExists('user_owner');
}

Run the migration to create the table:

php artisan migrate

First, add role constants to avoid hardcoding role strings (this makes maintenance easier). Then define the self-referential relationships and helper methods for role checks:

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;

    // Role type constants
    const TYPE_ADMIN = 'admin';
    const TYPE_OWNER = 'owner';
    const TYPE_BOSS = 'boss';
    const TYPE_SUPERVISOR = 'supervisor';

    // ... rest of your model code (fillable, etc.)

    // Get all owners this user belongs to (for bosses, supervisors, etc.)
    public function owners()
    {
        return $this->belongsToMany(User::class, 'user_owner', 'user_id', 'owner_id')
            ->where('type', self::TYPE_OWNER)
            ->withTimestamps();
    }

    // Get all users managed by this owner (bosses, supervisors, etc.)
    public function ownedUsers()
    {
        return $this->belongsToMany(User::class, 'user_owner', 'owner_id', 'user_id')
            ->withTimestamps();
    }

    // Query scopes to filter users by role quickly
    public function scopeAdmin($query)
    {
        return $query->where('type', self::TYPE_ADMIN);
    }

    public function scopeOwner($query)
    {
        return $query->where('type', self::TYPE_OWNER);
    }

    public function scopeBoss($query)
    {
        return $query->where('type', self::TYPE_BOSS);
    }

    public function scopeSupervisor($query)
    {
        return $query->where('type', self::TYPE_SUPERVISOR);
    }

    // Helper methods to check a user's role
    public function isAdmin()
    {
        return $this->type === self::TYPE_ADMIN;
    }

    public function isOwner()
    {
        return $this->type === self::TYPE_OWNER;
    }

    public function isBoss()
    {
        return $this->type === self::TYPE_BOSS;
    }

    public function isSupervisor()
    {
        return $this->type === self::TYPE_SUPERVISOR;
    }
}

Here are some common usage examples:

• Get all owners a specific boss belongs to:

  $boss = User::boss()->find(1);
  $associatedOwners = $boss->owners;
  

• Get all bosses managed by an owner:

  $owner = User::owner()->find(1);
  $managedBosses = $owner->ownedUsers()->boss()->get();
  

• Associate a supervisor with an owner:

  $supervisor = User::supervisor()->find(3);
  $supervisor->owners()->attach($ownerId); // $ownerId is the ID of the owner
  

• Remove a boss from an owner's management:

  $boss->owners()->detach($ownerId);
  

Since you're using a single login entry, you can manage role-based access and redirects in these ways:

Option 1: Redirect After Login #

Modify your LoginController to send users to role-specific dashboards:

use Illuminate\Http\Request;

class LoginController extends Controller
{
    // ... existing login code

    protected function authenticated(Request $request, $user)
    {
        if ($user->isAdmin()) {
            return redirect()->route('admin.dashboard');
        } elseif ($user->isOwner()) {
            return redirect()->route('owner.dashboard');
        } elseif ($user->isBoss()) {
            return redirect()->route('boss.dashboard');
        } elseif ($user->isSupervisor()) {
            return redirect()->route('supervisor.dashboard');
        }

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

Option 2: Role-Based Route Middleware #

Create a custom middleware to restrict routes to specific roles:

1. Generate the middleware:

   php artisan make:middleware CheckRole
   

2. Update the middleware file (app/Http/Middleware/CheckRole.php):

   namespace App\Http\Middleware;
   
   use Closure;
   use Illuminate\Http\Request;
   
   class CheckRole
   {
       public function handle(Request $request, Closure $next, ...$roles)
       {
           if (!in_array($request->user()->type, $roles)) {
               abort(403, 'You are not authorized to access this page.');
           }
   
           return $next($request);
       }
   }
   

3. Register the middleware in app/Http/Kernel.php under $routeMiddleware:

   protected $routeMiddleware = [
       // ... existing middleware
       'role' => \App\Http\Middleware\CheckRole::class,
   ];
   

4. Use it in your routes:

   Route::get('/admin/dashboard', [AdminController::class, 'dashboard'])->middleware('role:admin');
   Route::get('/owner/dashboard', [OwnerController::class, 'dashboard'])->middleware('role:owner');
   

• Admins are typically a top-level role, so they likely don't need to belong to any owners. You can adjust the owners() relationship if needed (e.g., add a condition to exclude admins).
• Always validate the type field when creating/updating users—use a rule like in:admin,owner,boss,supervisor to ensure only valid roles are stored.

内容的提问来源于stack exchange，提问作者user13134426