[JAVA] Comment implémenter le processus d'authentification en spécifiant le nom d'utilisateur et le mot de passe dans Spring Boot

introduction

Dans le processus d'authentification de Spring Boot, j'ai étudié comment spécifier le mot de passe, ce que je me demandais depuis longtemps.

Aperçu

Nous vous montrerons comment implémenter le traitement d'authentification avec un nom d'utilisateur et un mot de passe dans Spring Boot et Spring Security.

L'environnement prérequis est le suivant.

Version
Java 1.7
Spring Boot 1.5.9.RELEASE

[Problème] Le mot de passe ne peut pas être spécifié dans `ʻUserDetailsService``

Si vous allez dans "Spring Boot Authentication Process", vous trouverez de nombreux exemples utilisant loadUserByUsername de `ʻUserDetailsService`` [^ fqcn-uds]. J'ai aussi écrit. → Utiliser l'authentification de base avec Spring Boot

Cependant, comme indiqué ci-dessous, le seul argument pour loadUserByUsername est `ʻusername``.

UserDetailsService


UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;

Pour cette raison, il n'est pas possible de gérer les cas où le ** traitement d'authentification avec un nom d'utilisateur et un mot de passe spécifiés ** est requis. Par exemple, dans les cas suivants, `` loadUserByUsername '' ne peut pas être utilisé.

[^ cript]: fonction `` crypt '' de PostgreSQL, etc.

[Solution] Utilisez `ʻAbstractUserDetailsAuthenticationProvider``

Utilisez ʻAbstractUserDetailsAuthenticationProvider`` [^ fqcn-audap] au lieu de ʻUserDetailsService. Plus précisément, en créant un Bean de `ʻAuthenticationProvider en utilisant` ʻAbstractUserDetailsAuthenticationProvider``, vous pouvez facilement implémenter ** le processus d'authentification en utilisant le nom d'utilisateur et le mot de passe **.

Exemple de code

Enregistrer le fournisseur d'authentification avec Java Config


@Configuration
public class MyConfigure extends WebSecurityConfigurerAdapter {
  //* L'authentification de base est requise pour toutes les URL pour vérifier le fonctionnement.
  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.httpBasic().realmName("My sample realm"); //Paramètres d'authentification de base
    http.authorizeRequests().anyRequest().authenticated(); //Définition des demandes nécessitant une authentification
  }


  // ----------------------------------------
  //Définition du haricot
  // ----------------------------------------

  @Bean
  public AuthenticationProvider getAuthenticationProvider() {
    //Utilisez votre propre fournisseur d'authentification
    return new MyUserDetailsAuthenticationProvider();
  }
}

Définition de votre propre fournisseur d'authentification


//En héritant de AbstractUserDetailsAuthenticationProvider, il est possible d'implémenter uniquement retrieveUser
public class MyUserDetailsAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider {
  private static final String DUMMY_PASSWORD = "DUMMY_PASSWORD"; //* Comme il n'est pas utilisé pour l'authentification, n'importe quelle valeur peut être utilisée.(les chaînes de caractères nulles et vides sont NG)
  private static final List<GrantedAuthority> AUTH_USER = AuthorityUtils.createAuthorityList("USER"); //* Dans cet exemple, tous ont cette autorité.

  // <<< N/A >>>
  @Override protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {}
  //---

  @Override
  protected UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
    String userId = username;
    String password = (String) authentication.getCredentials();

    //Vérifiez l'ID utilisateur et le mot de passe
    boolean isValid = AuthApi.isValidUserIdAndPassword(userId, password); //* Pseudo code qui s'authentifie avec l'API de la bibliothèque externe
    if (!isValid) { throw new UsernameNotFoundException(username); }

    //Implémentation des détails utilisateur(User)Est généré et utilisé comme valeur de retour
    return new User(username, DUMMY_PASSWORD, AUTH_USER);
  }
}

finalement

Comme je l'ai écrit au début, il y a beaucoup d'échantillons utilisant loadUserByUsername, mais pour une raison quelconque, il semblait y avoir peu d'échantillons utilisant des mots de passe pour le traitement de l'authentification, alors je l'ai recherché et l'ai écrit. Si vous avez des erreurs ou des améliorations, veuillez nous en informer.

Recommended Posts

