Búsqueda de sitios web

Ejemplo de autorización de acceso basado en roles de Spring Security


Hoy veremos un ejemplo de autorización y acceso basado en roles de seguridad de primavera. Sin embargo, antes de leer esta publicación, revise mi publicación anterior sobre \Ejemplo de cierre de sesión de MVC de Spring 4 Security para obtener algunos conocimientos básicos sobre Spring 4 Security.

Rol de seguridad de primavera

En esta publicación, discutiremos cómo definir, usar y administrar roles de seguridad de Spring como \USUARIO, \ADMIN en la aplicación web Spring. Al igual que mi publicación anterior, este ejemplo de publicación también usa Spring 4 MVC Security con In-Memory Store y Spring Java Configuration Feature para desarrollar la aplicación. Eso significa que no vamos a utilizar el archivo web.xml y tampoco vamos a escribir ni una sola línea de configuración Spring XML. Usaremos la opción \Almacén en memoria para almacenar y administrar las Credenciales de usuario. Vamos a usar Spring 4.0.2.RELEASE, Spring STS 3.7 Suite IDE, Spring TC Server 3.1 con Java 1.8 y la herramienta de compilación Maven para desarrollar esto ejemplo.

Ejemplo de autorización de acceso basado en roles de Spring Security

  1. Cree un proyecto \Simple Spring Web Maven en Spring STS Suite con los siguientes detalles. Nombre del proyecto: SpringMVCSecruityMavenRolesApp2. Use el mismo archivo pom.xml de mi publicación anterior con los siguientes cambios

<artifactId>SpringMVCSecruityMavenRolesApp</artifactId>

<build>
  <finalName>SpringMVCSecruityMavenRolesApp</finalName>
</build>
</project>

  1. Utilice todos los archivos Java y JSP de mi publicación anterior. Discutiremos solo el contenido actualizado o recién agregado aquí.
  2. Actualice el archivo LoginSecurityConfig.java para configurar roles de usuario como \USUARIO y \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"); 
		
	}
}

Código Explicación

  1. En el método configureGlobal(), hemos agregado dos usuarios: un usuario con la función \ROLE_USER y otro usuario con las funciones \ROLE_USER y \ROLE_ADMIN. Eso significa que este segundo usuario actuará como usuario administrador Así podemos configurar cualquier número de usuarios y roles.
  2. Podemos usar métodos de autoridad (ROLE) o roles (ROLE) para configurar roles en nuestra aplicación.
  3. Diferencia entre los métodos de las autoridades() y los roles():

  • autoridades() necesita un nombre de rol completo como \ROLE_USER”
  • roles() necesita un nombre de función como \USUARIO. Automáticamente agregará el valor \ROL_ a este nombre de función \USUARIO.

  1. En el método configure(), hemos definido diferentes URL con los roles de acceso requeridos.

antMatchers("/homePage")
   .access("hasRole('ROLE_USER') or hasRole('ROLE_ADMIN')")

Este fragmento de código configura que \/homePage está disponible para los roles de USUARIO y ADMIN.

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

Este fragmento de código configura que \/userPage” sea accesible solo por la función \USUARIO y .\/adminPage solo sea accesible por la función \ADMIN. Si otros roles acceden a estas páginas, obtendremos el mensaje de error \403 Acceso denegado.

  1. Actualice el archivo del controlador LoginController.java para definir nuevas rutas de acceso a URL como se muestra a continuación. 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;
	}

}

Código Explicación Además del ejemplo de la publicación anterior, aquí hemos agregado dos nuevas URL más.

  1. \/userPage” es utilizado por el rol de USUARIO para acceder y realizar actividades de usuario normales.
  2. \/adminPage” es utilizado por el rol ADMIN para acceder y realizar actividades de usuario administrador. El rol ADMIN también puede acceder a la URL \/userPage.
  3. Se actualizó el archivo homePage.jsp para proporcionar actividades específicas de roles de usuario y administrador. 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>

Aquí hemos agregado tres opciones similares a Menú en el marco superior. \Cerrar sesión ya se discutió en mi publicación anterior. Los dos nuevos enlaces son:

  1. Usuario de JD: Accesible por los roles \USUARIO” y \ADMINISTRADOR
  2. Administrador de JD: Accesible solo por ambos roles de \ADMIN

NOTA: - En las aplicaciones en tiempo real, solo mostraremos el enlace \Usuario de JD” a la función \USUARIO y ocultaremos el enlace \Administrador de JD. para ver el mensaje de error exacto, no hemos ocultado este enlace.20. Agregue un nuevo archivo adminPage.jsp para que actúe como una página de inicio para el rol \ADMIN.

<%@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. Agregue un nuevo archivo userPage.jsp para que actúe como una página de inicio para el rol \USUARIO. páginausuario.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>

Hemos completado el desarrollo de nuestra aplicación ahora. Es hora de ver la estructura final de nuestro proyecto y probar la aplicación.26. La estructura final del proyecto se ve así:

Prueba de aplicación de ejemplo de roles de seguridad de Spring

Eso es todo sobre el ejemplo de roles de seguridad de Spring para proporcionar acceso autorizado a las páginas de aplicaciones web.