Spring Security Custom AuthenticationFailureHandler – Spring Security自定义AuthenticationFailureHandler

最后修改: 2018年 7月 19日

1. Overview


In this quick tutorial, we’re going to illustrate how to customize Spring Security’s authentication failures handling in a Spring Boot application. The goal is to authenticate users using a form login approach.

在这个快速教程中,我们将说明如何在Spring Boot应用程序中定制Spring Security的认证失败处理。我们的目标是使用表单登录方法对用户进行认证

For an introduction to Spring Security and Form Login in Spring Boot, please refer to this and this article, respectively.

有关Spring Boot中的Spring SecurityForm Login的介绍,请分别参考这篇这篇文章。

2. Authentication and Authorization


Authentication and Authorization are often used in conjunction because they play an essential, and equally important, role when it comes to granting access to the system.


However, they have different meanings and apply different constraints when validating a request:


  • Authentication – precedes Authorization; it’s about validating the received credentials; it’s where we verify that both username and password match the ones that our application recognizes
  • Authorization it’s about verifying if the successfully authenticated user has permissions to access a certain functionality of the application

We can customize both authentication and authorization failures handling, however, in this application, we’re going to focus on authentication failures.


3. Spring Security’s AuthenticationFailureHandler

3.Spring Security的AuthenticationFailureHandler

Spring Security provides a component that handles authentication failures for us by default.

Spring Security提供了一个组件,默认为我们处理认证失败。

However, it’s not uncommon to find ourselves in a scenario where the default behavior isn’t enough to meet requirements.


If that is the case, we can create our own component and provide the custom behavior we want by implementing the AuthenticationFailureHandler interface:


public class CustomAuthenticationFailureHandler 
  implements AuthenticationFailureHandler {
    private ObjectMapper objectMapper = new ObjectMapper();

    public void onAuthenticationFailure(
      HttpServletRequest request,
      HttpServletResponse response,
      AuthenticationException exception) 
      throws IOException, ServletException {
        Map<String, Object> data = new HashMap<>();


By default, Spring redirects the user back to the login page with a request parameter containing information about the error.

默认情况下,Spring 重定向用户回到登录页面,其request parameter包含有关错误的信息。

In this application, we’ll return a 401 response that contains information about the error, as well as the timestamp of its occurrence.


Besides the default component, Spring has others ready to use components that we can leverage depending on what we want to do:


  • DelegatingAuthenticationFailureHandler delegates AuthenticationException subclasses to different AuthenticationFailureHandlers, meaning we can create different behaviors for different instances of AuthenticationException
  • ExceptionMappingAuthenticationFailureHandler redirects the user to a specific URL depending on the AuthenticationException’s full class name
  • ForwardAuthenticationFailureHandler will forward the user to the specified URL regardless of the type of the AuthenticationException
  • SimpleUrlAuthenticationFailureHandler is the component that is used by default, it will redirect the user to a failureUrl, if specified; otherwise, it will simply return a 401 response

Now that we have created our custom AuthenticationFailureHandler, let’s configure our application and override Spring’s default handler:


public class SecurityConfiguration {

    public InMemoryUserDetailsManager userDetailsService() {
        UserDetails user1 = User.withUsername("user1")
        return new InMemoryUserDetailsManager(user1);

    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http.build();

    public AuthenticationFailureHandler authenticationFailureHandler() {
        return new CustomAuthenticationFailureHandler();

    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();

Note the failureHandler() call – it’s where we can tell Spring to use our custom component instead of using the default one.


4. Conclusion


In this example, we customized our application’s authentication failure handler leveraging Spring’s AuthenticationFailureHandler interface.


The implementation of this example can be found in the Github project.


When running locally, you can access and test the application at localhost:8080