[JAVA] Versuchen Sie, eine Anmeldefunktion mit Spring-Boot zu implementieren

Vorwort und Umwelt

Ich habe eine einfache Anmeldefunktion mit Spring-Boot implementiert. Ich habe einmal etwas Ähnliches mit PHP gemacht, und als ich dachte, ich könnte es mir leisten, hatte ich große Probleme, deshalb werde ich es als Memorandum zusammenfassen. Wenn Sie alles umfassend schreiben, wird Ihnen die Energie ausgehen, und ich werde grob auf den verstopften Teil konzentrieren. Ich liege hier falsch! Wenn Sie Fragen haben, lassen Sie es mich bitte wissen (╹◡╹)

Umgebung

• Spring-Boot(2.0.4)
• MySQL (zum Speichern von Benutzerinformationen und Sitzungsinformationen)
• Spring-Security (wird für die Authentifizierungs- / Autorisierungsverarbeitung verwendet)

Prozessablauf

Der Ablauf dieses Prozesses ist wie folgt. Auf dem Bildschirm befinden sich "hello.html" und "login.html", und hello.html ist ein Bildschirm, der ohne Anmeldung nicht angezeigt werden kann. ① Autorisierungsverarbeitung Wenn Sie versuchen, auf hello.html zuzugreifen, ohne sich anzumelden, wird auf login.html umgestellt

② Authentifizierungsprozess Vergleichen Sie die im Formular eingegebenen Werte "Benutzername" und "Passwort" mit den in der Datenbank gespeicherten Werten. Wenn eine Übereinstimmung vorliegt, ist die Authentifizierung erfolgreich. Wenn es nicht vorhanden ist, wechselt es zu login.html und zeigt eine Fehlermeldung an.

③ Sitzungsverwaltung Wenn die Authentifizierung erfolgreich ist, werden die Sitzungsinformationen in der Datenbank gespeichert. Ermöglicht es Ihnen, den Benutzernamen nach Bedarf aus den Sitzungsinformationen abzurufen.

④ Verwerfen Sie die Sitzung Wenn die Abmeldetaste gedrückt wird, werden die Sitzungsinformationen verworfen und die Authentifizierung ist erneut erforderlich.

Die folgende Abbildung fasst diese Prozesse zusammen.

Wenn Sie diese alle auf einmal implementieren, wird Ihr Kopf verletzt. Diesmal haben wir sie in drei Schritten implementiert.

• Schritt 1: Geben Sie einen bestimmten Benutzernamen und ein Passwort ein und los geht's!
• Schritt 2: Übergeben Sie nur das in der DB gespeicherte Benutzername / Passwort-Paar!
• Schritt 3: Fügen Sie Ihre Anmeldeinformationen in die Sitzung ein und verwalten Sie, wer angemeldet ist!

Im Folgenden werden die Implementierungsschritte für jeden Schritt beschrieben.

Abhängigkeiten

Vorher werde ich die Abhängigkeiten beim Erstellen eines Projekts mit Spring-Boot beschreiben. Weitere Informationen finden Sie in pom.xml.

Schritt 1. Geben Sie "Benutzer" und "Passwort" ein und es wird bestanden!

Wir werden mit der Gründung beginnen. Folgendes machen Sie in diesem Schritt:

• hello.html (Bildschirm, auf den nur authentifizierte Benutzer zugreifen können)
• login.html (Anmeldebildschirm)
• WebSecurityConfig-Klasse (Klassendatei, die Einstellungen für die Authentifizierung / Autorisierung beschreibt)
• MvcConfig-Klasse (Klassendatei zum Zuordnen von URLs zu Ansichtsnamen)

Beginnen wir mit allen Basiskonfigurationsdateien. Aber vorher ...

Konfigurationsdatei schwieriges Problem

Es scheint schwierig zu sein, an der Konfigurationsdatei zu basteln ... Zuerst dachte ich, Spring-Security sei schwer zu verstehen. Da Sie mit Spring-Security jedoch Einstellungen in Form von Java-Klassen schreiben können, können Sie nach dem Schreiben ein Gefühl dafür bekommen. Ich verstehe intuitiv, dass es möglich ist, einen Wert (Einstellung für das System) zur Eigenschaft der Klasse hinzuzufügen, die die Einstellung verwaltet, da es sich anfühlt, als würde man mit der Lautstärke und der Bildqualität im Spiel spielen. Ich denke es ist einfach.

