Heute lernen wir ein Beispiel für den Login bei Spring Security kennen
Bevor Sie diesen Beitrag lesen, gehen Sie bitte durch meinen vorherigen Beitrag bei „Einführung in Spring 4 Security“, um einige Grundlagen zu erhalten.
Spring Security Login Logout Beispiel
In diesem Beitrag werden wir eine Spring 4 MVC Security Webanwendung entwickeln, um Login- und Logout-Funktionen mit der In-Memory-Option zu bieten. Dieses Beispiel verwendet Spring Java Config mit Spring Annotations, das heißt ohne Verwendung von web.xml und Spring XML Configuration (Alter Stil). Wenn Sie nicht mit dem Spring 3.x Security Modul vertraut sind, lesen Sie bitte zuerst die folgenden Beiträge, um das Spring Security Rezept kennenzulernen.
Spring MVC Security Beispiel mit In-Memory, UserDetailsService und JDBC-Authentifizierung
Spring Security in Servlet-Webanwendung mit DAO, JDBC, In-Memory-Authentifizierung
Das Spring 4 Security Modul unterstützt die folgenden Optionen zum Speichern und Verwalten von Benutzeranmeldedaten:
- In-Memory-Speicher
- Relationsdatenbanken (RDBMS)
- No SQL Datenstores
- LDAP
Wir werden in diesem Beispiel die Option „In-Memory Store“ verwenden. Wir werden die anderen Optionen in meinen kommenden Beiträgen besprechen. Wir werden Spring 4.0.2.RELEASE, Spring STS 3.7 Suite IDE, Spring TC Server 3.1 mit Java 1.8 und Maven Build-Tool verwenden, um dieses Beispiel zu entwickeln.
Spring Security Login Beispiel
Wir werden eine Login- und Logout-Logik mit Spring 4 Security Features entwickeln. Das Hauptziel dieser Anwendung ist es, eine Anwendung zu entwickeln, ohne „web.xml“ zu verwenden und ohne eine einzige Zeile Spring XML Beans Configuration zu schreiben. Das bedeutet, dass wir das Spring Java Config-Feature mit Spring Annotations verwenden werden. Wir werden diese Anwendung mit den folgenden Funktionen entwickeln:
- Willkommensseite
- Login-Seite
- Startseite
- Logout-Funktion
Bitte verwenden Sie die folgenden Schritte, um dieses Spring 4 Security Simple Login Beispiel zu entwickeln und zu erkunden.
Erstellen Sie ein „Einfaches Spring Web Maven“ Projekt in Spring STS Suite mit den folgenden Details
Projektname: SpringMVCSecurityMavenApp
Aktualisieren Sie 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>SpringMVCSecurityMavenApp</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>SpringMVCSecurityMavenApp</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 sich nicht über das Flag „<failOnMissingWebXml>“ im Klaren sind, lesen Sie bitte am Ende dieses Beitrags, um ein gutes Verständnis für die Verwendung dieses Elements zu erhalten.
Entwickeln Sie zuerst einen Login-Controller mit Spring’s @Controller-Annotation
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", "Ungültige Anmeldeinformationen bereitgestellt.");
}
if (logout != null) {
model.addObject("message", "Erfolgreich von JournalDEV abgemeldet.");
}
model.setViewName("loginPage");
return model;
}
}
Code-Erklärung: Wir haben drei Methoden in „LoginController“ definiert, um drei verschiedene Arten von Client-Anfragen zu behandeln…
- welcomePage() wird alle Client-Anfragen behandeln, die die URI „/“ verwenden.
- homePage() wird alle Client-Anfragen behandeln, die die URI „/homePage“ verwenden.
- loginPage() wird alle Client-Anfragen behandeln, die die URI „/loginPage“ verwenden.
In loginPage() haben wir uns um die Behandlung von Fehler- und Abmelde-Nachrichten gekümmert.
Entwickeln Sie dann eine Klasse „LoginSecurityConfig“, um Login- und Logout-Sicherheitsfunktionen mit Spring 4 Security API bereitzustellen
LoginSecurityConfig.java
package com.journaldev.spring.security.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 um Login- und Logout-Sicherheitsfunktionen zu übernehmen.
- @EnableWebSecurity Annotation wird verwendet, um die Web-Sicherheit in jeder Webanwendung zu aktivieren.
- @EnableWebMVCSecurity Annotation wird verwendet, um die Web-Sicherheit in einer auf Spring MVC basierenden Webanwendung zu aktivieren.
HINWEIS: @EnableWebSecurity = @EnableWebMVCSecurity + Zusatzfunktionen. Deshalb ist die Annotation @EnableWebMVCSecurity in Spring 4.x Framework veraltet.
Die Klasse „LoginSecurityConfig“ oder jede andere Klasse, die zur Konfiguration von Spring Security bestimmt ist, sollte die Klasse „WebSecurityConfigurerAdapter“ erweitern oder ein entsprechendes Interface implementieren.
Die Methode configureGlobal() wird verwendet, um Benutzeranmeldeinformationen zu speichern und zu verwalten.
In der Methode configureGlobal() können wir die Methode authorities() verwenden, um unsere Anwendungsrollen wie „ROLE_USER“ zu definieren. Wir können auch die Methode roles() für denselben Zweck verwenden.
Unterschied zwischen den Methoden authorities() und roles(): authorities() benötigt einen kompletten Rollennamen wie „ROLE_USER“; roles() benötigt einen Rollennamen wie „USER“. Es wird automatisch „ROLE_“ zum Rollennamen „USER“ hinzugefügt.
HINWEIS: Wir werden ein weiteres Beispiel entwickeln, um Rollen wie „USER“, „ADMIN“ in meinen kommenden Beiträgen zu demonstrieren.
Wichtige Methode zur Behandlung von Login- und Logout-Sicherheit ist configure(HttpSecurity http)
Der folgende Codeausschnitt wird verwendet, um unberechtigten Zugriff auf „/homePage“ zu vermeiden. 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 Aufruf der Methode access(„hasRole(‚ROLE_USER‘)“) entfernen, können wir auf diese Seite zugreifen, ohne uns in unserer Anwendung anzumelden.
13. Wir haben Login- und Logout-Funktionen mit den Methoden formLogin() und logout() konfiguriert.
Aktivieren Sie die Spring MVC-Konfiguration LoginApplicationConfig.java
package com.journaldev.spring.security.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 Resolvers zu definieren, um das Schreiben der „web.xml“-Datei zu vermeiden.
- @EnableWebMvc Annotation wird verwendet, um die Spring Web MVC-Anwendungsfunktionen im Spring Framework zu aktivieren.
- @Import Annotation wird verwendet, um die Spring Security-Konfigurationsklasse in diese Klasse zu importieren.
- @ComponentScan Annotation wird verwendet, um die Komponentensuche im angegebenen Paket durchzuführen. Es entspricht „context:component-scan“ in der Spring XML-Konfiguration.
Initialisieren Sie Spring Security
package com.journaldev.spring.security.config.core;
package com.journaldev.spring.security.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 web.xml-Datei.
Initialisieren Sie die Spring MVC-Anwendung
Die Klasse „SpringMVCWebAppInitializer“ wird verwendet, um „DispatcherServlet“ ohne web.xml-Datei in einer auf Annotationen basierenden Konfiguration zu initialisieren.
SpringMVCWebAppInitializer.java
package com.journaldev.spring.security.config.core;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import com.journaldev.spring.security.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: Wenn wir auf unsere Anwendung zugreifen, ermöglicht SpringMVCWebAppInitializer’s getServletMappings() standardmäßig den Zugriff auf die Root-URL „/“. Wir können überschreiben, um an eine andere URL weiterzuleiten. Das Spring- oder Pivotal-Team arbeitet an diesem Problem, um diesen Java-Code durch die Einführung einer Annotation zu vermeiden. Bitte überprüfen Sie dies unter https://jira.spring.io/browse/SPR-10359.
Entwickeln Sie die welcomePage.jsp-Datei
<h3>Willkommen bei JournalDEV Tutorials</h3>
<a href="${pageContext.request.contextPath}/loginPage">Anmelden bei Journal</a>
Entwickeln Sie die loginPage.jsp-Datei
<%@ 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>Benutzername:</td>
<td><input type='text' name='username' value=''></td>
</tr>
<tr>
<td>Passwort:</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 homepage.jsp-Datei
<%@taglib prefix="c" uri="https://java.sun.com/jsp/jstl/core"%>
<h3>Willkommen bei 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()">Abmelden</a>
</c:if>
Die endgültige Projektstruktur sieht wie folgt aus:
Starten Sie das Spring Security MVC Login Logout-Beispiel
Starten Sie das Spring Security MVC Login Logout-BeispielUm diese Spring Webanwendung auszuführen, benötigen wir einen Web-Container, der Spring 4 und Java 8-Umgebungen mit Servlet 3.1.0-Container unterstützt.
Bereitstellen und Ausführen auf Spring TC Server in Spring STS Suite
Es greift automatisch auf die Willkommensseite unserer Anwendung zu, wie unten gezeigt.
– Klicken Sie auf den Link „Anmelden bei JournalDEV“, um zur Anmeldeseite zu gelangen. Spring 4 MVC
– Geben Sie nun falsche Anmeldedaten ein und klicken Sie auf die Schaltfläche „Anmelden“.
Hier können wir die Fehlermeldung beobachten: „Ungültige Anmeldeinformationen bereitgestellt.“ Geben Sie nun die korrekten Anmeldedaten ein, die in der Klasse „LoginSecurityConfig“ konfiguriert sind.
Nach erfolgreicher Anmeldung in unserer Anwendung können wir unsere Anwendungs-Startseite mit dem Link „Abmelden“ sehen. Klicken Sie auf den Link „Abmelden“, um sich von der Anwendung abzumelden.
Hier können wir beobachten, dass wir erfolgreich aus unserer Anwendung abgemeldet wurden und wieder zur Anmeldeseite umgeleitet wurden. Wir können einige Abmeldeerfolgsmeldungen auf dieser Anmeldeseite sehen.
Hinweis zu Maven und web.xml
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 es sie nicht in der Anwendung findet. Um Maven-bezogene Probleme zu vermeiden, müssen wir das Flag „<failOnMissingWebXml>“ in der pom.xml-Datei konfigurieren.
Das war’s zu Spring 4 Security Module Simple Example. Wir werden in meinen kommenden Beiträgen einige weitere praxisnahe Beispiele entwickeln, wie das Verwalten von Rollen, Remember-Me-Funktion, WebSocket-Sicherheit und mehr. Bitte hinterlassen Sie mir einen Kommentar, wenn Ihnen mein Beitrag gefällt oder wenn Sie irgendwelche Probleme/Vorschläge haben – ein umfassender Leitfaden.
