Course – LSS – NPI (cat=Spring Security)
announcement - icon

If you're working on a Spring Security (and especially an OAuth) implementation, definitely have a look at the Learn Spring Security course:


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.

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

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

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

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.

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 {

    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

Course – LSS (cat=Security/Spring Security)

I just announced the new Learn Spring Security course, including the full material focused on the new OAuth2 stack in Spring Security:

res – Security (video) (cat=Security/Spring Security)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.