MvcConfig ist besonders einfach zu verstehen. Wenn Sie Config noch nicht kennen, können Sie es von dort aus ausprobieren. Als ich die Konfigurationsdatei zum ersten Mal sah, sah sie völlig anders aus als der Code, den ich normalerweise schreibe. Deshalb habe ich sie geschrieben, bevor ich mir den Code tatsächlich angesehen habe.

WebSecurityConfig.java

package login.app.config;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
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;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import login.app.service.UserDetailsServiceImpl;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
	
	
	@Autowired
	private UserDetailsServiceImpl userDetailsService;
	
	//Da das von der Datenbank erhaltene Kennwort, das mit dem Formularwert verglichen werden soll, verschlüsselt ist, wird es auch zum Verschlüsseln des Formularwerts verwendet.
	@Bean
	public BCryptPasswordEncoder passwordEncoder() {
		BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
		return bCryptPasswordEncoder;
	}
	
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers(
                            "/images/**",
                            "/css/**",
                            "/javascript/**"
                            );
    }

	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http
		    .authorizeRequests()
		        .anyRequest().authenticated()
		        .and()
		    .formLogin()
		        .loginPage("/login") //Da die Anmeldeseite nicht über den Controller geleitet wird, muss sie mit ViewName verknüpft werden.
		        .loginProcessingUrl("/sign_in") //Senden Sie die URL des Formulars. Der Authentifizierungsprozess wird ausgeführt, wenn eine Anforderung an diese URL gesendet wird
		        .usernameParameter("username") //Explizites Namensattribut des Anforderungsparameters
		        .passwordParameter("password")
		        .successForwardUrl("/hello")
		        .failureUrl("/login?error")
		        .permitAll()
		        .and()
		    .logout()
		        .logoutUrl("/logout")
		        .logoutSuccessUrl("/login?logout")
		        .permitAll();
	}
	
	@Autowired
	public void configure(AuthenticationManagerBuilder auth) throws Exception{
		auth
		    .inMemoryAuthentication()
		        .withUser("user").password("{noop}password").roles("USER");
	}

}

Official hat die grundlegenden Teile sorgfältig zusammengefasst. Wenn Sie also nicht wissen, was Sie sagen, lesen Sie dies bitte. Ich denke, es ist besser, es zu tun.

Schauen wir uns nun jeden Prozess an.

Anmerkung

Lesen Sie die Annotation @Configuration richtig durch, da diese Klasse eine Konfigurationsdatei ist! Es ist für den Frühling zu erzählen. Die dazugehörige Annotation @EnableWebSecurity dient zur Verwendung dieser und jener von Spring-Security.

Vererbungsklasse

Diese Klasse erbt die Klasse "WebSecurityConfigurerAdapter" und überschreibt einige der in der Konfiguration verwendeten Methoden. Dieses Mal überschreiben wir die Konfigurationsmethode zum Festlegen des Authentifizierungs- / Autorisierungsprozesses.

Konfigurationsmethode (WebSecurity)

Hier werden die Einstellungen so vorgenommen, dass die Anforderung bei Verwendung einer statischen Datei (Bild, CSS, Javascript) nicht abgespielt wird.

Konfigurationsmethode (HttpSecurity)

Es ist eine Methode, um die Einstellungen für den Teil zu beschreiben, der sich auf die http-Anforderung im Authentifizierungs- / Autorisierungsprozess bezieht. Auf den ersten Blick scheint es schwierig zu sein, da viele Punkte in einer Reihe stehen, aber ich stelle nur individuelle Einstellungen ein. Wenn ich also nach Tutorials fische, bin ich mir sicher, dass es so sein wird. Hier ist eine grobe Liste der Einstellungen.

• Der Bildschirm in der App ist ohne Authentifizierung grundsätzlich nicht sichtbar
• Der Anmeldebildschirm befindet sich unter "/ login" (später beschrieben)
• Der Authentifizierungsprozess wird ausgeführt, wenn eine Anforderung an "/ sign_in" gesendet wird.
• Das Namensattribut des Eingabewerts des Formulars lautet "Benutzername" und "Passwort".
• Übergang zu "/ hallo" nach erfolgreicher Anmeldung
• Wenn die Anmeldung fehlschlägt / sich abmeldet, übergeben Sie den Parameter get an den Anmeldebildschirm und den Übergang

