Spring 4 Security MVC Login Logout-Beispiel

Tutorials
Spring

Heute werden wir über das Beispiel Spring Security Login sprechen. Bevor Sie diesen Beitrag lesen, sollten Sie meinen vorherigen Beitrag mit dem Titel „Einführung in Spring 4 Security“ lesen, um einige Grundlagen zu verstehen.

Spring Security Login Logout Beispiel

In diesem Beitrag werden wir eine Webanwendung Spring 4 MVC Security entwickeln, um Login- und Logout-Funktionen über die In-Memory-Option bereitzustellen. Dieses Beispiel verwendet Spring Java Config mit Spring Annotations, d.h. ohne die Verwendung von web.xml und Spring XML Configuration (alter Stil). Wenn Sie mit dem Spring 3.x Security Modul nicht vertraut sind, lesen Sie bitte zuerst die folgenden Beiträge, um das Spring Security Rezept kennenzulernen.

  1. Spring MVC Security Beispiel mit In-Memory-, UserDetailsService- und JDBC-Authentifizierung
  2. Spring Security in Servlet Webanwendung mit DAO, JDBC und In-Memory-Authentifizierung

Das Spring 4 Security Modul unterstützt die folgenden Optionen zum Speichern und Verwalten von Benutzeranmeldeinformationen:

  1. In-Memory-Speicher
  2. Relationale Datenbanken (RDBMS)
  3. NoSQL-Datenbanken
  4. LDAP

Wir werden die Option „In-Memory Store“ in diesem Beispiel verwenden. Wir werden in meinen kommenden Beiträgen andere Optionen besprechen. 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 Login Beispiel

Wir werden eine Anmelde- und Abmelde-Logik unter Verwendung der Sicherheitsfunktionen von Spring 4 entwickeln. Das Hauptziel dieser Anwendung ist es, eine Anwendung zu entwickeln, ohne „web.xml“ zu verwenden und ohne eine einzige Zeile Spring XML Beans-Konfiguration zu schreiben. Das bedeutet, wir werden die Funktion Spring Java Config mit Spring-Annotationen verwenden. Wir werden diese Anwendung mit den folgenden Funktionen entwickeln:

  1. Startseite
  2. Anmeldeseite
  3. Startseite
  4. Abmeldefunktion

Bitte verwenden Sie die folgenden Schritte, um dieses einfache Anmeldebeispiel für Spring 4 Security zu entwickeln und zu erkunden.

  • Erstellen Sie ein „Simple Spring Web Maven“-Projekt in Spring STS Suite mit den folgenden Details
   Project Name : SpringMVCSecruityMavenApp
  • Aktualisieren Sie die pom.xml mit dem folgenden Inhalt
<?xml version="1.0" encoding="UTF-8"?>
<project
   xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 
   https://maven.apache.org/xsd/maven-4.0.0.xsd"
   xmlns="https://maven.apache.org/POM/4.0.0" 
   xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance">

	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev</groupId>
	<artifactId>SpringMVCSecruityMavenApp</artifactId>
	<packaging>war</packaging>
	<version>1.0</version>

	<properties>
	    <java.version>1.8</java.version>
	    <spring.version>4.0.2.RELEASE</spring.version>
	    <spring.security.version>4.0.2.RELEASE</spring.security.version>
	    <servlet.api.version>3.1.0</servlet.api.version>
	    <jsp.api.version>2.2</jsp.api.version>
	    <jstl.version>1.2</jstl.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-web</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-config</artifactId>
			<version>${spring.security.version}</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>${servlet.api.version}</version>
		</dependency>		
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>${jsp.api.version}</version>
		</dependency>
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl.version}</version>
		</dependency>
	</dependencies>	

	<build>
	    <finalName>SpringMVCSecruityMavenApp</finalName>
	    <plugins>
		<plugin>
		     <groupId>org.apache.maven.plugins</groupId>
		     <artifactId>maven-compiler-plugin</artifactId>
		     <version>3.1</version>
		     <configuration>
			<source>${java.version}</source>
			<target>${java.version}</target>
		     </configuration>
		</plugin>
		<plugin>
	           <groupId>org.apache.maven.plugins</groupId>
	           <artifactId>maven-war-plugin</artifactId>
	           <configuration>
	              <failOnMissingWebXml>false</failOnMissingWebXml>
	           </configuration>           
        	</plugin>
	    </plugins>
	</build>
