Esempio di Autorizzazione di Accesso Basata su Ruolo di Spring Security

Tutorial
Spring

Oggi vedremo un esempio di accesso e autorizzazione basato su ruoli di sicurezza di primavera. Tuttavia, prima di leggere questo post, ti preghiamo di leggere il mio post precedente su “Esempio di accesso e logout di Spring 4 Security MVC” per ottenere una conoscenza di base su Spring 4 Security.

Ruolo della sicurezza di primavera

In questo post, discuteremo come definire, utilizzare e gestire ruoli di sicurezza di primavera come “UTENTE”, “AMMINISTRATORE” in un’applicazione web Spring. Come nel mio post precedente, anche questo esempio di post utilizza Spring 4 MVC Security con In-Memory Store e la funzionalità di configurazione Java Spring per sviluppare l’applicazione. Ciò significa che non utilizzeremo il file web.xml e non scriveremo nemmeno una singola riga di configurazione XML di Spring. Utilizzeremo l’opzione “In-Memory Store” per memorizzare e gestire le credenziali dell’utente. Utilizzeremo Spring 4.0.2.RELEASE, Spring STS 3.7 Suite IDE, Spring TC Server 3.1 con Java 1.8 e lo strumento di compilazione Maven per sviluppare questo esempio.

Esempio di autorizzazione basata su ruoli di sicurezza di primavera

  1. Crea un progetto “Simple Spring Web Maven” in Spring STS Suite con i seguenti dettagli.
    Nome del progetto: SpringMVCSecruityMavenRolesApp2. Utilizza lo stesso file pom.xml dal mio post precedente con le seguenti modifiche
<artifactId>SpringMVCSecruityMavenRolesApp</artifactId>

<build>
  <finalName>SpringMVCSecruityMavenRolesApp</finalName>
</build>
</project>
  1. Utilizza tutti i file Java e JSP dal mio post precedente. Discuteremo solo i contenuti aggiornati o appena aggiunti qui.
  2. Aggiorna il file LoginSecurityConfig.java per configurare i ruoli degli utenti come “USER” e “ADMIN”.
    LoginSecurityConfig.java
package com.journaldev.spring.secuity.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class LoginSecurityConfig extends WebSecurityConfigurerAdapter {

	@Autowired
	public void configureGlobal(AuthenticationManagerBuilder authenticationMgr) throws Exception {
		authenticationMgr.inMemoryAuthentication()
			.withUser("jduser").password("jdu@123").authorities("ROLE_USER")
			.and()
			.withUser("jdadmin").password("jda@123").authorities("ROLE_USER","ROLE_ADMIN");
	}
	
	@Override
	protected void configure(HttpSecurity http) throws Exception {

		
		http.authorizeRequests()
			.antMatchers("/homePage").access("hasRole('ROLE_USER') or hasRole('ROLE_ADMIN')")
			.antMatchers("/userPage").access("hasRole('ROLE_USER')")
			.antMatchers("/adminPage").access("hasRole('ROLE_ADMIN')")
			.and()
				.formLogin().loginPage("/loginPage")
				.defaultSuccessUrl("/homePage")
				.failureUrl("/loginPage?error")
				.usernameParameter("username").passwordParameter("password")				
			.and()
				.logout().logoutSuccessUrl("/loginPage?logout"); 
		
	}
}

Spiegazione del codice

  1. Nel metodo configureGlobal(), abbiamo aggiunto due utenti: Un utente con il ruolo “ROLE_USER” e un altro utente con entrambi i ruoli “ROLE_USER” e “ROLE_ADMIN”. Ciò significa che questo secondo utente agirà come utente Admin. In questo modo possiamo configurare qualsiasi numero di utenti e ruoli.
  2. Possiamo utilizzare sia il metodo authorities(ROLE) che il metodo roles(ROLE) per configurare i ruoli nella nostra applicazione.
  3. Differenza tra i metodi authorities() e roles():
  • authorities() richiede il nome completo del ruolo come “ROLE_USER”
  • roles() richiede il nome del ruolo come “USER”. Aggiungerà automaticamente il valore “ROLE_” a questo nome del ruolo “USER”.
  1. Nel metodo configure(), abbiamo definito diversi URL con i ruoli di accesso richiesti.
antMatchers("/homePage")
   .access("hasRole('ROLE_USER') or hasRole('ROLE_ADMIN')")

Questo frammento di codice configura che “/homePage” è disponibile sia per gli utenti USER che ADMIN.

 .antMatchers("/userPage").access("hasRole('ROLE_USER')")
 .antMatchers("/adminPage").access("hasRole('ROLE_ADMIN')")

Questo frammento di codice configura che “/userPage” è accessibile solo dal ruolo “USER” e “.“/adminPage” è accessibile solo dal ruolo “ADMIN”. Se altri ruoli accedono a queste pagine, otterremo il messaggio di errore di accesso “403 Accesso negato”.

  1. Aggiorna il file del controller LoginController.java per definire i nuovi percorsi di accesso URL come mostrato di seguito.
    LoginController.java
package com.journaldev.spring.web.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class LoginController {

	@RequestMapping(value = { "/"}, method = RequestMethod.GET)
	public ModelAndView welcomePage() {
		ModelAndView model = new ModelAndView();
		model.setViewName("welcomePage");
		return model;
	}

	@RequestMapping(value = { "/homePage"}, method = RequestMethod.GET)
	public ModelAndView homePage() {
		ModelAndView model = new ModelAndView();
		model.setViewName("homePage");
		return model;
	}
	
	@RequestMapping(value = {"/userPage"}, method = RequestMethod.GET)
	public ModelAndView userPage() {
		ModelAndView model = new ModelAndView();
		model.setViewName("userPage");
		return model;
	}
	
	@RequestMapping(value = {"/adminPage"}, method = RequestMethod.GET)
	public ModelAndView adminPage() {
		ModelAndView model = new ModelAndView();
		model.setViewName("adminPage");
		return model;
	}
	
	@RequestMapping(value = "/loginPage", method = RequestMethod.GET)
	public ModelAndView loginPage(@RequestParam(value = "error",required = false) String error,
	@RequestParam(value = "logout",	required = false) String logout) {
		
		ModelAndView model = new ModelAndView();
		if (error != null) {
			model.addObject("error", "Invalid Credentials provided.");
		}

		if (logout != null) {
			model.addObject("message", "Logged out from JournalDEV successfully.");
		}

		model.setViewName("loginPage");
		return model;
	}

}

