Spring Security 6 & JWT Authentication · Aula

Implementando um filtro JWT personalizado

Crie um `OncePerRequestFilter` personalizado para interceptar requisições, extrair JWTs e autenticar usuários.

Aula 2 de 411 etapas

Implementando um filtro JWT personalizado é uma aula grátis de Spring Security 6 & JWT Authentication no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Spring Security 6 & JWT Authentication, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Spring Security 6 & JWT Authentication inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Why a Custom JWT Filter?

When using JSON Web Tokens (JWTs) for authentication, Spring Security doesn't inherently know how to process them. This is where a custom filter comes in!

A custom JWT filter intercepts incoming requests to:

Extract the JWT.
Validate its authenticity and expiration.
Inform Spring Security about the authenticated user.

The OncePerRequestFilter Base

For our custom JWT filter, we'll extend Spring's OncePerRequestFilter. This base class guarantees that your filter logic runs exactly once per HTTP request, preventing redundant processing.

It simplifies filter implementation.
Ensures efficiency for each request.
It's ideal for authentication logic.

Basic Filter Structure

Every custom filter extending OncePerRequestFilter must override the doFilterInternal method. This is where our JWT processing logic will reside.

It provides access to the HttpServletRequest, HttpServletResponse, and the FilterChain to pass the request along.

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(
        HttpServletRequest request,
        HttpServletResponse response,
        FilterChain filterChain
    ) throws ServletException, IOException {
        // Our JWT logic will go here
        filterChain.doFilter(request, response);
    }
}

Extracting the JWT

The first step in our filter is to extract the JWT from the incoming request. JWTs are typically sent in the Authorization header, prefixed with Bearer .

We need to check for this header and remove the 'Bearer ' part to get the raw token.

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(
        HttpServletRequest request,
        HttpServletResponse response,
        FilterChain filterChain
    ) throws ServletException, IOException {
        final String authHeader = request.getHeader("Authorization");
        String jwt = null;

        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            jwt = authHeader.substring(7); // Remove "Bearer " prefix
            System.out.println("Extracted JWT: " + jwt.substring(0, 5) + "...");
        } else {
            System.out.println("No JWT found or invalid header.");
        }

        filterChain.doFilter(request, response);
    }
}

Validating & Parsing (Concept)

After extraction, the JWT must be validated. This involves:

Signature verification: Ensuring the token hasn't been tampered with.
Expiration check: Confirming the token is still valid.
Claim extraction: Retrieving information like the username (subject) from the token's payload.

This validation is typically handled by a dedicated JwtService or similar utility, which our filter would use.

Loading User Details (Concept)

Once the JWT is validated and the username (or user ID) is extracted, the filter needs to load the user's specific details. This is usually done using Spring Security's UserDetailsService.

The UserDetailsService fetches the UserDetails object, which contains information like roles and authorities needed for authorization.

Setting Authentication Context

The final crucial step is to inform Spring Security that the user is authenticated for the current request. This is done by creating an Authentication object (e.g., UsernamePasswordAuthenticationToken) and setting it in the SecurityContextHolder.

Once set, Spring Security will recognize the user as authenticated for the duration of the request.

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Simulate a UserDetails object loaded from DB
        UserDetails userDetails = new User(
            "exampleUser", "[PASSWORD_HASH]", new ArrayList<>()
        );

        // Create an Authentication token
        UsernamePasswordAuthenticationToken authToken =
            new UsernamePasswordAuthenticationToken(
                userDetails, null, userDetails.getAuthorities()
            );

        // Set the Authentication in the SecurityContextHolder
        SecurityContextHolder.getContext().setAuthentication(authToken);

        System.out.println("Authentication set for: " +
            SecurityContextHolder.getContext().getAuthentication().getName());

        // Clear context after request (or for next test)
        SecurityContextHolder.clearContext();
    }
}

Runnable Filter Logic Example

Let's see a simplified, runnable example that mimics the core logic of our custom JWT filter. It simulates extracting a token and setting authentication based on its presence.

This example uses mock components to show the flow without a full Spring Boot setup.

import java.util.HashMap;
import java.util.Map;

// Simulate Spring Security components needed for the filter logic
class MockSecurityContextHolder {
    private static String authenticatedUser = null;

    public static String getAuthentication() {
        return authenticatedUser;
    }

    public static void setAuthentication(String user) {
        authenticatedUser = user;
    }

    public static void clearContext() {
        authenticatedUser = null;
    }
}

public class Main {

    // This method simulates the core logic of doFilterInternal
    public static void simulateJwtFilter(Map<String, String> requestHeaders) {
        System.out.println("--- Simulating JWT Filter Logic ---");

        final String authHeader = requestHeaders.get("Authorization");
        String jwt = null;
        String username = null;

        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            jwt = authHeader.substring(7);
            // In a real app, this extracts username from JWT payload
            username = "coddyuser"; // Simplified: assume "coddyuser" from a valid JWT
            System.out.println("Filter: JWT found: " + jwt.substring(0, 5) + "...");
        } else {
            System.out.println("Filter: No JWT found or invalid header format.");
        }