</project>

HINWEIS:- Wenn Sie nicht mit der Flagge „<failOnMissingWebXml>“ vertraut sind, lesen Sie bitte am Ende dieses Beitrags, um ein gutes Verständnis für die Verwendung dieses Elements zu erhalten.- Entwickeln Sie zunächst den Login-Controller, indem Sie die Annotation @Controller von Spring verwenden.
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 = "/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:- Wir haben drei Methoden in „LoginController“ definiert, um drei verschiedene Arten von Client-Anfragen zu behandeln.

  1. welcomePage() wird alle Client-Anfragen behandeln, die die URI „/“ verwenden.
  2. homePage() wird alle Client-Anfragen behandeln, die die URI „/homePage“ verwenden.
  3. loginPage() wird alle Client-Anfragen behandeln, die die URI „/loginPage“ verwenden.
  4. Im loginPage() haben wir darauf geachtet, Fehler- und Logout-Nachrichten zu behandeln.
  • Dann entwickeln Sie eine Klasse „LoginSecurityConfig“, um Login- und Logout-Sicherheitsfunktionen mit der Spring 4 Security API bereitzustellen.
    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("journaldev")
			.password("jd@123")
			.authorities("ROLE_USER");
	}
	
	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http.authorizeRequests()
			.antMatchers("/homePage").access("hasRole('ROLE_USER')")
			.and()
				.formLogin().loginPage("/loginPage")
				.defaultSuccessUrl("/homePage")
				.failureUrl("/loginPage?error")
				.usernameParameter("username").passwordParameter("password")				
			.and()
				.logout().logoutSuccessUrl("/loginPage?logout"); 
		
	}
}