Konfigurationsmethode (AuthenticationManagerBuilder)

Hier wird inMemoryAuthentication () verwendet, um klar anzuzeigen, dass eine speicherinterne Authentifizierung durchgeführt wird, und der für die Authentifizierung verwendete Benutzername und das Kennwort werden direkt festgelegt. Ich halte es für unwahrscheinlich, dass moderne Apps keine Datenbank verwenden. Daher möchte ich den Teil, der die Datenbank für die Authentifizierungsverarbeitung verwendet, erneut besuchen.

Mit oder ohne Autowired

Wenn Sie sich die Tutorials ansehen, sehen Sie häufig den Methodennamen configureGlobal und die Annotation @Autowired. Wenn Sie von @Autowired sprechen, wird es häufig für Felder verwendet, Sie können es jedoch auch an Methoden anhängen. In Bezug auf die Konfigurationsklasse kann diesmal festgelegt werden, dass der Name für die Methode ohne @ Autowired-Annotation konfiguriert werden soll, und für die Methode mit @Autowired-Annotation kann ein beliebiger Name festgelegt werden. Referenz

Schauen wir uns als nächstes die Einstellungsdatei für ViewName an.

MvcConfig.java

package login.app.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;


@Configuration
public class MvcConfig implements WebMvcConfigurer {
	
	/**
	 * 「/Login von der URL "Login".Rufen Sie HTML auf
	 */
	public void addViewControllers(ViewControllerRegistry registry) {
		registry.addViewController("/login").setViewName("login");
	}

}

Normalerweise gibt es in Spring-Boot einen Controller. Nachdem Sie die Anforderung mit der Annotation @RequesMapping aufgenommen und einige Verarbeitungsschritte ausgeführt haben, wird der Ansichtsname für den Bildschirm (HTML) zurückgegeben und der Bildschirm angezeigt. Da der Spring-Security-Lehrer den Anmeldevorgang ausführt, gibt es meines Erachtens kein Problem, auch wenn Sie LoginController oder ähnliches nicht implementieren. Da es jedoch erforderlich ist, die Zuordnung zwischen dem Ansichtsnamen und der URL zu trennen, werden wir sie in dieser Einstellungsdatei beschreiben. Wenn hier eine Anfrage mit der URL "/ login" eingeht, wird der Vorgang beschrieben, indem "login" mit dem Ansichtsnamen (login.html) angezeigt wird. Ich würde mich sehr freuen, wenn Sie mir sagen könnten, ob es einen besseren Weg gibt, es zu beschreiben.

Ich werde hello.html weglassen, weil es nur eine Begrüßung ist, aber ich werde über login.html schreiben, weil es ein bisschen süchtig macht.

login.html

<form th:action="@{/sign_in}" method="post">
	    <input type="text" name="username">user_name
	    <br/>
	    <input type="password" name="password">password
	    
	    <br/>
	    
	    <input type="submit" value="Login">
	</form>

Hierbei ist zu beachten, dass der Wert des Namensattributs mit dem in der Einstellungsdatei beschriebenen Wert übereinstimmen sollte und dass das Ziel des Formulars durch das Attribut th: action angegeben werden sollte. Wenn Sie jedoch "/ sign_in" schreiben, werden Sie wütend, dass es keine solche URL gibt. Dies liegt daran, dass CSRF-Maßnahmen von Spring-Security standardmäßig aktiviert sind. Wenn Sie die einfache URL an acrtion übergeben, ohne an etwas in diesem Zustand zu denken, werden Sie wütend, weil das Token für CSRF-Gegenmaßnahmen nicht platziert ist. Es gibt verschiedene Möglichkeiten, dies zu lösen. Dieses Mal wird jedoch durch Setzen von "th: action = @ {URL}" in Thymeleaf ein Token generiert und in die URL eingefügt. Referenz

Außerdem ist die Ziel-URL standardmäßig eine lange URL, die die Authentifizierungsverarbeitung durchführt. Ich denke jedoch, dass es besser ist, sie in der Einstellungsdatei anzugeben.

Wenn Sie es mit der Implementierung ausführen, wird der Anmeldebildschirm angezeigt. Wenn Sie also "Benutzer" und "Kennwort" eingeben, können Sie zu hello.html wechseln. Da ich vergessen habe, das Ausführungsergebnis jedes Mal zu erfassen, wird der Ausführungsbildschirm nur in Schritt 3 angezeigt, aber bitte verzeihen Sie mir.

Schritt 2. Wenn Sie einen Benutzer in der Datenbank finden, lassen Sie es durch!

Wir haben eine Funktion implementiert, mit der nur der in Schritt 1 angemeldete Benutzer die Seite anzeigen kann. Es ist jedoch nicht möglich, "wer angemeldet ist" zu identifizieren, wenn jeder einen gemeinsamen Benutzernamen und ein Kennwort verwendet. Erstens ist Sicherheit zu lächerlich. In diesem Schritt fügen wir eine Funktion hinzu, mit der sich nur in der Datenbank registrierte Benutzer anmelden können. Die folgenden Elemente sind erforderlich.

• LoginUser (Entität)
• LoginUserDao (Klasse, die die Zugriffsmethode mit DB implementiert)
• UserDetailsServiceImpl (Klasse, die die Methode definiert, die bei der Authentifizierungsverarbeitung aufgerufen werden soll)

Da der Zweck hier darin besteht, eine Anmeldefunktion zu erstellen, werde ich die Verwendung von Entity und EntityManager weglassen, aber ich möchte auch diesen Bereich zusammenfassen. Schauen wir uns also die UserDetailsServiceImpl-Klasse an.

UserDetailsServiceImpl.java

package login.app.service;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import login.app.dao.LoginUserDao;
import login.app.entity.LoginUser;

@Service
public class UserDetailsServiceImpl implements UserDetailsService{
	
	//Eine Klasse, die eine Methode zum Suchen von Benutzerinformationen aus der Datenbank implementiert
	@Autowired
	private LoginUserDao userDao;
	
	@Override
	public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {
		
		LoginUser user = userDao.findUser(userName);
		
		if (user == null) {
			throw new UsernameNotFoundException("User" + userName + "was not found in the database");
		}
		//Liste der Berechtigungen
		//Es gibt Admin, User usw., aber da wir sie diesmal nicht verwenden, wird nur USER vorübergehend eingestellt.
		//Um Berechtigungen verwenden zu können, müssen Berechtigungstabellen und Benutzerberechtigungstabellen in der Datenbank erstellt und verwaltet werden.
		List<GrantedAuthority> grantList = new ArrayList<GrantedAuthority>();
		GrantedAuthority authority = new SimpleGrantedAuthority("USER");
		grantList.add(authority);
		
		//Das RawData-Passwort kann nicht übergeben werden, daher Verschlüsselung
		BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
		
		//Da UserDetails eine Schnittstelle ist, wandeln Sie das vom Konstruktor der User-Klasse erstellte Benutzerobjekt um.
		UserDetails userDetails = (UserDetails)new User(user.getUserName(), encoder.encode(user.getPassword()),grantList);
		
		return userDetails;
	}

}

Der Verarbeitungsablauf der Methode loadUserByUsername, die die Informationen zum Durchführen der Authentifizierungsverarbeitung abruft, lautet wie folgt.

• Suche DB nach Benutzername mit Methode in der Dao-Klasse
• Speichern Sie die gefundenen Benutzerinformationen in der Entitätsklasse
• Berechtigungsinformationen festlegen (Dummy-Daten werden hier festgelegt)
• Passwort verschlüsseln
• Erstellen Sie ein UserDetails-Objekt und übergeben Sie es an den Authentifizierungsprozess

Ich würde gerne einen Blick auf jeden von ihnen werfen.

Berechtigungsinformationen

Für Spring-Security müssen Sie auch Berechtigungen (Administrator, Benutzer usw.) an Ihre Anmeldeinformationen übergeben. Da wir hier jedoch nur einen Benutzer benötigen, generieren wir vorübergehend Berechtigungsinformationen aus SimpleGrantedAuthority und fügen sie in die Liste von GrantedAuthority ein. Wenn Sie auch Berechtigungen festlegen möchten, müssen Sie eine Berechtigungstabelle oder Benutzerberechtigungstabelle in der Datenbank erstellen oder die Anzahl der Entitäten erhöhen. Diesmal ist es jedoch in Ordnung, wenn Sie sich anmelden können. Ich werde sie daher weglassen.

Verschlüsselung

In Spring-Security werden Kennwörter grundsätzlich verschlüsselt. Da ich keine Kenntnisse über Verschlüsselung habe, habe ich das Gefühl, dass ich derzeit berühmte Orte verwende. Wenn ich jedoch eine tatsächliche Anwendung erstelle, kenne ich jede Methode und verschlüssle das Kennwort beim Speichern von Benutzerinformationen in der Datenbank Ich denke es wird notwendig sein.

UserDetails-Objekt

In Spring-Security werden anstelle der Übergabe von Benutzerinformationen als Benutzerentität ein Benutzername namens UserDetails, ein verschlüsseltes Kennwort und ein Objekt vom Typ UserDetails, das durch Berechtigungsinformationen erstellt wurde, an den Authentifizierungsprozess übergeben. Da die User-Klasse eine Implementierungsklasse der UserDetails-Schnittstelle ist, kann sie als Rückgabewert verwendet werden. Ich denke jedoch, dass es besser ist, sie entsprechend dem Typ der Methode umzuwandeln und dann zurückzugeben.

Da die Authentifizierungsinformationen von In-Memory in DB geändert wurden, möchte ich als Nächstes einen Blick auf den geänderten Teil der Einstellungsdatei werfen.

WebSecurityConfig.java(Authentifizierungsverarbeitungsteil)

public void configure(AuthenticationManagerBuilder auth) throws Exception{
		auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
	}

Wenn Sie hier angeben, dass userDetailsService für die Authentifizierung verwendet wird, und die zuvor erstellte Implementierungsklasse als Argument übergeben, wird eine Klasse namens DaoAuthenticationProvider aufgerufen und die in der Authentifizierung implementierte loadUserByUsername-Methode aufgerufen. .. Geben Sie dieselbe Verschlüsselungsmethode wie die von DB für passwordEncoder an und vergleichen Sie damit den Eingabewert des Formulars mit dem Kennwort von DB und führen Sie den Authentifizierungsprozess durch.

Wenn Sie das Formular mit der bisherigen Implementierung erneut mit login.html senden, wird die Datenbank durchsucht und nur die in der Datenbank vorhandenen Benutzer übergeben die Authentifizierung. Du hast es geschafft.

Schritt 3. Sehen Sie, wer in der Sitzung angemeldet ist!

Schließlich verwaltet es Sitzungsinformationen und realisiert die folgenden Funktionen.

• Sie können sich für die Dauer der Sitzung weiter anmelden (die Anmeldung bleibt auch dann bestehen, wenn Sie den Browser schließen).
• Informationen aus den Sitzungsinformationen abrufen, wer angemeldet ist
• Verwerfen Sie Sitzungsinformationen über die Schaltfläche zum Abmelden

