Voorbeeld van Spring 4 Security MVC Inloggen en Uitloggen

Handleidingen
Spring

Vandaag zullen we leren over het Voorbeeld van Spring Security Inloggen. Voordat je dit bericht leest, ga alsjeblieft door mijn vorige bericht op “Inleiding tot Spring 4 Beveiliging” om wat basisprincipes te krijgen.

Voorbeeld van Spring Security Inloggen en Uitloggen

In dit bericht gaan we een Spring 4 MVC Beveiligde Web Applicatie ontwikkelen om Inlog- en Uitlogfuncties te bieden door gebruik te maken van de In-Memory optie. Dit voorbeeld maakt gebruik van Spring Java Config met Spring-annotaties, dat wil zeggen zonder gebruik te maken van web.xml en Spring XML-configuratie (oude stijl). Als je niet bekend bent met de Spring 3.x Beveiligingsmodule, ga dan eerst door de volgende berichten om de Spring Security-methode te proeven.

  1. Voorbeeld van Spring MVC Beveiliging met in-memory, UserDetailsService en JDBC Authenticatie
  2. Spring Security in Servlet Web Applicatie met DAO, JDBC, In-Memory authenticatie

De Spring 4 Beveiligingsmodule ondersteunt de volgende opties om Gebruikersreferenties op te slaan en te beheren:

  1. In-Memory Opslag
  2. Relationele Databases (RDBMS)
  3. NoSQL Databanken
  4. LDAP

We zullen de optie “In-Memory Store” gebruiken in dit voorbeeld. We zullen andere opties in mijn komende posts bespreken. We gaan Spring 4.0.2.RELEASE, Spring STS 3.7 Suite IDE, Spring TC Server 3.1 met Java 1.8 en Maven build tool gebruiken om dit voorbeeld te ontwikkelen.

Voorbeeld van Spring Security Login

We gaan een inlog- en uitloglogica ontwikkelen met behulp van Spring 4-beveiligingsfuncties. Het hoofddoel van deze applicatie is het ontwikkelen van een applicatie zonder gebruik te maken van “web.xml” en zonder een enkele regel Spring XML Beans-configuratie te schrijven. Dat betekent dat we de Spring Java Config-functie met Spring Annotations gaan gebruiken. We zullen deze applicatie ontwikkelen met de volgende functies:

  1. Welkomstpagina
  2. Inlogpagina
  3. Startpagina
  4. Uitlogfunctie

Gebruik de volgende stappen om dit eenvoudige Spring 4-beveiligingsloginvoorbeeld te ontwikkelen en te verkennen.

  • Maak een “Eenvoudig Spring Web Maven”-project in Spring STS Suite met de volgende details
   Project Name : SpringMVCSecruityMavenApp
  • Update pom.xml met de volgende inhoud
<?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>

OPMERKING:- Als je niet bekend bent met de “<failOnMissingWebXml>” vlag, lees dan aan het einde van deze post om een goed begrip te krijgen van het gebruik van dit element.- Ontwikkel eerst de Login Controller door gebruik te maken van Spring’s @Controller-annotatie.
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 Uitleg:- We hebben drie methoden gedefinieerd in “LoginController” om drie verschillende soorten clientverzoeken af te handelen

  1. welcomePage() zal alle clientverzoeken afhandelen die de “/ ” URI gebruiken.
  2. homePage() zal alle clientverzoeken afhandelen die de “/homePage” URI gebruiken.
  3. loginPage() zal alle clientverzoeken afhandelen die de “/loginPage” URI gebruiken.
  4. In loginPage(), hebben we ervoor gezorgd dat fout- en uitlogberichten worden afgehandeld.
  • Vervolgens ontwikkelen we een klasse “LoginSecurityConfig” om inlog- en uitlogbeveiligingsfuncties te bieden met behulp van Spring 4 Security API.
    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 Uitleg:- We hebben twee methoden gedefinieerd in “LoginSecurityConfig” om gebruikersreferenties op te slaan en te beheren en om inlog- en uitlogbeveiligingsfuncties te bieden.

  1. @EnableWebSecurity Annotation wordt gebruikt om webbeveiliging in elke webtoepassing in te schakelen.
  2. @EnableWebMVCSecurity Annotation wordt gebruikt om webbeveiliging in Spring MVC-gebaseerde webtoepassingen in te schakelen.
    LET OP:- @EnableWebSecurity = @EnableWebMVCSecurity + Extra functies. Daarom is de @EnableWebMVCSecurity Annotation verouderd in Spring 4.x Framework.4. De klasse “LoginSecurityConfig” of een andere klasse die is aangewezen om Spring Security te configureren, moet de klasse “WebSecurityConfigurerAdapter” uitbreiden of de gerelateerde interface implementeren.
  3. De methode configureGlobal() wordt gebruikt om gebruikersreferenties op te slaan en te beheren.
  4. In de configureGlobal() methode kunnen we de authorities() methode gebruiken om onze toepassingsrollen zoals “ROLE_USER” te definiëren. We kunnen ook de roles() methode voor hetzelfde doel gebruiken.
  5. Verschil tussen de methods authorities() en roles():
  6. authorities() heeft een volledige rollenaam nodig zoals “ROLE_USER” roles() heeft een rollenaam nodig zoals “USER”. Het voegt automatisch de waarde “ROLE_” toe aan deze rollenaam “USER”. LET OP:- We zullen nog een ander voorbeeld ontwikkelen om rollen zoals “USER”, “ADMIN” te demonstreren in mijn komende berichten.
  7. Belangrijke methode om te zorgen voor beveiliging bij inloggen en uitloggen is configure(HttpSecurity http)
  8. Het volgende codefragment wordt gebruikt om ongeautoriseerde toegang tot “/homePage” te voorkomen. Als je probeert deze pagina rechtstreeks te openen, word je automatisch doorgestuurd naar de “/loginPage” pagina.