Code Erklärung:- Wir haben zwei Methoden in „LoginSecurityConfig“ definiert, um Benutzeranmeldeinformationen zu speichern und zu verwalten und sich um Login- und Logout-Sicherheitsfunktionen zu kümmern.

  1. @EnableWebSecurity Annotation wird verwendet, um die Web-Sicherheit in jeder Webanwendung zu aktivieren.
  2. @EnableWebMVCSecurity„` Annotation wird verwendet, um die Web-Sicherheit in einer auf Spring MVC basierenden Webanwendung zu aktivieren. „`NOTE:-„` „`@EnableWebSecurity„` = „`@EnableWebMVCSecurity„` + Zusätzliche Funktionen. Aus diesem Grund ist die „`@EnableWebMVCSecurity„` Annotation im Spring 4.x-Framework veraltet. Die Klasse „LoginSecurityConfig“ oder jede Klasse, die für die Konfiguration der Spring Security vorgesehen ist, sollte die Klasse „WebSecurityConfigurerAdapter“ erweitern oder die entsprechende Schnittstelle implementieren. „`
  3. „`Die Methode „`configureGlobal()„` wird verwendet, um Benutzeranmeldeinformationen zu speichern und zu verwalten. „`
  4. „`In der Methode „`configureGlobal()„` können wir die Methode „`authorities()„` verwenden, um die Rollen unserer Anwendung wie „ROLE_USER“ zu definieren. Wir können auch die Methode „`roles()„` für denselben Zweck verwenden. „`
  5. „`Unterschied zwischen den Methoden „`authorities()„` und „`roles()„`: „`
  6. „`Die Methode „`authorities()„` benötigt einen vollständigen Rollennamen wie „ROLE_USER“, während „`roles()„` einen Rollennamen wie „USER“ benötigt. Es fügt automatisch den Wert „ROLE_“ zu diesem Rollennamen „USER“ hinzu. „`NOTE:-„` Wir werden ein weiteres Beispiel entwickeln, um Rollen wie „USER“, „ADMIN“ in meinen kommenden Beiträgen zu demonstrieren. „`
  7. „`Wichtige Methode zur Sicherung von Login- und Logout-Sicherheit ist „`configure(HttpSecurity http)„` „`
  8. „`Der folgende Code-Schnipsel wird verwendet, um den unbefugten Zugriff auf „/homePage“ zu verhindern. Wenn Sie versuchen, auf diese Seite direkt zuzugreifen, werden Sie automatisch auf die Seite „/loginPage“ umgeleitet.
.antMatchers("/homePage").access("hasRole('ROLE_USER')")

Wenn wir den access(„hasRole(‚ROLE_USER‘)“)-Methodenaufruf entfernen, können wir auf diese Seite zugreifen, ohne uns bei unserer Anwendung anzumelden.13. Wir haben die Anmelde- und Abmeldefunktionen mit den Methoden formLogin() und logout() konfiguriert.

  • Aktivieren Sie die Spring MVC-Konfiguration
    LoginApplicationConfig.java
package com.journaldev.spring.secuity.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;

@EnableWebMvc
@Configuration
@ComponentScan({ "com.journaldev.spring.*" })
@Import(value = { LoginSecurityConfig.class })
public class LoginApplicationConfig {
	@Bean
	public InternalResourceViewResolver viewResolver() {
		InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
		viewResolver.setViewClass(JstlView.class);
		viewResolver.setPrefix("/WEB-INF/views/");
		viewResolver.setSuffix(".jsp");
		return viewResolver;
	}
	
}

Code-Erklärung:- Wir verwenden die Klasse „LoginApplicationConfig“, um Spring MVC View Resolver zu definieren, um das Schreiben der Datei „web.xml“ zu vermeiden.

  1. @EnableWebMvc Annotation wird verwendet, um die Funktionen der Spring Web MVC-Anwendung im Spring Framework zu aktivieren.
  2. @Import Annotation wird verwendet, um die Spring Security-Konfigurationsklasse in diese Klasse zu importieren.
  3. @ComponentScan Annotation wird verwendet, um eine Komponentensuche im angegebenen Paket durchzuführen. Es entspricht „context:component-scan“ in der Spring XML-Konfiguration.
  • Initialisieren Sie die Spring Security
package com.journaldev.spring.secuity.config.core;

import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;

public class SpringSecurityInitializer extends AbstractSecurityWebApplicationInitializer {

}

„SpringSecurityInitializer“ wird verwendet, um den DelegatingFilterProxy zu registrieren, um die springSecurityFilterChain zu verwenden. Es vermeidet das Schreiben von Filterkonfigurationen in der Datei web.xml.- Initialisieren Sie die Spring MVC-Anwendung
Die Klasse „SpringMVCWebAppInitializer“ wird verwendet, um „DispatcherServlet“ ohne web.xml-Datei in einer Annotation basierten Konfiguration zu initialisieren. SpringMVCWebAppInitializer.java

package com.journaldev.spring.secuity.config.core;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import com.journaldev.spring.secuity.config.LoginApplicationConfig;

public class SpringMVCWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

	@Override
	protected Class<?>[] getRootConfigClasses() {
		return new Class[] { LoginApplicationConfig.class };
	}

	@Override
	protected Class<?>[] getServletConfigClasses() {
		return null;
	}

	@Override
	protected String[] getServletMappings() {
		return new String[] { "/" };
	}
	
}

HINWEIS:-

  1. Wenn wir auf unsere Anwendung zugreifen, ermöglicht die Methode getServletMappings() von SpringMVCWebAppInitializer standardmäßig den Zugriff auf die Root-URL: „/“. Wir können dies überschreiben, um zu einer anderen URL weiterzuleiten.
  2. Das Spring- oder Pivotal-Team arbeitet an diesem Problem, um den Java-Code durch die Einführung einer Annotation zu reduzieren. Bitte überprüfen Sie dies unter https://jira.spring.io/browse/SPR-10359.
  • Entwickeln Sie die Datei welcomePage.jsp
<h3>Welcome to JournalDEV Tutorials</h3>
<a href="${pageContext.request.contextPath}/loginPage">Login to Journal</a>
  • Entwickeln Sie die Datei loginPage.jsp
<%@ taglib prefix="c" uri="https://java.sun.com/jsp/jstl/core"%>
<html>
<body onload='document.loginForm.username.focus();'>
	<h3>JournalDEV Tutorials</h3>

	<c:if test="${not empty error}"><div>${error}</div></c:if>
	<c:if test="${not empty message}"><div>${message}</div></c:if>

	<form name='login' action="<c:url value='/loginPage' />" method='POST'>
		<table>
			<tr>
				<td>UserName:</td>
				<td><input type='text' name='username' value=''></td>
			</tr>
			<tr>
				<td>Password:</td>
				<td><input type='password' name='password' /></td>
			</tr>
			<tr>
				<td colspan='2'><input name="submit" type="submit" value="submit" /></td>
			</tr>
		</table>
		<input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}" />
	</form>
</body>
</html>
  • Entwickeln Sie die Datei homepage.jsp
<%@taglib prefix="c" uri="https://java.sun.com/jsp/jstl/core"%>
<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>
<c:if test="${pageContext.request.userPrincipal.name != null}">
	<a href="javascript:document.getElementById('logout').submit()">Logout</a>
</c:if>
  • Die endgültige Projektstruktur sieht wie folgt aus:

Führen Sie das Beispiel für die Spring Security MVC-Anmeldung und -Abmeldung aus

Um diese Spring-Webanwendung auszuführen, benötigen wir einen Webcontainer, der Spring 4 und Java 8 in der Umgebung mit Servlet 3.1.0 unterstützt.

  • Bereitstellen und Ausführen auf dem Spring TC Server in der Spring STS Suite
  • Es greift automatisch auf unsere Anwendungsbegrüßungsseiten-URL zu, wie unten gezeigt.
    – Klicken Sie auf den Link „Bei JournalDEV anmelden“, um zur Anmeldeseite zu gelangen.
    – Geben Sie nun falsche Anmeldeinformationen ein und klicken Sie auf die Schaltfläche „Anmelden“.
    Hier können wir diese Fehlermeldung beobachten: „Ungültige Anmeldeinformationen bereitgestellt.“- Geben Sie nun die korrekten Anmeldeinformationen ein, die in der Klasse „LoginSecurityConfig“ konfiguriert sind.
    Nach erfolgreichem Anmelden bei unserer Anwendung sehen wir unsere Anwendungs-Homepage mit dem Link „Abmelden“.- Klicken Sie auf den Link „Abmelden“, um sich von der Anwendung abzumelden.
    Hier können wir beobachten, dass wir erfolgreich von unserer Anwendung abgemeldet wurden und erneut zur Anmeldeseite weitergeleitet wurden. Wir können einige erfolgreiche Abmeldemeldungen auf dieser Anmeldeseite beobachten.

HINWEIS:- Wenn wir dieses Beispiel betrachten, verwenden wir die web.xml-Datei nicht richtig. Da es sich um eine Webanwendung handelt, sucht Maven nach der web.xml-Datei und meldet einige Fehler, wenn sie nicht in der Anwendung gefunden wird. Um Maven-bezogene Probleme zu vermeiden, müssen wir das Flag „failOnMissingWebXml“ in der pom.xml-Datei konfigurieren. Das ist alles zum Spring 4 Security Module Simple Example. Wir werden in meinen kommenden Beiträgen einige weitere Echtzeit-Beispiele entwickeln, wie das Verwalten von Rollen, die Remember-Me-Funktion, die WebSocket-Sicherheit und mehr. Bitte hinterlassen Sie mir einen Kommentar, wenn Ihnen mein Beitrag gefällt oder wenn Sie Probleme/Vorschläge haben.

Source:
https://www.digitalocean.com/community/tutorials/spring-4-security-mvc-login-logout-example