Proteggere gli endpoint con regole di accesso personalizzate
Vada oltre i semplici controlli dei ruoli scrivendo logiche di autorizzazione personalizzate in Spring Security 6 con AuthorizationManager, espressioni SpEL e request matcher.
Proteggere gli endpoint con regole di accesso personalizzate è una lezione Spring Security 6 & JWT Authentication gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Spring Security 6 & JWT Authentication, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Spring Security 6 & JWT Authentication include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Why Custom Access Rules?
Roles and methods cover most cases, but real apps need finer control: only the owner of a resource may edit it, or access depends on the time of day or a feature flag.
Spring Security 6 lets you express these rules declaratively or programmatically.
The authorizeHttpRequests DSL
In Spring Security 6 the modern way to secure URLs is authorizeHttpRequests. Each matcher maps a request pattern to an access rule.
http.authorizeHttpRequests(auth -> auth
.requestMatchers('/public/**').permitAll()
.requestMatchers('/admin/**').hasRole('ADMIN')
.anyRequest().authenticated());Matching by HTTP Method
You can scope rules to a specific HTTP method, so reads and writes have different requirements.
http.authorizeHttpRequests(auth -> auth
.requestMatchers(HttpMethod.GET, '/api/orders/**').authenticated()
.requestMatchers(HttpMethod.POST, '/api/orders/**').hasRole('MANAGER'));SpEL with access()
The access() rule takes a Spring Expression Language (SpEL) condition for dynamic logic that plain matchers cannot express.
http.authorizeHttpRequests(auth -> auth
.requestMatchers('/reports/**')
.access(new WebExpressionAuthorizationManager(
"hasRole('ANALYST') and request.getHeader('X-Region') == 'EU'")));The AuthorizationManager Interface
For full control, implement AuthorizationManager. It returns an AuthorizationDecision that grants or denies access based on the authentication and the request.
public interface AuthorizationManager<T> {
AuthorizationDecision check(Supplier<Authentication> auth, T object);
}Writing a Custom AuthorizationManager
Here is a manager that only allows access during business hours. The supplier gives the current user; the object holds request context.
AuthorizationManager<RequestAuthorizationContext> businessHours =
(auth, ctx) -> {
int hour = LocalTime.now().getHour();
boolean ok = hour >= 9 && hour < 18;
return new AuthorizationDecision(ok);
};Plugging It In
Attach your custom manager to a matcher with access(). Any request to the path is now evaluated by your logic.
http.authorizeHttpRequests(auth -> auth
.requestMatchers('/maintenance/**').access(businessHours)
.anyRequest().authenticated());Owner-Based Access
A common rule: only the resource owner can modify it. You can read a path variable from the request context to compare against the logged-in user.
AuthorizationManager<RequestAuthorizationContext> ownerOnly =
(auth, ctx) -> {
String pathUser = ctx.getVariables().get('userId');
boolean same = auth.get().getName().equals(pathUser);
return new AuthorizationDecision(same);
};Combining Rules
Spring evaluates matchers top to bottom and stops at the first match. Order matters: put specific rules before broad ones, and always end with a catch-all like anyRequest().
Denying by Default
A secure baseline denies everything not explicitly allowed. Use denyAll() as the final rule when you want a strict allow-list.
http.authorizeHttpRequests(auth -> auth
.requestMatchers('/health').permitAll()
.anyRequest().denyAll());Testing Access Rules
Verify your rules with @WithMockUser and MockMvc. Assert that authorized users get 200 and unauthorized users get 403.
mockMvc.perform(get('/admin/dashboard'))
.andExpect(status().isForbidden());Quick Check
Test your understanding of custom access rules.
Recap
You learned to write custom authorization in Spring Security 6:
- Use the
authorizeHttpRequestsDSL with path and method matchers - Apply SpEL conditions via
access() - Implement
AuthorizationManagerfor dynamic, owner-based, or time-based rules - Order matters; end with a catch-all and prefer deny-by-default
These tools let you enforce business-specific security policies precisely.
Domande Frequenti
La lezione «Proteggere gli endpoint con regole di accesso personalizzate» è gratuita?
Sì — il testo completo di «Proteggere gli endpoint con regole di accesso personalizzate» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Spring Security 6 & JWT Authentication, passa a CoddyKit PRO. Il corso Spring Security 6 & JWT Authentication include 4 lezioni in totale.
Cosa imparerò in «Proteggere gli endpoint con regole di accesso personalizzate»?
Vada oltre i semplici controlli dei ruoli scrivendo logiche di autorizzazione personalizzate in Spring Security 6 con AuthorizationManager, espressioni SpEL e request matcher. Eserciti Spring Security 6 & JWT Authentication con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Spring Security 6 & JWT Authentication?
Non è richiesta alcuna esperienza precedente. Spring Security 6 & JWT Authentication su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Proteggere gli endpoint con regole di accesso personalizzate»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Spring Security 6 & JWT Authentication?
Sì. Ogni lezione Spring Security 6 & JWT Authentication include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Controllo degli accessi basato sui ruoli (RBAC)
- Sicurezza a livello di metodo con le annotazioni
- Approfondimento della configurazione di HttpSecurity
- Proteggere gli endpoint con regole di accesso personalizzate