Laravels auktoriseringssystem styr vad en autenticerad användare får göra (skilt från autentisering — vem de är). Gates är enkla closures för behörigheter; Policies är klasser som organiserar auktoriseringslogik kring en specifik modell (t.ex. vem som kan uppdatera ett Post).
::(, fn() => ->());
(::()) { ... }
::();
Gates är bra för enkla, fristående behörigheter som inte är knutna till en specifik modell.
<?php
// php artisan make:policy PostPolicy --model=Post
class PostPolicy {
public function update(User $user, Post $post): bool {
return $user->id === $post->user_id; // only the author can update
}
public function delete(User $user, Post $post): bool {
return $user->id === $post->user_id || $user->isAdmin();
}
}
En Policy-klass grupperar auktoriseringsreglerna för en modell — varje metod svarar på "kan denna användare utföra denna åtgärd på denna modell?" Detta håller auktoriseringslogiken organiserad per resurs.
// in a controller
public function update(Request $request, Post $post) {
$this->authorize('update', $post); // checks PostPolicy::update — throws 403 if denied
// ... proceed (we know the user is authorized)
}
// the user model
if ($request->user()->can('update', $post)) { ... }
{{-- in Blade — show UI only if authorized --}}
@can('update', $post)
<a href="{{ route('posts.edit', $post) }}">Edit</a>
@endcan
Metoderna authorize()/can() (och @can i Blade) kontrollerar policyn automatiskt — kastar ett 403 eller döljer gränssnitt när användaren inte har tillåtelse.
Autoriseringen är väsentlig och säkerhetskritisk — att kontrollera vad autenticerade användare får göra (inte bara om de är inloggade) är grundläggande för programsäkerhet, och Laravels policies och gates ger ett rent, organiserat sätt att hantera det.
Att förstå skillnaden mellan autentisering (vem du är — inloggning) och auktorisering (vad du kan göra — behörigheter) är grundläggande, och auktoriseringsfel leder till allvarliga säkerhetsproblem (användare får åtkomst till eller ändrar data de inte borde — bruten åtkomstkontroll är en högsta säkerhetrisk).
Laravels system erbjuder två kompletterande verktyg: Gates för enkla, fristående behörigheter (closure-baserade kontroller), och Policies — det vanliga, rekommenderade tillvägagångssättet — som organiserar en modells auktoriseringsregler i en dedikerad klass (t.ex. vem som kan uppdatera eller ta bort ett Post), vilket håller auktoriseringslogiken strukturerad och underhållbar per resurs.
Att förstå hur man definierar policies/gates och tillämpar dem ($this->authorize(), $user->can(), @can i Blade — kontroll av behörigheter i controllers, kasta 403:or och villkorligt visa gränssnitt) är viktigt för att bygga säkra applikationer där användare bara kan utföra tillåtna åtgärder.
Därför att nästan alla verkliga applikationer behöver fin-granulerad åtkomstkontroll (så att användare endast kan ändra sina egna resurser, begränsa administratörsåtgärder, osv.), och eftersom fel auktorisering skapar farliga säkerhetshål, är kunskap om Laravels policies och gates — det korrekta, organiserade sättet att implementera auktorisering — viktig säkerhetsviktig seniorkompetens som är väsentlig för att bygga applikationer som på rätt sätt tillämpar vem som kan göra vad, ett ofta förekommande och kritiskt krav i verkliga system.