.antMatchers("/homePage").access("hasRole('ROLE_USER')")

Als we het access(“hasRole(‘ROLE_USER’)”) methodeoproep verwijderen, kunnen we deze pagina openen zonder in te loggen op onze applicatie.13. We hebben inlog- en uitlogfuncties geconfigureerd met behulp van de formLogin() en logout() methoden.

  • Spring MVC-configuratie inschakelen
    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-uitleg:- We gebruiken de klasse “LoginApplicationConfig” om Spring MVC View Resolvers te definiëren om te voorkomen dat we het bestand “web.xml” moeten schrijven.

  1. @EnableWebMvc Annotation wordt gebruikt om Spring Web MVC-toepassingsfuncties in Spring Framework in te schakelen
  2. @Import Annotation wordt gebruikt om de Spring Security Configuratieklasse in deze klasse te importeren.
  3. @ComponentScan Annotation wordt gebruikt om componentscanning uit te voeren in de opgegeven package. Het is gelijk aan “context:component-scan” in Spring XML-configuratie.
  • Spring Security initialiseren
package com.journaldev.spring.secuity.config.core;

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

public class SpringSecurityInitializer extends AbstractSecurityWebApplicationInitializer {

}

“SpringSecurityInitializer” wordt gebruikt om de DelegatingFilterProxy te registreren om de springSecurityFilterChain te gebruiken. Dit vermijdt het schrijven van filterconfiguratie in het web.xml-bestand.- Spring MVC-toepassing initialiseren
De klasse “SpringMVCWebAppInitializer” wordt gebruikt om “DispatcherServlet” te initialiseren zonder web.xml-bestand in een op annotaties gebaseerde configuratie. 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[] { "/" };
	}
	
}

LET OP:-

  1. Wanneer we toegang krijgen tot onze applicatie, staat SpringMVCWebAppInitializer standaard toe om de root-URL “/ ” te benaderen. We kunnen dit overschrijven om door te verwijzen naar een andere URL.
  2. Het Spring- of Pivotal-team werkt aan dit probleem om de hoeveelheid Java-code te verminderen door een annotatie te introduceren. Controleer dit op https://jira.spring.io/browse/SPR-10359.
  • Ontwikkel het welcomePage.jsp-bestand 
<h3>Welcome to JournalDEV Tutorials</h3>
<a href="${pageContext.request.contextPath}/loginPage">Login to Journal</a>
  • Ontwikkel het loginPage.jsp-bestand 
<%@ 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>
  • Ontwikkel het homepage.jsp-bestand 
<%@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>
  • De uiteindelijke projectstructuur ziet er als volgt uit:

Voer het Spring Security MVC Login Logout-voorbeeld uit

Om deze Spring Web-applicatie uit te voeren, hebben we een webcontainer nodig die Spring 4 en Java 8-omgevingen ondersteunt met Servlet 3.1.0-container.

  • Implementeer en voer uit op de Spring TC Server in Spring STS Suite
  • Het systeem: Het automatisch toegang krijgen tot de welkomstpagina van onze applicatie-URL zoals hieronder getoond.
    – Klik op de link “Inloggen bij JournalDEV” om toegang te krijgen tot de inlogpagina.
    – Geef nu verkeerde inloggegevens op en klik op de knop “Inloggen”.
    Hier kunnen we deze foutmelding waarnemen: “Ongeldige referenties verstrekt.”- Geef nu de juiste inloggegevens op die geconfigureerd zijn in de klasse “LoginSecurityConfig”.
    Na succesvol inloggen op onze applicatie, kunnen we onze applicatiestartpagina zien met de “Uitloggen” link.- Klik op de “Uitloggen” link om uit te loggen uit de applicatie.
    Hier kunnen we waarnemen dat we succesvol zijn uitgelogd uit onze applicatie en opnieuw zijn doorverwezen naar de inlogpagina. We kunnen wat succesvolle uitlogberichten waarnemen op deze inlogpagina.

OPMERKING: Als we dit voorbeeld bekijken, gebruiken we het web.xml-bestand niet correct. Aangezien het een webtoepassing is, zoekt Maven naar het web.xml-bestand en geeft enkele fouten als het niet in de toepassing wordt gevonden. Om Maven-gerelateerde problemen te voorkomen, moeten we de vlag “<failOnMissingWebXml>” configureren in het pom.xml-bestand. Dat is alles over het eenvoudige voorbeeld van Spring 4 Security Module. We zullen in mijn komende berichten enkele meer realtime bruikbare voorbeelden ontwikkelen, zoals het beheren van rollen, de “Onthoud mij”-functie, WebSocket-beveiliging en meer. Laat me een opmerking achter als je mijn bericht leuk vindt of als je problemen/suggesties hebt.

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