        // Check if user is already authenticated
        if (username != null && MockSecurityContextHolder.getAuthentication() == null) {
            // Simulate JWT validation (signature, expiration, etc.)
            boolean tokenValid = true; // Assume valid for this simple demo

            if (tokenValid) {
                // In a real filter, we'd load UserDetails and create an Authentication object
                MockSecurityContextHolder.setAuthentication(username);
                System.out.println("Filter: User '" + username + "' authenticated and context set.");
            } else {
                System.out.println("Filter: JWT validation failed.");
            }
        } else if (username != null && MockSecurityContextHolder.getAuthentication() != null) {
            System.out.println("Filter: User '" + username + "' already authenticated for this request.");
        }

        // In a real filter, this would call filterChain.doFilter(...)
        System.out.println("Filter: Request passed to next filter/handler.");
        System.out.println("--- Filter Logic End ---");
    }

    public static void main(String[] args) {
        // Scenario 1: Request with a valid JWT
        Map<String, String> headers1 = new HashMap<>();
        headers1.put("Authorization", "Bearer abc.def.ghi");
        simulateJwtFilter(headers1);
        System.out.println("Main: SecurityContext has authentication: " +
            (MockSecurityContextHolder.getAuthentication() != null ? MockSecurityContextHolder.getAuthentication() : "None"));
        MockSecurityContextHolder.clearContext(); // Clean up

        System.out.println("\n");

        // Scenario 2: Request without a JWT
        Map<String, String> headers2 = new HashMap<>();
        simulateJwtFilter(headers2);
        System.out.println("Main: SecurityContext has authentication: " +
            (MockSecurityContextHolder.getAuthentication() != null ? MockSecurityContextHolder.getAuthentication() : "None"));
        MockSecurityContextHolder.clearContext(); // Clean up
    }
}

Integrating with Spring Security

After creating our JwtAuthenticationFilter, we need to register it with Spring Security's filter chain. This is typically done in your security configuration class (e.g., SecurityConfig) using HttpSecurity.

We use .addFilterBefore() to ensure our JWT filter runs before Spring Security's default authentication filters, like UsernamePasswordAuthenticationFilter.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

// Assuming JwtAuthenticationFilter is defined elsewhere
class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(jakarta.servlet.http.HttpServletRequest request, jakarta.servlet.http.HttpServletResponse response, jakarta.servlet.FilterChain filterChain) throws jakarta.servlet.ServletException, java.io.IOException {
        // Simplified for config demo
        filterChain.doFilter(request, response);
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    private final JwtAuthenticationFilter jwtAuthFilter;

    // Inject our custom JWT filter
    public SecurityConfig(JwtAuthenticationFilter jwtAuthFilter) {
        this.jwtAuthFilter = jwtAuthFilter;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable()) // Disable CSRF for stateless APIs
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll() // Public endpoints
                .anyRequest().authenticated() // Secure all other requests
            )
            // Add our custom JWT filter BEFORE the default UsernamePasswordAuthenticationFilter
            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }
}

Filter Chain Challenge

Consider the JwtAuthenticationFilter we've discussed. What are its key responsibilities in the Spring Security filter chain when handling JWT-based authentication?

Responda na aula interativa

Lesson Recap: Custom JWT Filter

In this lesson, we explored how to build a custom OncePerRequestFilter to handle JWT authentication in Spring Security.

We learned to extract JWTs from the Authorization header.
We understood the conceptual steps of validating the token and loading user details.
We saw how to authenticate the user by setting the SecurityContextHolder.
Finally, we covered how to integrate this filter into Spring Security's filter chain using HttpSecurity.addFilterBefore().

This custom filter is crucial for integrating JWTs seamlessly into your secure Spring Boot applications.

Grátis para começar

Aprenda Java com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 12
Aulas: 48

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Implementando um filtro JWT personalizado” é grátis?

Sim — o texto completo de “Implementando um filtro JWT personalizado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Spring Security 6 & JWT Authentication, atualize para CoddyKit PRO. O curso de Spring Security 6 & JWT Authentication inclui 4 aulas no total.

O que vou aprender em “Implementando um filtro JWT personalizado”?

Crie um `OncePerRequestFilter` personalizado para interceptar requisições, extrair JWTs e autenticar usuários. Você pratica Spring Security 6 & JWT Authentication com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Spring Security 6 & JWT Authentication?

Nenhuma experiência prévia é necessária. Spring Security 6 & JWT Authentication no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Implementando um filtro JWT personalizado”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Spring Security 6 & JWT Authentication?

Sim. Cada aula de Spring Security 6 & JWT Authentication inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Projetando o fluxo de autenticação com JWT
Implementando um filtro JWT personalizado
Integração do AuthenticationManager com provedores
Tratando erros de autenticação e pontos de entrada

← Voltar para Spring Security 6 & JWT Authentication