로그인

jjwt 의존

// jjwt - gateway와 동일한 버전의 jjwt 사용
implementation "io.jsonwebtoken:jjwt-api:${jjwtVersion}"
runtimeOnly "io.jsonwebtoken:jjwt-impl:${jjwtVersion}"
runtimeOnly "io.jsonwebtoken:jjwt-jackson:${jjwtVersion}"

application.yml

jwt:
  secret: ${JWT_SECRET}
  access-token-expiration-ms: 86400000   # 24시간
  # access-token-expiration-ms: 900000   # 운영시 15분

JwtProperties

package com.pagely.userservice.infrastructure.security;

/**
 * JWT 관련 설정 매핑.
 *
 * @param secret                  JWT 서명용 비밀키 (HS256, 32바이트 이상)
 * @param accessTokenExpirationMs AccessToken 만료 시간 (밀리초)
 */
@ConfigurationProperties(prefix = "jwt") // ServiceApplication - @EnableConfigurationProperties(JwtProperties.class)
public record JwtProperties(
        String secret,
        long accessTokenExpirationMs
) {
}

JwtProvider

@Component
public class JwtTokenProvider {

    private static final String CLAIM_ROLE = "role";

    private final SecretKey secretKey;
    private final long accessTokenExpirationMs;

    public JwtTokenProvider(JwtProperties jwtProperties) {
        this.secretKey = Keys.hmacShaKeyFor(
                jwtProperties.secret().getBytes(StandardCharsets.UTF_8)
        );
        this.accessTokenExpirationMs = jwtProperties.accessTokenExpirationMs();
    }

    /**
     * AccessToken 생성.
     *
     * @param userId 유저 UUID (sub 클레임)
     * @param role   유저 권한 문자열 (role 클레임)
     * @return JWT 토큰 문자열
     */
    public String createAccessToken(UUID userId, String role) {
        long now = System.currentTimeMillis();
        Date issuedAt = new Date(now);
        Date expiration = new Date(now + accessTokenExpirationMs);

        return Jwts.builder()
                .subject(userId.toString())
                .claim(CLAIM_ROLE, role)
                .issuedAt(issuedAt)
                .expiration(expiration)
                .signWith(secretKey)
                .compact();
    }

    /**
     * 만료 시간(초 단위) 반환. 응답 DTO 의 expiresIn 에 사용.
     */
    public long getAccessTokenExpirationSeconds() {
        return accessTokenExpirationMs / 1000;
    }
}

DTO

/**
 * 토큰 발급 응답 DTO.
 *
 * <p>OAuth 2.0 RFC 6749 의 token endpoint 응답 형식 참조.</p>
 *
 * @param accessToken 발급된 JWT
 * @param tokenType   토큰 타입 (항상 "Bearer")
 * @param expiresIn   만료까지 남은 시간 (초)
 */
public record TokenResponse(
        String accessToken,
        String tokenType,
        long expiresIn
) {

    public static TokenResponse of(String accessToken, long expiresInSeconds) {
        return new TokenResponse(accessToken, "Bearer", expiresInSeconds);
    }
}

🎓 OAuth 2.0 표준 형식

RFC 6749 Section 5.1:
{
  "access_token": "...",
  "token_type": "Bearer",
  "expires_in": 3600
}

표준을 따르면
클라이언트 라이브러리 호환이 쉽다. (axios interceptor 등 자동 인식)
추후 RefreshToken 추가 시 OAuth 2.0로 쉽게 확장할 수 있다.

표준은 snake_case(access_token) 이지만,
서비스 내 일관성을 우선해서 camelCase를(accessToken) 사용하기로 했다.
외부 OAuth 호환 필요 시 @JsonProperty 로 변환하면 된다고 한다.

/**
 * 로그인 요청 DTO.
 *
 * <p>POST /api/v1/auth/token 의 Request Body.</p>
 */
public record LoginRequest(
        @NotBlank(message = "로그인 아이디는 필수입니다.")
        String loginId,

        @NotBlank(message = "비밀번호는 필수입니다.")
        String password
) {
    public LoginCommand toCommand() {
        return new LoginCommand(
                loginId,
                password
        );
    }
}

