Feat/#15/week6 hw

build.gradle

@@ -36,4 +36,17 @@ dependencies {
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
     implementation 'org.springframework.boot:spring-boot-starter-security'
+
+    // JWT
+    implementation 'io.jsonwebtoken:jjwt-api:0.12.5'
+    runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.12.5'
+    runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.12.5'
+
+    // Spring Security
+    implementation 'org.springframework.boot:spring-boot-starter-security'
+
+    // WebClient (카카오 API 호출용)
+    implementation 'org.springframework.boot:spring-boot-starter-webflux'
+    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
+
 }

src/main/java/org/sopt/auth/code/AuthSuccessCode.java

@@ -6,8 +6,13 @@
 
 @Getter
 public enum AuthSuccessCode implements ResponseCode {
+    LOGIN_SUCCESS(HttpStatus.OK,"로그인 성공!"),
+    KAKAO_LOGIN_SUCCESS(HttpStatus.OK,"카카오 로그인 성공!"),
+    SIGNUP_SUCCESS(HttpStatus.OK,"회원가입 성공!"),
     TOKEN_GENERATED(HttpStatus.CREATED, "토큰 발급 완료!"),
-    USER_SEARCHED(HttpStatus.OK,"유저 조회 완료!");
+    USER_SEARCHED(HttpStatus.OK,"유저 조회 완료!"),
+    LOGOUT_SUCCESS(HttpStatus.OK,"로그아웃 성공!")
+    ;
 
     private final HttpStatus status;
     private final String message;

src/main/java/org/sopt/auth/controller/AuthController.java

@@ -1,45 +1,103 @@
 package org.sopt.auth.controller;
 
 import io.swagger.v3.oas.annotations.Operation;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.sopt.auth.code.AuthSuccessCode;
+import org.sopt.auth.dto.request.SignUpRequest;
 import org.sopt.auth.service.AuthService;
 import org.sopt.auth.dto.TokenResponse;
+import org.sopt.auth.util.AccessTokenResolver;
+import org.sopt.auth.util.CookieUtil;
+import org.sopt.auth.util.HeaderUtil;
 import org.sopt.global.api.response.BaseResponse;
 import org.sopt.user.dto.UserResponse;
 import org.springframework.http.ResponseEntity;
-import org.springframework.security.core.Authentication;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
+import org.sopt.auth.dto.request.LoginRequest;
+import org.sopt.auth.dto.request.KakaoLoginRequest;
+
 
 @RestController
 @RequiredArgsConstructor
-@RequestMapping("/api/v1/auth")
+@RequestMapping("/auth")
 public class AuthController {
 
     private final AuthService authService;
 
+    @Operation(summary = "회원가입 (Access Token + Refresh Token 발급)")
+    @PostMapping("/signup")
+    public ResponseEntity<BaseResponse<Void>> signup(
+            @RequestBody @Valid final SignUpRequest request,
+            HttpServletResponse response
+    ) {
+        TokenResponse tokens = authService.signUp(request);
+        setTokens(response, tokens);
+        return ResponseEntity.ok(BaseResponse.success(AuthSuccessCode.SIGNUP_SUCCESS));
+    }
+
+
     @Operation(summary = "로그인 (Access Token + Refresh Token 발급)")
     @PostMapping("/login")
-    public ResponseEntity<BaseResponse<TokenResponse>> login(
-            @RequestParam("email") String email,
-            @RequestParam("password") String password
+    public ResponseEntity<BaseResponse<Void>> login(
+            @RequestBody @Valid final LoginRequest request,
+            HttpServletResponse response
     ) {
-        TokenResponse tokens = authService.login(email, password);
-        //todo: 리프레시 토큰 쿠키로 담아서 보내도록 helper metohd private으로 하기 !!
-        return ResponseEntity.ok(BaseResponse.success(AuthSuccessCode.TOKEN_GENERATED,tokens));
+        TokenResponse tokens = authService.login(request);
+        setTokens(response, tokens);
+        return ResponseEntity.ok(BaseResponse.success(AuthSuccessCode.LOGIN_SUCCESS));
     }
 
-    @Operation(summary = "내 정보 조회 (Access Token 검증)")
-    @GetMapping("/api/v1/me")
-    public ResponseEntity<BaseResponse<UserResponse>> me(Authentication authentication) {
+    @Operation(summary = "카카오 로그인 (인가코드로 토큰 발급)")
+    @PostMapping("/kakao")
+    public ResponseEntity<BaseResponse<Void>> kakaoLogin(
+            @RequestBody @Valid final KakaoLoginRequest request,
+            HttpServletResponse response
+    ) {
+        TokenResponse tokens = authService.kakaoLogin(request.code());
+        setTokens(response, tokens);
+        return ResponseEntity.ok(BaseResponse.success(AuthSuccessCode.KAKAO_LOGIN_SUCCESS));
+    }
 
-        if (authentication == null || authentication.getPrincipal() == null) {
-            throw new IllegalArgumentException("인증되지 않았습니다.");
-        }
+    @Operation(summary = "토큰 재발급")
+    @PostMapping("/reissue")
+    public ResponseEntity<BaseResponse<Void>> reissue(
+            HttpServletRequest request,
+            HttpServletResponse response
+    ) {
+        String refreshToken = CookieUtil.getRefreshToken(request);
+        TokenResponse tokens = authService.reissue(refreshToken);
+        setTokens(response, tokens);
+        return ResponseEntity.ok(BaseResponse.success(AuthSuccessCode.TOKEN_GENERATED));
+    }
 
-        Long memberId = Long.parseLong(authentication.getName());
+    @Operation(summary = "내 정보 조회 (Access Token 검증)")
+    @GetMapping("/me")
+    public ResponseEntity<BaseResponse<UserResponse>> me(
+            @AuthenticationPrincipal Long memberId
+    ) {
         UserResponse member = authService.getMemberById(memberId);
-
         return ResponseEntity.ok(BaseResponse.success(AuthSuccessCode.USER_SEARCHED,member));
     }
+
+    @Operation(summary = "로그아웃")
+    @PostMapping("/logout")
+    public ResponseEntity<BaseResponse<Void>> logout(
+            @AuthenticationPrincipal Long memberId,
+            HttpServletRequest request,
+            HttpServletResponse response
+    ) {
+        String accessToken = AccessTokenResolver.resolve(request);
+        authService.logout(memberId,accessToken);
+        CookieUtil.deleteCookie(response, "refreshToken");
+        return ResponseEntity.ok(BaseResponse.success(AuthSuccessCode.LOGOUT_SUCCESS));
+    }
+
+    private void setTokens(HttpServletResponse response, TokenResponse tokens) {
+        HeaderUtil.setAuthorizationHeader(response, tokens.accessToken());
+        CookieUtil.addRefreshTokenCookie(response, tokens.refreshToken());
+    }
 }

src/main/java/org/sopt/auth/dto/request/KakaoLoginRequest.java

@@ -0,0 +1,5 @@
+package org.sopt.auth.dto.request;
+
+public record KakaoLoginRequest(
+        String code
+) {}

src/main/java/org/sopt/auth/dto/request/LoginRequest.java

@@ -0,0 +1,7 @@
+package org.sopt.auth.dto.request;
+
+public record LoginRequest(
+        String email,
+        String password
+) {
+}

src/main/java/org/sopt/auth/dto/request/SignUpRequest.java

@@ -0,0 +1,7 @@
+package org.sopt.auth.dto.request;
+
+public record SignUpRequest(
+        String nickname,
+        String email,
+        String password
+) {}

src/main/java/org/sopt/auth/exception/code/AuthErrorCode.java

@@ -0,0 +1,32 @@
+package org.sopt.auth.exception.code;
+
+import org.sopt.global.api.code.ResponseCode;
+import org.springframework.http.HttpStatus;
+
+public enum AuthErrorCode implements ResponseCode {
+    INVALID_REFRESH_TOKEN(HttpStatus.UNAUTHORIZED, "유효하지 않은 리프레시 토큰입니다."),
+    USER_NOT_FOUND(HttpStatus.NOT_FOUND, "유저를 찾을 수 없습니다."),
+    KAKAO_USER_CANNOT_LOGIN(HttpStatus.BAD_REQUEST, "카카오로 가입한 유저입니다. 카카오 로그인을 이용해주세요."),
+    UNAUTHORIZED(HttpStatus.UNAUTHORIZED, "인증에 실패했습니다."),
+    EMAIL_ALREADY_EXISTS(HttpStatus.CONFLICT, "이미 존재하는 이메일입니다."),
+    SIGNUP_REQUIRED(HttpStatus.NOT_FOUND,"회원가입이 필요합니다."),
+    INVALID_PASSWORD(HttpStatus.UNAUTHORIZED, "비밀번호가 일치하지 않습니다."),
+
+    EMPTY_TOKEN(HttpStatus.UNAUTHORIZED, "토큰이 비어있습니다."),
+    MALFORMED_TOKEN(HttpStatus.UNAUTHORIZED, "토큰 형식이 올바르지 않습니다."),
+    EXPIRED_TOKEN(HttpStatus.UNAUTHORIZED, "토큰이 만료되었습니다.");
+
+    private final HttpStatus status;
+    private final String message;
+
+    AuthErrorCode(HttpStatus status, String message) {
+        this.status = status;
+        this.message = message;
+    }
+
+    @Override
+    public HttpStatus getStatus() { return status; }
+
+    @Override
+    public String getMessage() { return message; }
+}

src/main/java/org/sopt/global/api/jwt/JwtAuthFilter.java → src/main/java/org/sopt/auth/jwt/JwtAuthFilter.java

@@ -1,12 +1,12 @@
-package org.sopt.global.api.jwt;
+package org.sopt.auth.jwt;
 
-import com.auth0.jwt.exceptions.JWTVerificationException;
 import jakarta.servlet.FilterChain;
 import jakarta.servlet.ServletException;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
-import org.sopt.auth.service.JwtService;
+import org.sopt.auth.service.BlacklistService;
+import org.sopt.global.api.exception.BaseException;
 import org.springframework.http.HttpHeaders;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.core.context.SecurityContextHolder;
@@ -22,6 +22,7 @@
 public class JwtAuthFilter extends OncePerRequestFilter {
 
     private final JwtService jwtService;
+    private final BlacklistService blacklistService;
 
     @Override
     protected void doFilterInternal(
@@ -30,20 +31,26 @@ protected void doFilterInternal(
             FilterChain filterChain
     ) throws ServletException, IOException {
         String header = request.getHeader(HttpHeaders.AUTHORIZATION);
+        System.out.println(">>> Header: " + header);
+
         if (header != null && header.startsWith("Bearer ")) {
             String token = header.substring("Bearer ".length()).trim();
             try {
+                if (blacklistService.isBlacklisted(token)) {
+                    filterChain.doFilter(request, response);
+                    return;
+                }
                 Long memberId = jwtService.verifyAndGetMemberId(token);
+                System.out.println(">>> 인증 성공, memberId: " + memberId);
                 UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken(
-                        String.valueOf(memberId), null, Collections.emptyList());
+                        memberId, null, Collections.emptyList());
                 auth.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                 SecurityContextHolder.getContext().setAuthentication(auth);
-            } catch (IllegalArgumentException | JWTVerificationException e) {
-                // 유효하지 않은 토큰 또는 토큰이 없는 경우, 인증 없이 다음 필터로 넘겨요.
-                // 여기서 예외를 던지지 않는 이유는, /v1/login 같이 인증이 필요 없는 API도
-                // 이 필터를 거치기 때문이에요. 인증 여부 판단은 SecurityConfig의
-                // authorizeHttpRequests 설정에서 담당합니다.
+            } catch (BaseException e) {
+                System.out.println(">>> 토큰 검증 실패: " + e.getMessage());
             }
+        } else {
+            System.out.println(">>> Authorization 헤더 없음 또는 Bearer 형식 아님");
         }
 
         filterChain.doFilter(request, response);

src/main/java/org/sopt/auth/service/JwtService.java → src/main/java/org/sopt/auth/jwt/JwtService.java

@@ -1,8 +1,12 @@
-package org.sopt.auth.service;
+package org.sopt.auth.jwt;
 
 import com.auth0.jwt.JWT;
 import com.auth0.jwt.algorithms.Algorithm;
+import com.auth0.jwt.exceptions.JWTVerificationException;
+import com.auth0.jwt.exceptions.TokenExpiredException;
 import com.auth0.jwt.interfaces.DecodedJWT;
+import org.sopt.auth.exception.code.AuthErrorCode;
+import org.sopt.global.api.exception.BaseException;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
@@ -46,14 +50,32 @@ public String generateRefreshToken(Long memberId) {
     }
 
     public Long verifyAndGetMemberId(String token) {
+
         if (token == null || token.isBlank()) {
-            throw new IllegalArgumentException("토큰이 없습니다.");
+            throw new BaseException(AuthErrorCode.EMPTY_TOKEN);
         }
-        DecodedJWT jwt = JWT.require(algorithm).build().verify(token);
+
         try {
+            DecodedJWT jwt = JWT.require(algorithm).build().verify(token);
             return Long.parseLong(jwt.getSubject());
+        } catch (TokenExpiredException e) {
+            throw new BaseException(AuthErrorCode.EXPIRED_TOKEN);
+        } catch (JWTVerificationException e) {
+            throw new BaseException(AuthErrorCode.MALFORMED_TOKEN);
         } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("JWT의 회원 정보가 올바르지 않습니다.");
+            throw new BaseException(AuthErrorCode.MALFORMED_TOKEN);
+        }
+    }
+
+    public long getRemainingMillis(String token) {
+        try {
+            DecodedJWT jwt = JWT.require(algorithm).build().verify(token);
+            Date expiration = jwt.getExpiresAt();
+            return expiration.getTime() - System.currentTimeMillis();
+        } catch (TokenExpiredException e) {
+            return 0;
+        } catch (JWTVerificationException e) {
+            throw new BaseException(AuthErrorCode.MALFORMED_TOKEN);
         }
     }
 }

src/main/java/org/sopt/auth/jwt/exception/EmptyTokenException.java

@@ -0,0 +1,10 @@
+package org.sopt.auth.jwt.exception;
+
+import org.sopt.auth.exception.code.AuthErrorCode;
+import org.sopt.global.api.exception.BaseException;
+
+public class EmptyTokenException extends BaseException {
+    public EmptyTokenException() {
+        super(AuthErrorCode.EMPTY_TOKEN);
+    }
+}

src/main/java/org/sopt/auth/jwt/exception/MalformedTokenException.java

@@ -0,0 +1,10 @@
+package org.sopt.auth.jwt.exception;
+
+import org.sopt.auth.exception.code.AuthErrorCode;
+import org.sopt.global.api.exception.BaseException;
+
+public class MalformedTokenException extends BaseException {
+    public MalformedTokenException() {
+        super(AuthErrorCode.MALFORMED_TOKEN);
+    }
+}