Spring-Sicherheitsrollenbasiertes Zugriffsberechtigungsbeispiel

Tutorials
Spring

Heute werden wir uns ein Beispiel für rollenbasierten Zugriff und Autorisierung in der Frühlingssicherheit anschauen. Bevor Sie diesen Beitrag lesen, lesen Sie bitte meinen vorherigen Beitrag über „Spring 4 Security MVC Login Logout Example“, um grundlegende Kenntnisse über Spring 4 Security zu erhalten.

Spring Security Rolle

In diesem Beitrag werden wir besprechen, wie man Spring Security Rollen wie „USER“ und „ADMIN“ in einer Spring-Webanwendung definiert, verwendet und verwaltet. Wie in meinem vorherigen Beitrag wird dieses Beispiel auch Spring 4 MVC Security mit In-Memory Store und der Spring Java Configuration Feature verwenden, um die Anwendung zu entwickeln. Das bedeutet, dass wir keine web.xml-Datei verwenden und auch keine einzige Zeile Spring XML-Konfiguration schreiben werden. Wir werden die Option „In-Memory Store“ verwenden, um Benutzeranmeldeinformationen zu speichern und zu verwalten. Wir werden Spring 4.0.2.RELEASE, Spring STS 3.7 Suite IDE, Spring TC Server 3.1 mit Java 1.8 und das Maven-Build-Tool verwenden, um dieses Beispiel zu entwickeln.

Spring Security rollenbasierter Zugriff und Autorisierung Beispiel

  1. Erstellen Sie ein „Simple Spring Web Maven“ Projekt in der Spring STS Suite mit folgenden Details.
    Projektname: SpringMVCSecruityMavenRolesApp2. Verwenden Sie dieselbe pom.xml Datei wie in meinem vorherigen Beitrag mit den folgenden Änderungen.
<artifactId>SpringMVCSecruityMavenRolesApp</artifactId>

<build>
  <finalName>SpringMVCSecruityMavenRolesApp</finalName>
</build>
</project>
  1. Verwenden Sie alle Java- und JSP-Dateien aus meinem vorherigen Beitrag. Hier besprechen wir nur aktualisierten oder neu hinzugefügten Inhalt.
  2. Aktualisieren Sie die Datei LoginSecurityConfig.java, um Benutzerrollen wie „USER“ und „ADMIN“ zu konfigurieren.
    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"); 
		
	}
}

Begruendung des Codes

  1. In der Methode configureGlobal() haben wir zwei Benutzer hinzugefügt: Einen Benutzer mit der Rolle „ROLE_USER“ und einen weiteren Benutzer mit den Rollen „ROLE_USER“ und „ROLE_ADMIN“. Das bedeutet, dass dieser zweite Benutzer als Administrator fungiert. Auf diese Weise können wir beliebig viele Benutzer und Rollen konfigurieren.
  2. Wir können entweder die Methoden authorities(ROLE) oder roles(ROLE) verwenden, um Rollen in unserer Anwendung zu konfigurieren.
  3. Unterschied zwischen den Methoden authorities() und roles():
  • authorities() benötigt den vollständigen Rollennamen wie „ROLE_USER“
  • roles() benötigt den Rollennamen wie „USER“. Es fügt automatisch den Wert „ROLE_“ zu diesem Rollennamen „USER“ hinzu.
  1. In der Methode configure() haben wir verschiedene URLs mit den erforderlichen Zugriffsrollen definiert.
antMatchers("/homePage")
   .access("hasRole('ROLE_USER') or hasRole('ROLE_ADMIN')")

Dieser Code-Ausschnitt konfiguriert, dass „/homePage“ für Benutzer- und Administratorrollen verfügbar ist.

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

Dieser Code-Ausschnitt konfiguriert, dass „/userPage“ nur von der Benutzerrolle zugänglich ist und „/adminPage“ nur von der Administratorrolle zugänglich ist. Wenn andere Rollen auf diese Seiten zugreifen, erhalten wir die Fehlermeldung „403 Zugriff verweigert“.

  1. Aktualisieren Sie die Datei LoginController.java Controller, um neue URL-Zugriffspfade wie unten gezeigt zu definieren.
    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;
	}

}

