Hoe werken authenticatie en autorisatie met Spring Security en JWT?

Question

IT Interview Practice · Accepted Answer

Spring Security is een servlet-**filter chain** die elk request onderschept voordat het je controller bereikt. **Authenticatie** beantwoordt "wie ben je?"; **autorisatie** beantwoordt "mag je dit doen?". Voor stateless REST-API's is de gangbare aanpak **JWT** (JSON Web Token) in plaats van server-side sessies.

## De JWT-flow

```text
POST /login (user+pass) ──▶ AuthController verifieert ──▶ ondertekent JWT ──▶ geeft token terug
                                                                          │
Client bewaart hem, en stuurt bij elke call:                             ▼
GET /api/orders  Authorization: Bearer <jwt> ──▶ JwtFilter valideert ──▶ controller
```

De token wordt door de server ondertekend, dus bij latere requests kan een filter hem verifiëren *zonder een database-lookup* — dat is wat het stateless en horizontaal schaalbaar maakt.

## De filter chain configureren

```java
@Configuration
@EnableMethodSecurity // schakelt @PreAuthorize op methoden in
public class SecurityConfig {

@Bean
    SecurityFilterChain chain(HttpSecurity http) throws Exception {
        http
          .csrf(csrf -> csrf.disable())                 // stateless API: geen CSRF-cookie
          .sessionManagement(s -> s.sessionCreationPolicy(STATELESS))
          .authorizeHttpRequests(auth -> auth
              .requestMatchers("/login").permitAll()    // open endpoint
              .requestMatchers("/api/admin/**").hasRole("ADMIN") // role-check
              .anyRequest().authenticated())            // al het andere heeft een token nodig
          .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
}
```

## Autorisatie op methodeniveau

```java
@PreAuthorize("hasRole('ADMIN') or #userId == authentication.name")
public UserDto get(@PathVariable String userId) { /* ... */ }
```

## Waarom het belangrijk is

Auth is waar beveiligingsincidenten gebeuren, dus interviewers luisteren naar de juiste instincten: **wachtwoorden hashen met BCrypt** (nooit plaintext opslaan), JWT's kort houden met refresh tokens, en stateless tokens verkiezen voor schaalbaarheid maar de trade-off kennen — je kunt een JWT niet direct intrekken zonder een denylist. Weten *waarom* CSRF wordt uitgeschakeld voor token-API's laat echt begrip zien, geen copy-paste-config.

De JWT-flow

De filter chain configureren

Autorisatie op methodeniveau

Waarom het belangrijk is

Gerelateerde vragen