Recherche de site Web

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

Aujourd'hui, nous allons examiner un exemple de contrôle d'accès et d'autorisation basé sur les rôles dans Spring Security. Cependant, avant de lire cet article, veuillez consulter mon article précédent sur « Exemple de connexion et déconnexion MVC avec Spring 4 Security » pour acquérir quelques connaissances de base sur Spring 4 Security.

Rôle de Spring Security

Dans cet article, nous allons discuter de la façon de définir, utiliser et gérer les rôles de sécurité Spring comme « USER » et « ADMIN » dans une application Web Spring. Comme dans mon précédent article, l'exemple de cet article utilise également Spring 4 MVC Security avec un stockage en mémoire et la fonctionnalité de configuration Java Spring pour développer l'application. Cela signifie que nous n'allons pas utiliser le fichier web.xml et que nous n'écrirons pas une seule ligne de configuration XML Spring. Nous utiliserons 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 build Maven pour développer cet exemple.

Exemple d'autorisation d'accès basée sur les rôles avec 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 de mon post précédent 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 ne discuterons ici que du contenu mis à jour ou nouvellement ajouté.
  2. Mettre à jour le fichier LoginSecurityConfig.java pour configurer les rôles des utilisateurs comme « 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 à la fois les rôles « ROLE_USER » et « ROLE_ADMIN ». Cela signifie que ce deuxième utilisateur agira en tant qu'utilisateur Admin. De cette façon, nous pouvons configurer n'importe quel nombre d'utilisateurs et de rôles.
  2. Nous pouvons utiliser soit les méthodes authorities(ROLE) soit roles(ROLE) pour configurer les Rôles dans notre application.
  3. Différence entre les méthodes authorities() et roles() :
  • authorities() a besoin du nom complet du rôle comme « ROLE_USER »
  • roles() a besoin d'un nom de 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 à la fois 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 que "/adminPage" est accessible uniquement par le rôle "ADMIN". Si d'autres rôles accèdent à ces pages, nous recevrons le message d'erreur d'accès "403 Accès refusé".

  1. Mettre à jour le fichier Controller 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 du post précédent, nous avons ajouté ici deux nouvelles URL.

  1. “/userPage ” est utilisé par le rôle UTILISATEUR pour accéder et effectuer les activités normales de l'utilisateur.

  2. « /adminPage » est utilisé par le rôle ADMIN pour accéder et effectuer les activités des utilisateurs administrateurs. 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. « Se déconnecter » a déjà été discuté dans mon message précédent. Deux nouveaux liens sont :

  1. Utilisateur JD : 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 afficherons uniquement le lien « JD User » pour le rôle « USER » et masquerons le lien « JD Admin ». Pour tester si ce lien est accessible par le rôle « USER » ou non et également pour voir le message d'erreur exact, nous n'avons pas masqué ce lien. 20. Ajouter 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. Ajouter un nouveau fichier userPage.jsp pour servir de page d'accueil pour le rôle « USER ». 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 maintenant terminé le développement de notre application. Il est temps de voir la structure finale de notre projet et de tester l'application. La structure finale du projet ressemble à ceci :

Test de l'application d'exemple des rôles Spring Security

  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 par défaut de l'application comme indiqué ci-dessous :

    2. 3. Cliquez sur le lien « Login to JournalDEV ». Vous êtes maintenant sur la page de connexion. 5. Connectez-vous d'abord avec les identifiants 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 : « JD User », « JD Admin » et « Logout ». Cliquez sur le lien « JD User ». Comme nous nous sommes connectés à l'application avec les identifiants du rôle « USER », nous pouvons accéder à ce lien comme indiqué ci-dessous. Utilisez simplement la flèche retour dans l'IDE Spring STS et cette fois cliquez sur le lien « JD Admin ». Comme nous nous sommes connectés avec les identifiants du rôle « USER », nous ne pouvons pas accéder à ce lien. C'est pourquoi nous avons vu ce message d'erreur : « 403 Access is denied ». 9. Maintenant, connectez-vous et connectez-vous à nouveau avec les identifiants du rôle ADMIN : Nom d'utilisateur : jdadmin Mot de passe : jda@123. Cette fois, nous pouvons accéder avec succès au lien « JD Admin » comme indiqué ci-dessous. Testez le lien « Logout » pour vous déconnecter de l'application.

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