Spring Security અને JWT સાથે authentication અને authorization કેવી રીતે કામ કરે છે?

Question

IT Interview Practice · Accepted Answer

Spring Security એ એક servlet **filter chain** છે જે દરેક request ને તમારા controller સુધી પહોંચે તે પહેલાં intercept કરે છે. **Authentication** "તમે કોણ છો?" નો જવાબ આપે છે; **authorization** "શું તમને આ કરવાની પરવાનગી છે?" નો જવાબ આપે છે. Stateless REST APIs માટે, સામાન્ય અભિગમ server-side sessions ને બદલે **JWT** (JSON Web Token) છે.

## JWT flow

```text
POST /login (user+pass) ──▶ AuthController verifies ──▶ signs JWT ──▶ returns token
                                                                          │
Client stores it, then sends on every call:                              ▼
GET /api/orders  Authorization: Bearer <jwt> ──▶ JwtFilter validates ──▶ controller
```

Token server દ્વારા sign થાય છે, તેથી પછીની requests પર filter તેને *database lookup વગર* verify કરી શકે છે — એ જ તેને stateless અને horizontally scalable બનાવે છે.

## Filter chain configure કરવી

```java
@Configuration
@EnableMethodSecurity // enables @PreAuthorize on methods
public class SecurityConfig {

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

## Method-level authorization

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

## આ શા માટે મહત્વનું છે

Auth એ છે જ્યાં security incidents થાય છે, તેથી interviewers સાચી સહજ સમજ સાંભળે છે: **BCrypt વડે passwords hash કરો** (ક્યારેય plaintext ન સંગ્રહો), JWTs ને refresh tokens સાથે ટૂંકા-આયુષ્યવાળા રાખો, અને scalability માટે stateless tokens ને પ્રાધાન્ય આપો પણ trade-off જાણો — denylist વગર તમે JWT ને તરત revoke કરી શકતા નથી. Token APIs માટે CSRF શા માટે disable કરાય છે તે *જાણવું* copy-paste config નહીં પણ વાસ્તવિક સમજ દર્શાવે છે.

JWT flow

Filter chain configure કરવી

Method-level authorization

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો