[JAVA] [Introduction à Spring Boot] Fonction d'authentification avec Spring Security
Objectif
Pour ceux qui ont terminé le Spring Quickstart Guide, ceux qui ont commencé à apprendre Spring Boot et ceux qui veulent le consulter.
Partagez ce que vous avez appris en travaillant sur le guide officiel Sécurisation d'une application Web.
Vérifiez le formulaire rempli.
Il y a une page d'accueil, cliquez ici,
Accédez à la page de connexion. Saisissez le nom d'utilisateur et le mot de passe de l'utilisateur de test et cliquez sur le bouton Se connecter.
Vous serez redirigé vers une page qui ne peut être consultée que par des personnes authentifiées. Vous ne pouvez pas accéder à cet écran si vous n'êtes pas connecté.
L'environnement de développement et l'examen jusqu'à présent sont les suivants.
Environnement de développement
Système d'exploitation: macOS Mojave version 10.14.6
Éditeur de texte: Visual Studio Code (ci-après VSCode)
Java: 11.0.2
QuickstartGuide Création d'un service Web RESTful Utilisation d'un service Web RESTful Accès aux données avec JPA Traitement de la soumission du formulaire Sécurisation d'une application Web
1. Démarrez le projet Spring Boot!
Tout d'abord, accédez à spring initializr.
- Cliquez sur le bouton AJOUTER DES DÉPENDANCES et ajoutez «Spring Web» et «Thymeleaf».
2.Artifact, nom changé en
sécurisation-web - Remplacez Java par 11.
Cliquez ensuite sur le bouton GENERATE pour télécharger le fichier Zip.
Extrayez le fichier Zip téléchargé et vous êtes prêt à partir.
2. Ajoutez du code!
Ouvrez le dossier précédent avec VS Code. Nous vous recommandons d'installer le Java Extension Pack pour les extensions. Il est dit que vous devez l'installer.
Créons home.html!
Créez un fichier home.html dans src / main / resources / templates /.
Ajoutez le code faisant référence à la formule. Ce sera la première page.
home.html
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="https://www.thymeleaf.org"
xmlns:sec="https://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
<head>
<title>Spring Security Example</title>
</head>
<body>
<h1>Welcome!</h1>
<p>Click <a th:href="@{/hello}">here</a> to see a greeting.</p>
</body>
</html>
La partie balise html sert à écrire th: 〇〇 et sec: 〇〇 (une méthode de description utilisant les balises thymeleaf et Spring Security est possible).
Maintenant, approfondissons la description de thymeleaf dans le code ajouté.
thymeleaf est un moteur de template qui peut être géré par springboot. Th: Décrivez comme 〇〇. [Tutoriel Thymeleaf] écrit en japonais (https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf_ja.html#thymeleaf%E3%81%AE%E7%B4%B9%E4%BB% Il y a aussi 8B)!
th:href
Cette balise est définie dans l'attribut href de la balise a. La méthode de description est th: href =" @ {} ".
Spécifiez le chemin à l'intérieur de {}. Cette fois c'est / hello, donc si vous cliquez sur la balise, elle passera à http: // localhost: 8080 / hello.
Créons hello.html!
Créez un fichier hello.html dans src / main / resources / templates /.
Ajoutez le code faisant référence à la formule.
hello.html
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="https://www.thymeleaf.org"
xmlns:sec="https://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
<head>
<title>Hello World!</title>
</head>
<body>
<h1 th:inline="text">Hello [[${#httpServletRequest.remoteUser}]]!</h1>
<form th:action="@{/logout}" method="post">
<input type="submit" value="Sign Out"/>
</form>
</body>
</html>
th: inline sert à étendre la valeur d'une variable dans le texte de la balise. Placez les variables que vous souhaitez afficher dans «[...]]».
Cette fois, il s'agit de $ {# httpServletRequest.remoteUser}, donc le nom de l'utilisateur authentifié est affiché.
Lorsque vous appuyez sur le bouton Déconnexion, vous serez redirigé vers / login? Déconnexion.
Créons MvcConfig.java!
Créez un fichier MvcConfig.java dans src / main / java / com / example / securingweb /.
Ajoutez le code faisant référence à la formule.
MvcConfig.java
package com.example.securingweb;
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 {
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/home").setViewName("home");
registry.addViewController("/").setViewName("home");
registry.addViewController("/hello").setViewName("hello");
registry.addViewController("/login").setViewName("login");
}
}
L'annotation ** @ Configuration ** est donnée à la classe afin que divers paramètres de Spring puissent être exécutés en code Java. (Classe de réglage)
J'ai créé une classe MvcConfig qui implémente l'interface WebMvcConfigurer et remplace la méthode addViewControllers.
registry.addViewController("/home").setViewName("home");
Au lieu d'avoir un autre contrôleur et d'utiliser l'annotation @ GetMapping pour renvoyer le nom de la vue
Par la description ci-dessus
Lorsque l'URL est http: // localhost: 8080 / home, le modèle ** home.html ** sera référencé.
Il semble que l'URL et le modèle soient mappés.
Nous implémenterons login.html plus tard.
Ajoutez Spring Security à pom.xml!
Ajoutez ce qui suit à pom.xml pour utiliser Spring Security.
Spring Security est un cadre permettant d'ajouter des fonctionnalités de sécurité aux applications Web. Fournit un support complet pour l'authentification, l'autorisation et la protection contre les abus courants.
pom.xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
Créons WebSecurityConfig.java!
Créez un fichier WebSecurityConfig.java dans src / main / java / com / example / securingweb /.
Ajoutez le code faisant référence à la formule.
WebSecurityConfig.java
package com.example.securingweb;
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 org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/", "/home").permitAll()
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.permitAll()
.and()
.logout()
.permitAll();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
String password = passwordEncoder().encode("password");
auth.inMemoryAuthentication()
.passwordEncoder(passwordEncoder())
.withUser("user").password(password).roles("USER");
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
Nous approfondirons le code ajouté.
① Héritage des classes @ EnableWebSecurity et WebSecurityConfigurerAdapter
WebSecurityConfig.java
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
//réduction
}
Spring Security est activé en ajoutant l'annotation @ EnableWebSecurity.
Et il hérite d'une classe abstraite appelée WebSecurityConfigurerAdapter. Remplacez la ** méthode configure ** dans cette classe
Nous mettrons en œuvre la possibilité de restreindre ou non l'accès aux pages.
② Définir les restrictions d'accès aux pages
WebSecurityConfig.java
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/", "/home").permitAll() //URL qui ne nécessitent pas de restrictions d'accès
.anyRequest().authenticated() //D'autres URL nécessitent une authentification. Vous ne pouvez y accéder que si vous êtes authentifié
.and()
.formLogin()
.loginPage("/login") //Aucune restriction d'accès sur l'écran de connexion
.permitAll() //Aucune authentification requise
.and()
.logout()
.permitAll(); //Aucune authentification requise
}
Remplacer la ** méthode de configuration **. HttpSecurity est reçu comme argument, et c'est une méthode pour décrire les paramètres de la partie liée à la requête http. Définit si l'authentification est requise lors de la connexion, de la déconnexion ou de l'accès à d'autres pages.
③ Paramètres utilisateur pour authentifier
La mise en œuvre de cette partie était dite obsolète si vous suiviez le guide officiel. Il a donc une implémentation légèrement différente.
WebSecurityConfig.java
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
//Encoder le mot de passe
String password = passwordEncoder().encode("password");
//Paramètres d'authentification en mémoire
auth.inMemoryAuthentication()
.passwordEncoder(passwordEncoder())
.withUser("user").password(password).roles("USER");
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
** PasswordEncoder passwordEncoder () ** définit une méthode de hachage des mots de passe.
Et le mot de passe de la chaîne de caractères est haché dans la partie de String password = passwordEncoder (). Encode (" password ");.
AuthenticationManagerBuilder est une classe qui active l'authentification en mémoire.
python
//Paramètres d'authentification en mémoire
auth.inMemoryAuthentication()
.passwordEncoder(passwordEncoder())
.withUser("user").password(password).roles("USER");
}
Nous l'implémentons ici et configurons l'utilisateur pour s'authentifier.
Créons login.html!
Créez un fichier login.html dans src / main / resources / templates /.
Ajoutez le code faisant référence à la formule. Ce sera la page de connexion.
login.html
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="https://www.thymeleaf.org"
xmlns:sec="https://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
<head>
<title>Spring Security Example </title>
</head>
<body>
<div th:if="${param.error}">
Invalid username and password.
</div>
<div th:if="${param.logout}">
You have been logged out.
</div>
<form th:action="@{/login}" method="post">
<div><label> User Name : <input type="text" name="username"/> </label></div>
<div><label> Password: <input type="password" name="password"/> </label></div>
<div><input type="submit" value="Sign In"/></div>
</form>
</body>
</html>
Il y a un champ pour entrer le nom d'utilisateur et le mot de passe.
th: if =" $ {param.error} ʻest la zone qui s'affiche lorsque l'authentification de l'utilisateur échoue. th: if =" $ {param.logout} ʻest la zone qui sera affichée lorsque vous vous déconnectez (affichée après avoir appuyé sur le bouton Déconnexion dans hello.html).
3. Lançons-le!
Maintenant que l'application est prête à fonctionner, vérifions.
Entrez la commande suivante dans le terminal et appuyez sur Entrée.
Terminal
$ ./mvnw spring-boot:run
La première page s'affiche.
Cliquez ici pour accéder à la page de connexion.
Saisissez un nom d'utilisateur et un mot de passe appropriés et appuyez sur le bouton Connexion.
La page de connexion s'affiche de nouveau et le message d'erreur s'affiche également.
Ensuite, entrez ʻuser dans Nom d'Usr et Mot de passe` dans Mot de passe et appuyez sur le bouton Se connecter.
J'ai pu passer à une page qui ne peut être consultée que par des personnes authentifiées.
Lorsque vous appuyez sur le bouton Déconnexion,
Vous serez redirigé vers la page de connexion et vous verrez un message.
Je vous remercie pour votre travail acharné. terminé!
Site de référence
** Alternative à obsolète pour User.withDefaultPasswordEncoder () ** ** [Spring Security has started] # 2 User Authentication ** ** "Hello World!" Avec Spring Security **
Recommended Posts