Comment implémenter le processus d'authentification en spécifiant le nom d'utilisateur et le mot de passe dans Spring Boot
Implémentez la fonction de connexion dans Rails simplement avec le nom et le mot de passe (1)
Implémentez la fonction de connexion dans Rails simplement avec juste un nom et un mot de passe (2)
Comment appeler et utiliser l'API en Java (Spring Boot)
Comment ajouter un chemin de classe dans Spring Boot
Comment se lier avec un fichier de propriétés dans Spring Boot
Comment créer un projet Spring Boot dans IntelliJ
Comment utiliser CommandLineRunner dans Spring Batch of Spring Boot
Comment démarrer par environnement avec Spring Boot de Maven
Comment modifier la valeur de paramètre de application.properties au moment du démarrage dans Spring Boot
Implémentez la fonction de connexion simplement avec le nom et le mot de passe dans Rails (3)
Comment contrôler les transactions dans Spring Boot sans utiliser @Transactional
Je ne sais pas quel nom d'utilisateur et mot de passe saisir pour l'authentification de l'utilisateur lors du démarrage de tomcat.
Comment donner des informations utilisateur authentifiées à Spring Security autres que userId et mot de passe et comment s'y référer
Avec Spring Boot, hachez le mot de passe et utilisez l'enregistrement des membres et la sécurité Spring pour implémenter la fonction de connexion.
Comment utiliser Lombok au printemps
Comment configurer Spring Boot + PostgreSQL
Comment définir et utiliser un profil avec une configuration basée sur des annotations dans le framework Spring
Implémenter l'API REST avec Spring Boot
Comment faire coexister CsrfRequestDataValueProcessor et RequestDataValueProcessor original sur Spring Boot
Implémenter l'application Spring Boot dans Gradle
Comment utiliser ModelMapper (Spring boot)
Comment nommer des variables en Java
[Ruby on Rails] Comment se connecter avec seulement votre nom et mot de passe en utilisant le bijou
Comment afficher les caractères saisis dans Spring Boot sur le navigateur et les liens de référence [Introduction à Spring Boot / Pour les débutants]
[Spring Boot] J'ai étudié comment implémenter le post-traitement de la demande reçue.
Comment mettre en œuvre un diaporama en utilisant Slick in Rails (un par un et plusieurs par un)
[Spring Boot Actuator] Comment enregistrer manuellement votre propre processus de vérification de l'état
Comment mettre à jour les modifications utilisateur dans Rails Devise sans entrer de mot de passe
Comment mettre en œuvre la fonction d'authentification du courrier au moment de l'inscription de l'utilisateur
Comment implémenter la fonctionnalité de recherche dans Rails
Comment implémenter le calcul de la date en Java
Comment implémenter le filtre de Kalman par Java
Comment changer le nom de l'application dans les rails
Comment inclure Spring Tool dans Eclipse 4.6.3?
Comment appliquer les conventions de codage en Java
Comment implémenter la fonctionnalité de classement dans Rails
Comment implémenter le traitement asynchrone dans Outsystems
Comment diviser un fichier de message Spring Boot
Ajoutez une botte de printemps et un dégradé à éclipse
[Spring Boot] Comment obtenir des propriétés dynamiquement à partir d'une chaîne contenue dans une URL
Obtenez le nom de classe et le nom de méthode du contrôleur exécuté par le HandlerInterceptor de Spring Boot
Comment définir des variables d'environnement dans le fichier de propriétés de l'application Spring Boot
Comment utiliser MyBatis2 (iBatis) avec Spring Boot 1.4 (Spring 4)
Comment utiliser h2db intégré avec Spring Boot
Sortie des journaux de demande et de réponse avec Spring Boot
Comment réduire l'image de Spring Boot Docker
Comment utiliser les attributs de session Spring Boot (@SessionAttributes)
Essayez d'implémenter la fonction de connexion avec Spring Boot
Comment séparer .scss par contrôleur dans Rails
Comment implémenter une fonctionnalité similaire dans Rails
Comment implémenter le verrouillage optimiste dans l'API REST
Comment définir plusieurs orm.xml dans Spring4, JPA2.1
[Spring Boot] Comment se référer au fichier de propriétés
[Introduction à Spring Boot] Fonction d'authentification avec Spring Security
Spring Boot - Comment définir le délai d'expiration de la session
Comment implémenter la pagination dans GraphQL (pour ruby)
Jusqu'à ce que vous créiez un projet Spring Boot dans Intellij et que vous le transmettiez à Github
[Java] Comment obtenir la clé et la valeur stockées dans Map par traitement itératif