AuthController

@RestController
@RequestMapping("/api/v1/auth")
@RequiredArgsConstructor
public class AuthController {

    private final AuthApplicationService authApplicationService;

    @PostMapping("/token")
    public ResponseEntity<ApiResponse> login(@Valid @RequestBody LoginRequest request) {
        TokenResponse response = authApplicationService.login(request.toCommand());
        return ApiResponse.ok(response);
    }
}

UserContextHolder 구현

ThreadLocal 개념 정리

ThreadLocal이란?

각 스레드마다 자기만의 독립된 변수 저장소.

1. 일반 변수는 모든 스레드가 공유:

private static String shared = "hello";
// 스레드 A 가 "world" 로 변경하면
// 스레드 B 도 "world" 로 보임 → 동시성 문제

2. ThreadLocal 은 스레드별로 격리

public static final ThreadLocal<UserContext> CONTEXT;

┌──────────────────────────────────┐       ┌──────────────────────────────────┐
│           Thread A               │       │           Thread B               │
├──────────────────────────────────┤       ├──────────────────────────────────┤
│ ┌──────────────────────────────┐ │       │ ┌──────────────────────────────┐ │
│ │       ThreadLocalMap         │ │       │ │       ThreadLocalMap         │ │
│ ├──────────────┬───────────────┤ │       │ ├──────────────┬───────────────┤ │
│ │     Key      │    Value      │ │       │ │     Key      │    Value      │ │
│ ├──────────────┼───────────────┤ │       │ ├──────────────┼───────────────┤ │
│ │   CONTEXT    │    userA      │ │       │ │   CONTEXT    │    userB      │ │
│ └──────────────┴───────────────┘ │       │ └──────────────┴───────────────┘ │
└──────────────────────────────────┘       └──────────────────────────────────┘
                                (A,B 서로 간섭 불가)

메모리 누수 위험 - clear가 필요한 이유

시나리오: Tomcat 같은 스레드 풀 환경
Tomcat 의 워커 스레드 풀: 200개 스레드

[요청 1]
  스레드 A 받음
  CONTEXT.set(userA)    ← Thread A 의 Map 에 저장
  ... 처리 ...
  응답 반환
  ← 이 시점에 CLEAR 하지 않으면 ?

[요청 2 (다른 사용자)]
  스레드 A 다시 받음 (스레드 풀에서 재사용)
  CONTEXT.get()         ← userA 그대로 남아있음! ❌
  → 다른 사용자 요청을 처리하면서 이전 사용자 정보 사용
  → **권한 누수 / 보안 사고**

그래서 try-finally + clear()

try {
    UserContextHolder.set(...);
    chain.doFilter(...);
} finally {
    UserContextHolder.clear();  // 필수
}

ThreadLocal 의 한계

① 비동기 작업 시 컨텍스트 안 넘어감

public void method() {
    UserContextHolder.set(userA);
    
    CompletableFuture.supplyAsync(() -> {
        // 별도 스레드에서 실행
        return UserContextHolder.get();   // null!
    });
}

이유: ThreadLocal 은 현재 스레드만 인식. 다른 스레드는 자기 Map 만 봄.
해결법

• InheritableThreadLocal — 자식 스레드 생성 시 복사 (근본 해결 아님)
• TaskDecorator — Spring 의 비동기 작업 시 명시적으로 컨텍스트 복사
• MDC (SLF4J) — 로깅에 한해 비슷한 패턴
• 수동 전달 — 람다 캡처

→ MVP 에선 동기 처리에서만 사용 고려.

로그인 후 게이트웨이 헤더 주입 확인

어노테이션 테스트

 @GetMapping("/me/_debug")
    @AuthRequired
    public ResponseEntity<ApiResponse> debugMe(
            @CurrentUserId UUID userId,
            @CurrentUserRole Role role
    ) {
        return ApiResponse.ok(Map.of(
                "userId", userId.toString(),
                "role", role.name()
        ));
    }

공통 모듈로 이관