Es gibt verschiedene Methoden der Sitzungsverwaltung, aber dieses Mal werde ich sie auf MySQL stellen. Sie müssen jedoch nur eine [Abfrage zur Generierung von Sitzungstabellen] vorbereiten (https://github.com/spring-projects/spring-session/tree/master/spring-session-jdbc/src/main/). Führen Sie einfach resources / org / springframework / session / jdbc) aus und spielen Sie mit application.properties und Abhängigkeiten herum. Spring-Security kümmert sich um den Inhalt.

Die Sitzungsverwaltung kann hier möglicherweise nicht geschrieben werden, z. B. die Verwendung von Redis mit NoSQL oder die Vorgehensweise mit der Sitzungs-ID. Daher werde ich dieses Mal nur eine grobe Verwendungsmethode zum Erstellen einer Anmeldefunktion und detaillierte Inhalte schreiben Ich würde gerne einen anderen anschauen.

Erstellen und Festlegen einer Sitzungsspeichertabelle

Die Erstellung selbst ist in Ordnung, wenn Sie die Anweisung CREATE für jede SQL ausführen, die Sie unter dem obigen Link verwenden. Sie können sehen, wie sich die Sitzung in der App verhält, indem Sie den Inhalt dieser Tabelle nacheinander auswählen. Ich muss diesen Bereich richtig kennen, deshalb möchte ich ihn vor dem Schreiben etwas besser organisieren.

Als nächstes ist es eine Einstellung, die Tabelle zu verwenden, aber dies ist in Ordnung, indem nur ein wenig zu application.properties und pom.xml hinzugefügt wird. Vielen Dank.

application.properties

spring.session.store-type=jdbc

pom.xml(Sitzungsnutzungsteil)

       <dependency>
		<groupId>org.springframework.session</groupId>
		<artifactId>spring-session-jdbc</artifactId>
	    </dependency>

Ich glaube nicht, dass pom.xml in der Liste der Abhängigkeiten in der Projektgenerierungsphase enthalten ist, daher müssen Sie es manuell hinzufügen. Ich habe das nicht verstanden und es war ziemlich voll.

Sitzungsinformationen lesen

"Hallo, Benutzername san!" In hello.html müssen Sie Informationen haben, um zu sehen, wer Sie jetzt angemeldet sind. Dies wird durch die init-Methode von HelloController implementiert, die bei erfolgreicher Anmeldung übergeht.

HelloController.java(Methode, die zum Zeitpunkt des Bildschirmübergangs aufgerufen wurde)

@RequestMapping("/hello")
	private String init(Model model) {
		Authentication auth = SecurityContextHolder.getContext().getAuthentication();
		//Erhalten Sie Anmeldebenutzerinformationen von Principal
		String userName = auth.getName();
		model.addAttribute("userName", userName);
		return "hello";
		
	}

Der Punkt hier ist der SecurityContextHolder. Hier werden die Informationen des aktuell angemeldeten Benutzers gespeichert, es handelt sich jedoch tatsächlich um eine HttpSession. Mit anderen Worten, die Benutzerinformationen, die in den in Spring-Security definierten Sitzungsinformationen enthalten sind, werden als Schlüssel verwendet, um auf die Datenbank zu verweisen, in der die Sitzungsinformationen gespeichert sind, und der Anmeldestatus des entsprechenden Benutzers wird festgelegt. Es ist kompliziert. Ich werde diesen Bereich richtig organisieren und in einem anderen Artikel zusammenfassen (o_o) Wenn es sich um die ursprüngliche Anwendung handelt, werden wir den Benutzer-ID-Bereich aus dem erfassten Benutzernamen aus der Datenbank abrufen und die Informationen jedes Benutzers weiter auslesen. Diesmal setzen wir jedoch nur den Benutzernamen in den Anforderungsbereich. Ich werde es behalten. Durch den Übergang zu hello.html in diesem Status kann der Name des angemeldeten Benutzers auf dem Bildschirm angezeigt werden.

Ausloggen

Zum Zeitpunkt der Abmeldung gibt es verschiedene Möglichkeiten, z. B. das Verwerfen von Sitzungsinformationen. Wenn Sie jedoch eine Anfrage an "/ logout" des Spring-Security-Lehrers senden, wird dies ausgeführt. Sie können den Abmeldevorgang selbst implementieren, aber CSRF scheint dies alles gut zu machen. Ich denke, es ist sicher, ihn uns zu überlassen. Ich denke jedoch, dass man bedenken muss, was im Prozess erforderlich ist und wie sich die DB-Informationen der Sitzung ändern. Organisieren Sie diesen Bereich (unten abgekürzt)

Es gibt eine Einschränkung: Es scheint, dass Sie beim Übergang zu "/ logout" auf hello.html immer mit der "POST" -Methode wechseln müssen. Es scheint, dass es für dieses und jenes von CSRF ist, aber da das Verständnis flauschig ist, möchte ich mein Bestes geben, um Sicherheit zu studieren.

Ausführungsergebnis

Damit haben wir eine Reihe von Funktionen implementiert. Abschließend möchte ich das Ausführungsergebnis einer Reihe von Prozessen angeben.

Der Quellcode für diese Reihe von Implementierungen ist auf GitHub aufgeführt. Es gibt auch eine SQL-Datei im SQL-Ordner, um dies und das mit einem einzigen Befehl zu tun. Wenn Sie also nichts dagegen haben.