Exemple d’autorisation d’accès basée sur les rôles avec Spring Security

Tutoriels
Spring

Aujourd’hui, nous examinerons un exemple d’accès basé sur les rôles et d’autorisation de sécurité de printemps. Cependant, avant de lire ce post, veuillez parcourir mon précédent post sur le «Exemple de connexion et déconnexion de sécurité Spring 4 MVC» pour acquérir quelques connaissances de base sur la sécurité Spring 4.

Rôle de sécurité Spring

Dans ce post, nous discuterons de la manière de définir, utiliser et gérer les rôles de sécurité de printemps tels que « USER », « ADMIN » dans une application Web Spring. Comme dans mon précédent post, cet exemple utilise également la sécurité Spring 4 MVC avec un stockage en mémoire et la fonction de configuration Java de Spring pour développer l’application. Cela signifie que nous n’allons pas utiliser le fichier web.xml et que nous n’allons même pas écrire une seule ligne de configuration XML Spring. Nous allons utiliser l’option « In-Memory Store » pour stocker et gérer les informations d’identification des utilisateurs. Nous allons utiliser Spring 4.0.2.RELEASE, Spring STS 3.7 Suite IDE, Spring TC Server 3.1 avec Java 1.8 et l’outil de construction Maven pour développer cet exemple.

Exemple d’autorisation d’accès basée sur les rôles de Spring Security

  1. Créez un projet « Simple Spring Web Maven » dans Spring STS Suite avec les détails suivants.
    Nom du projet : SpringMVCSecruityMavenRolesApp2. Utilisez le même fichier pom.xml que dans mon précédent message avec les modifications suivantes
<artifactId>SpringMVCSecruityMavenRolesApp</artifactId>

<build>
  <finalName>SpringMVCSecruityMavenRolesApp</finalName>
</build>
</project>
  1. Utilisez tous les fichiers Java et JSP de mon précédent message. Nous discuterons uniquement du contenu mis à jour ou nouvellement ajouté ici.
  2. Mettez à jour le fichier LoginSecurityConfig.java pour configurer les rôles utilisateur tels que « USER » et « 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"); 
		
	}
}

Explication du code

  1. Dans la méthode configureGlobal(), nous avons ajouté deux utilisateurs : un utilisateur avec le rôle « ROLE_USER » et un autre utilisateur avec les rôles « ROLE_USER » et « ROLE_ADMIN ». Cela signifie que ce deuxième utilisateur agira en tant qu’utilisateur administrateur. De cette manière, nous pouvons configurer n’importe quel nombre d’utilisateurs et de rôles.
  2. Nous pouvons utiliser les méthodes authorities(ROLE) ou roles(ROLE) pour configurer les rôles dans notre application.
  3. Différence entre les méthodes authorities() et roles() :
  • authorities() nécessite le nom complet du rôle comme « ROLE_USER »
  • roles() nécessite le nom du rôle comme « USER ». Il ajoutera automatiquement la valeur « ROLE_ » à ce nom de rôle « USER ».
  1. Dans la méthode configure(), nous avons défini différentes URL avec les rôles d’accès requis.
antMatchers("/homePage")
   .access("hasRole('ROLE_USER') or hasRole('ROLE_ADMIN')")

Cet extrait de code configure que « /homePage » est disponible pour les rôles USER et ADMIN.

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

Cet extrait de code configure que « /userPage » est accessible uniquement par le rôle USER et « /adminPage » est accessible uniquement par le rôle ADMIN. Si d’autres rôles accèdent à ces pages, nous obtiendrons un message d’erreur « 403 Accès refusé ».

  1. Mettez à jour le fichier Contrôleur LoginController.java pour définir de nouveaux chemins d’accès URL comme indiqué ci-dessous.
    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;
	}

}

Explication du Code En plus de l’exemple précédent, nous avons ajouté deux nouveaux URL.

  1. « /userPage » est utilisé par le rôle UTILISATEUR pour accéder et effectuer des activités d’utilisateur normales.

  2. « /adminPage » est utilisé par le rôle ADMIN pour accéder et effectuer des activités d’utilisateur administrateur. Le rôle ADMIN peut également accéder à l’URL « /userPage ».

  3. Fichier homePage.jsp mis à jour pour fournir des activités spécifiques aux rôles Utilisateur et Administrateur.
    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>

Ici, nous avons ajouté trois options de menu dans le cadre supérieur. « Déconnexion » a déjà été discuté dans mon précédent message. Deux nouveaux liens sont les suivants :

  1. JD Utilisateur : Accessible par les rôles « UTILISATEUR » et « ADMIN »
  2. JD Admin : Accessible uniquement par les rôles « ADMIN »

REMARQUE :- Dans les applications en temps réel, nous ne montrerons que le lien « JD Utilisateur » au rôle « UTILISATEUR » et masquerons le lien « JD Admin ». Pour tester s’il est accessible par le rôle « UTILISATEUR » ou non et également pour voir le message d’erreur exact, nous n’avons pas caché ce lien.20. Ajoutez un nouveau fichier adminPage.jsp pour servir de page d’accueil pour le rôle « ADMIN ».
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. Ajoutez le nouveau fichier userPage.jsp pour servir de page d’accueil pour le rôle « UTILISATEUR ».
    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>

Nous avons terminé le développement de notre application maintenant. Il est temps de voir la structure finale de notre projet et de tester l’application.26. La structure finale du projet ressemble à ceci :

Test d’application exemple de rôles de sécurité Spring

  1. Cliquez avec le bouton droit sur le projet dans l’IDE Spring STS et sélectionnez l’option « Exécuter en tant que >> Exécuter sur le serveur ». Cela accédera à la page d’accueil de l’application par défaut comme indiqué ci-dessous: 3. Cliquez sur le lien « Se connecter à JournalDEV ». Vous êtes maintenant sur la page de connexion. 5. Connectez-vous d’abord avec les informations d’identification du rôle « USER »: Nom d’utilisateur : jduser Mot de passe : jdu@123 Maintenant, nous verrons la page d’accueil de l’application avec 3 options de menu : « Utilisateur JD », « Administrateur JD » et « Déconnexion ». Cliquez sur le lien « Utilisateur JD ». Comme nous nous sommes connectés à l’application en utilisant les informations d’identification du rôle « USER », nous pouvons accéder à ce lien comme indiqué ci-dessous. Utilisez simplement la flèche arrière dans l’IDE Spring STS et cette fois, cliquez sur le lien « Administrateur JD ». Comme nous nous sommes connectés avec les informations d’identification du rôle « USER », nous ne pouvons pas accéder à ce lien. C’est pourquoi nous avons vu ce message d’erreur : « 403 Accès refusé ». 9. Maintenant, déconnectez-vous et connectez-vous à nouveau avec les informations d’identification du rôle « ADMIN » Nom d’utilisateur : jdadmin Mot de passe : jda@123 Cette fois, nous pouvons accéder avec succès au lien « Administrateur JD » comme indiqué ci-dessous. Testez le lien « Déconnexion » pour vous déconnecter de l’application.

C’est tout à propos de l’exemple de rôles de sécurité de Spring pour fournir un accès autorisé aux pages de l’application web.

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