Pular para o conteúdo principal

Capítulo 4: Curso Complementar

🎯 Objetivos​

  • Aprofundar os conceitos com os cursos complementares
  • Explorar os módulos 22 a 28 sobre segurança
  • Dominar os aspectos avançados do projeto

📚 Recurso Principal​

Curso Complementar

Todos os cursos complementares estão disponíveis no repositório:

📖 Pasta Curso

Foco especial nos módulos 22 a 28 para a parte de segurança.

🗂️ Estrutura dos Cursos​

A pasta cours/ contém uma série de módulos progressivos:

Visão geral​

MóduloTemaDescrição
01-10FundamentosBases do projeto, setup, arquitetura
11-18Segurança DetalhadaSpring Security passo a passo (ver Capítulo 5)
19-21API AvançadaEndpoints complexos, validação
22-28Segurança AvançadaJWT, papéis, proteção de rotas

🔐 Foco: Módulos 22 a 28 (Segurança)​

Estes módulos cobrem os aspectos avançados de segurança:

Módulo 22: Introdução ao Spring Security​

  • Configuração básica
  • Filtros de segurança
  • AuthenticationManager

Módulo 23: Autenticação por Formulário​

  • UserDetailsService
  • PasswordEncoder
  • Armazenamento de usuários

Módulo 24: JWT (JSON Web Tokens)​

  • Geração de tokens
  • Validação de tokens
  • Estrutura de um JWT
// Estrutura de um JWT
{
  "header": {
    "alg": "HS256",
    "typ": "JWT"
  },
  "payload": {
    "sub": "user@example.com",
    "iat": 1609459200,
    "exp": 1609545600,
    "roles": ["USER", "ADMIN"]
  },
  "signature": "..."
}

Módulo 25: Filtros de Autenticação​

  • JwtAuthenticationFilter
  • Cadeia de filtros do Spring Security
  • OncePerRequestFilter
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {
        
        String authHeader = request.getHeader("Authorization");
        
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            // Validar o token e autenticar
        }
        
        filterChain.doFilter(request, response);
    }
}

Módulo 26: Autorização baseada em Papéis​

  • @PreAuthorize
  • @Secured
  • hasRole() e hasAuthority()
@RestController
@RequestMapping("/api/admin")
public class AdminController {
    
    @GetMapping("/leads")
    @PreAuthorize("hasRole('ADMIN')")
    public List<LeadDto> getAllLeads() {
        return leadService.getAllLeads();
    }
    
    @DeleteMapping("/leads/{id}")
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteLead(@PathVariable Long id) {
        leadService.deleteLead(id);
    }
}

Módulo 27: Proteção de Rotas​

  • Configuração SecurityFilterChain
  • Endpoints públicos vs protegidos
  • CORS e CSRF
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .csrf(csrf -> csrf.disable())
        .cors(cors -> cors.configurationSource(corsConfigurationSource()))
        .authorizeHttpRequests(auth -> auth
            // Endpoints públicos
            .requestMatchers("/api/contact").permitAll()
            .requestMatchers("/api/auth/**").permitAll()
            // Endpoints protegidos
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            // Todo o resto requer autenticação
            .anyRequest().authenticated()
        )
        .sessionManagement(session -> 
            session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
        )
        .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
        .build();
}

Módulo 28: Testes de Segurança​

  • @WithMockUser
  • Testes de autorização
  • Testes de autenticação
@SpringBootTest
@AutoConfigureMockMvc
class SecurityTests {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    void adminEndpoint_withoutAuth_returns401() throws Exception {
        mockMvc.perform(get("/api/admin/leads"))
            .andExpect(status().isUnauthorized());
    }
    
    @Test
    @WithMockUser(roles = "ADMIN")
    void adminEndpoint_withAdmin_returns200() throws Exception {
        mockMvc.perform(get("/api/admin/leads"))
            .andExpect(status().isOk());
    }
    
    @Test
    void publicEndpoint_withoutAuth_returns200() throws Exception {
        mockMvc.perform(post("/api/contact")
            .contentType(MediaType.APPLICATION_JSON)
            .content("{...}"))
            .andExpect(status().isOk());
    }
}

📋 Conceitos-Chave Abordados​

Arquitetura de Segurança​

┌─────────────────────────────────────────────────────────┐
│                    Requisição HTTP                      │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│              Security Filter Chain                       │
│  ┌───────────────────────────────────────────────────┐  │
│  │ 1. CorsFilter                                     │  │
│  │ 2. CsrfFilter (desativado para API)               │  │
│  │ 3. JwtAuthenticationFilter ◄─── Valida o token    │  │
│  │ 4. UsernamePasswordAuthenticationFilter           │  │
│  │ 5. AuthorizationFilter ◄─── Verifica papéis       │  │
│  └───────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                    Controller                           │
└─────────────────────────────────────────────────────────┘

Fluxo de Autenticação JWT​

🛠️ Exercícios Práticos​

Exercício 1: Adicionar um novo papel​

Adicionar um papel MANAGER que pode visualizar os leads mas não pode excluí-los.

Exercício 2: Token com expiração personalizada​

Modificar o tempo de validade do token JWT (ex: 1 hora ao invés de 24).

Exercício 3: Endpoint com múltiplos papéis​

Criar um endpoint acessível por ADMIN E MANAGER.

@PreAuthorize("hasAnyRole('ADMIN', 'MANAGER')")
public List<LeadDto> getLeadsForManagers() {
    // ...
}

📖 Acessar os Cursos​

Link Direto

📚 Acessar a pasta completa de cursos

Consulte os módulos 22 a 28 para um entendimento aprofundado da segurança no Spring Boot.

⏭️ Próxima Etapa​

O próximo capítulo cobre segurança de forma ainda mais detalhada com os módulos 11 a 18 dos anexos:

Capítulo 5: Segurança Avançada (Módulos 11-18) →

Voltar ao índice do módulo