[JAVA] Définissez le résultat de l'authentification Spring Security sur JSON

introduction

J'ai essayé de savoir comment renvoyer le résultat de l'authentification par formulaire dans JSON avec Spring Security.

La version que j'ai vérifiée est la suivante.

Exemple de code

Code de la théorie. Veuillez d'abord consulter l'exemple de code.

JsonAuthConfigurer.java

package example;

import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

@Configuration
public class JsonAuthConfigurer extends WebSecurityConfigurerAdapter
    implements AuthenticationSuccessHandler, AuthenticationFailureHandler {
  private static final MediaType CONTENT_TYPE_JSON = MediaType.APPLICATION_JSON_UTF8;

  @Autowired
  MappingJackson2HttpMessageConverter httpMessageConverter;

  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.formLogin() //Définir l'authentification par formulaire
        .successHandler(this) //Spécification du gestionnaire lorsque l'authentification est réussie
        .failureHandler(this); //Spécification du gestionnaire lorsque l'authentification échoue
    http.authorizeRequests().anyRequest().authenticated(); //Définition des demandes nécessitant une authentification
  }


  // ------------------------------
  // AuthenticationSuccessHandler
  // ------------------------------

  @Override
  public void onAuthenticationSuccess(HttpServletRequest request,
                                      HttpServletResponse response,
                                      Authentication authentication) throws IOException {
    MyResult result = new MyResult("Authentification réussie"); //L'objet doit être JSON
    HttpOutputMessage outputMessage = new ServletServerHttpResponse(response);
    httpMessageConverter.write(result, CONTENT_TYPE_JSON, outputMessage); //Écrire à la réponse
    response.setStatus(HttpStatus.OK.value()); // 200 OK.
  }

  // ------------------------------
  // AuthenticationFailureHandler
  // ------------------------------

  @Override
  public void onAuthenticationFailure(HttpServletRequest request,
                                      HttpServletResponse response,
                                      AuthenticationException exception) throws IOException {
    MyResult result = new MyResult("Échec d'authentification"); //L'objet doit être JSON
    HttpOutputMessage outputMessage = new ServletServerHttpResponse(response);
    httpMessageConverter.write(result, CONTENT_TYPE_JSON, outputMessage); //Écrire à la réponse
    response.setStatus(HttpStatus.UNAUTHORIZED.value()); // 401 Unauthorized.
  }


  // ------------------------------

  /**Résultat d'authentification*/
  @lombok.Value
  public static class MyResult {
    private final String message;
  }

}

Pour rendre la réponse JSON

Il semble que vous devriez écrire JSON dans le contenu de la réponse avec successHandler [^ fqcn-s] et failureHandler [^ fqcn-f]. En outre, en cas d'échec de l'authentification, l'état est défini sur «401 Non autorisé».

Tips Étant donné que le processus de conversion de Response en JSON s'est terminé facilement, voici quelques conseils que j'ai remarqués après avoir essayé diverses choses.

MappingJackson2HttpMessageConverter Lors de l'écriture de JSON dans le contenu de la réponse, il est pratique d'utiliser MappingJackson2HttpMessageConverter ''. Il ajoutera également automatiquement Content-Type: application / json; charset = UTF-8 '' à l'en-tête.

Mappage automatiqueJackson2HttpMessageConverter

@Autowired
MappingJackson2HttpMessageConverter httpMessageConverter;

Ecrire JSON

httpMessageConverter.write(result, CONTENT_TYPE_JSON, outputMessage);

En passant, si vous écrivez à Response par vous-même, ce sera comme suit. [^ quote-1]

@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
  response.getWriter().write(new ObjectMapper().writeValueAsString(new UserAuthenticationResponse(authentication.getName(), 123l)));
  response.setStatus(200);
}

Implémentation de l'interface du gestionnaire

Comme indiqué dans l'exemple de code ci-dessus, l'implémentation des interfaces de divers gestionnaires dans la classe d'implémentation WebSecurityConfigurer rendra le code plus propre.

Extrait d'une partie propre

@Configuration
public class JsonAuthConfigurer extends WebSecurityConfigurerAdapter
    implements AuthenticationSuccessHandler, AuthenticationFailureHandler {
    //↑ Parce que le gestionnaire est implémenté dans cette classe...

  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.formLogin()
        .successHandler(this) //← L'argument de la spécification du gestionnaire peut être ceci
        .failureHandler(this); //← L'argument de la spécification du gestionnaire peut être ceci
  }

  //...
}

en conclusion

Il s'agit de la troisième série de certification. Les articles précédents sont les suivants.

• Utiliser l'authentification de base avec Spring Boot
• Comment implémenter le processus d'authentification en spécifiant le nom d'utilisateur et le mot de passe dans Spring Boot

J'ai l'impression de m'habituer au printemps.