Code-Erklärung Zusätzlich zum vorherigen Beitrag Beispiel haben wir hier zwei neue URLs hinzugefügt.

  1. „/userPage“ wird von der USER-Rolle genutzt, um Zugang zu erhalten und normale Benutzeraktivitäten auszuführen.

  2. „/adminPage“ wird von der ADMIN-Rolle genutzt, um Zugang zu erhalten und Admin-Benutzeraktivitäten auszuführen. Die ADMIN-Rolle kann auch auf die URL „/userPage“ zugreifen.

  3. Aktualisierte Datei homePage.jsp, um spezifische Aktivitäten für Benutzer- und Admin-Rollen bereitzustellen.
    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>

Hier haben wir drei Menü-ähnliche Optionen im oberen Rahmen hinzugefügt. „Logout“ wurde bereits in meinem vorherigen Beitrag besprochen. Die zwei neuen Links sind:

  1. JD Benutzer: Zugänglich sowohl für „USER“ als auch „ADMIN“ Rollen
  2. JD Admin: Zugänglich nur für „ADMIN“ Rollen

HINWEIS:- In Echtzeit-Anwendungen wird nur der Link „JD Benutzer“ für die „USER“ Rolle angezeigt und der Link „JD Admin“ versteckt. Um zu testen, ob es von der „USER“ Rolle aus zugänglich ist oder nicht und auch um die genaue Fehlermeldung zu sehen, haben wir diesen Link nicht versteckt.20. Fügen Sie eine neue Datei adminPage.jsp hinzu, um als Homepage für die „ADMIN“ Rolle zu fungieren.
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. Fügen Sie eine neue Datei userPage.jsp hinzu, um als Startseite für die Rolle „USER“ zu fungieren.
    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>

Wir haben jetzt die Entwicklung unserer Anwendung abgeschlossen. Es ist Zeit, die endgültige Struktur unseres Projekts zu sehen und die Anwendung zu testen. Die endgültige Projektstruktur sieht wie folgt aus:

Spring Security Rollen Beispielanwendungstest

  1. Bitte klicken Sie mit der rechten Maustaste auf das Projekt in der Spring STS IDE und wählen Sie die Option „Ausführen als >> Auf Server ausführen“. Es wird die Standardanwendungsbegrüßungsseite wie unten gezeigt öffnen: 3. Klicken Sie auf den Link „Login to JournalDEV“. Jetzt befinden Sie sich auf der Anmeldeseite.
    5. Melden Sie sich zunächst mit den Anmeldeinformationen für die Rolle „USER“ an:
    Benutzername: jduser Passwort: jdu@123 Jetzt sehen wir die Anwendungs-Homepage mit 3 Menüoptionen: „JD Benutzer“, „JD Admin“ und „Logout“. Klicken Sie auf den Link „JD Benutzer“. Da wir uns mit den Anmeldeinformationen für die Rolle „USER“ angemeldet haben, können wir auf diesen Link zugreifen, wie unten gezeigt. Verwenden Sie einfach den Rückwärtspfeil in der Spring STS IDE und klicken Sie diesmal auf den Link „JD Admin“. Da wir uns mit den Anmeldeinformationen für die Rolle „USER“ angemeldet haben, können wir nicht auf diesen Link zugreifen. Deshalb sehen wir diese Fehlermeldung: „403 Der Zugriff wurde verweigert“. 9. Jetzt abgemeldet und erneut mit den Anmeldeinformationen für die Rolle „ADMIN“ anmelden
    Benutzername: jdadmin Passwort: jda@123 Diesmal können wir erfolgreich auf den Link „JD Admin“ zugreifen, wie unten gezeigt. Testen Sie den Link „Logout“, um sich von der Anwendung abzumelden.

{
„error“: „Upstream error…“
}

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