Spiegazione del Codice Oltre all’esempio precedente, qui sono stati aggiunti altri due nuovi URL.

  1. “/userPage” è utilizzato dal Ruolo UTENTE per accedere e svolgere attività di utente normale.

  2. “/adminPage” è utilizzato dal Ruolo AMMINISTRATORE per accedere e svolgere attività di utente amministratore. Il ruolo AMMINISTRATORE può accedere anche all’URL “/userPage”.

  3. Aggiornato il file homePage.jsp per fornire attività specifiche per gli utenti e gli amministratori.
    homePage.jsp

<%@taglib prefix="c" uri="https://java.sun.com/jsp/jstl/core"%>
<a href="${pageContext.request.contextPath}/userPage">JD User</a> | <a href="${pageContext.request.contextPath}/adminPage">JD Admin</a> | <a href="javascript:document.getElementById('logout').submit()">Logout</a>

<h3>Welcome to JournalDEV Tutorials</h3>
<ul>
   <li>Java 8 tutorial</li>
   <li>Spring tutorial</li>
   <li>Gradle tutorial</li>
   <li>BigData tutorial</li>
</ul>

<c:url value="/logout" var="logoutUrl" />
<form id="logout" action="${logoutUrl}" method="post" >
  <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}" />
</form>

Qui abbiamo aggiunto tre opzioni di menu al frame superiore. “Logout” è già stato discusso nel mio post precedente. I nuovi due link sono:

  1. JD Utente: Accessibile sia dai ruoli “UTENTE” che “AMMINISTRATORE”
  2. JD Admin: Accessibile solo dai ruoli “AMMINISTRATORE”

NOTA:- Nelle applicazioni in tempo reale, mostreremo solo il link “JD Utente” al ruolo “UTENTE” e nasconderemo il link “JD Admin”. Per testare se è accessibile dal ruolo “UTENTE” o meno e anche per vedere il messaggio di errore esatto, non abbiamo nascosto questo link.20. Aggiungi il nuovo file adminPage.jsp per fungere da Homepage per il ruolo “AMMINISTRATORE”.
adminPage.jsp

<%@taglib prefix="c" uri="https://java.sun.com/jsp/jstl/core"%>
<h3>Welcome to JournalDEV Tutorials</h3>
<h3>Admin Page</h3>

<c:url value="/logout" var="logoutUrl" />
<form id="logout" action="${logoutUrl}" method="post" >
  <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}" />
</form>
<c:if test="${pageContext.request.userPrincipal.name != null}">
	<a href="javascript:document.getElementById('logout').submit()">Logout</a>
</c:if>
  1. Aggiungi il nuovo file userPage.jsp per fungere da Homepage per il ruolo “UTENTE”.
    userPage.jsp
<%@taglib prefix="c" uri="https://java.sun.com/jsp/jstl/core"%>
<h3>Welcome to JournalDEV Tutorials</h3>
<h3>User Page</h3>

<c:url value="/logout" var="logoutUrl" />
<form id="logout" action="${logoutUrl}" method="post" >
  <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}" />
</form>
<c:if test="${pageContext.request.userPrincipal.name != null}">
	<a href="javascript:document.getElementById('logout').submit()">Logout</a>
</c:if>

Abbiamo completato lo sviluppo dell’applicazione. È ora di vedere la struttura finale del nostro progetto e testare l’applicazione.26. La struttura finale del progetto è la seguente:

Test dell’applicazione di esempio di ruoli di Spring Security

  1. Clicca con il tasto destro del mouse sul progetto in Spring STS IDE e seleziona l’opzione “Esegui come >> Esegui su server”. Accederà alla pagina di benvenuto dell’applicazione predefinita come mostrato di seguito: 3. Fai clic sul link “Accedi a JournalDEV”. Ora sei nella pagina di accesso.
    5. Prima accedi con le credenziali del ruolo “USER”:
    Nome utente: jduser Password: jdu@123 Ora vedremo la Homepage dell’applicazione con 3 opzioni di menu: “JD Utente”, “JD Amministratore” e “Logout”. Fai clic sul link “JD Utente”. Dato che abbiamo effettuato l’accesso all’applicazione utilizzando le credenziali del ruolo “USER”, possiamo accedere a questo link come mostrato di seguito. Usa la freccia indietro in Spring STS IDE e questa volta fai clic sul link “JD Amministratore”. Dato che abbiamo effettuato l’accesso con le credenziali del ruolo “USER”, non possiamo accedere a questo link. Ecco perché abbiamo visto questo messaggio di errore: “403 Accesso negato”.9. Ora esegui il logout e accedi nuovamente con le credenziali del ruolo ADMIN
    Nome utente: jdadmin Password: jda@123 Questa volta possiamo accedere con successo al link “JD Amministratore” come mostrato di seguito. Testa il link “Logout” per uscire dall’applicazione.

Ecco un esempio di ruoli di sicurezza di Spring per fornire accesso autorizzato alle pagine dell’applicazione web.

Source:
https://www.digitalocean.com/community/tutorials/spring-security-role-based-access-authorization-example