[Feature/#17] refresh token 발급 시 Redis에 저장하도록 설정

.github/workflows/deploy.yml

@@ -33,7 +33,7 @@ jobs:
     - name: Gradle Authorization
       run: chmod +x gradlew
     - name: Gradle Build Run
-      run: ./gradlew build
+      run: ./gradlew build -x test
 
     - name: Create Zip files
       run: zip -r ./$GITHUB_SHA.zip .

build.gradle

@@ -31,6 +31,7 @@ dependencies {
 	// database
 	implementation 'org.mariadb.jdbc:mariadb-java-client:3.1.4'
 	runtimeOnly 'com.h2database:h2'
+	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 
 	// Querydsl
 	implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'

src/main/java/com/backend/auth/application/OAuthService.java

@@ -1,9 +1,13 @@
 package com.backend.auth.application;
 
 import com.backend.auth.jwt.TokenProvider;
-import com.backend.auth.presentation.dto.response.LoginResponse;
+import com.backend.auth.presentation.dto.response.AccessTokenResponse;
+import com.backend.auth.presentation.dto.response.TokenResponse;
+import com.backend.global.common.code.ErrorCode;
+import com.backend.global.exception.BusinessException;
 import com.backend.member.application.MemberService;
 import com.backend.member.domain.Member;
+import com.backend.member.domain.Provider;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
@@ -15,10 +19,16 @@ public class OAuthService {
 
     private final TokenProvider tokenProvider;
 
-    public LoginResponse login(String provider, String socialId) {
-        Member member = memberService.findMemberOrRegister(provider, socialId);
-        String accessToken = tokenProvider.generateAccessToken(member);
-        String refreshToken = tokenProvider.generateRefreshToken(member);
-        return new LoginResponse(accessToken, refreshToken);
+    public TokenResponse login(String provider, String uid) {
+        memberService.findMemberOrRegister(Provider.from(provider), uid);
+        String accessToken = tokenProvider.generateAccessToken(uid);
+        String refreshToken = tokenProvider.generateRefreshToken(uid);
+        return new TokenResponse(accessToken, refreshToken);
+    }
+
+    public AccessTokenResponse reissue(String refreshToken) throws Exception {
+        tokenProvider.validateToken(refreshToken);
+        String accessToken = tokenProvider.reissueAccessToken(refreshToken);
+        return new AccessTokenResponse(accessToken);
     }
 }

src/main/java/com/backend/auth/application/RefreshTokenService.java

@@ -0,0 +1,24 @@
+package com.backend.auth.application;
+
+import com.backend.auth.domain.RefreshToken;
+import com.backend.auth.domain.RefreshTokenRepository;
+import com.backend.global.common.code.ErrorCode;
+import com.backend.global.exception.BusinessException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class RefreshTokenService {
+
+    private final RefreshTokenRepository refreshTokenRepository;
+
+    public  void saveRefreshToken(String refreshToken, String uid){
+        refreshTokenRepository.save(new RefreshToken(refreshToken, uid)); 
+    }
+    public String findUidByRefreshToken(String refreshToken){
+        RefreshToken result = refreshTokenRepository.findById(refreshToken)
+                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FOUND_ERROR));
+        return result.getUid();
+    }
+}

src/main/java/com/backend/auth/config/RedisConfig.java

@@ -0,0 +1,28 @@
+package com.backend.auth.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
+
+@Configuration
+@EnableRedisRepositories
+public class RedisConfig {
+
+    @Value("${spring.data.redis.host}")
+    private String host;
+
+    @Value("${spring.data.redis.port}")
+    private int port;
+
+    @Bean
+    public RedisConnectionFactory connectionFactory(){
+        RedisStandaloneConfiguration redisConfiguration = new RedisStandaloneConfiguration();
+        redisConfiguration.setHostName(host);
+        redisConfiguration.setPort(port);
+        return new LettuceConnectionFactory(redisConfiguration);
+    }
+}

src/main/java/com/backend/auth/domain/RefreshToken.java

@@ -0,0 +1,15 @@
+package com.backend.auth.domain;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.redis.core.RedisHash;
+
+@Getter
+@AllArgsConstructor
+@RedisHash(value = "refreshToken", timeToLive = 60 * 60 * 24 * 14)
+public class RefreshToken {
+    @Id
+    private String refreshToken;
+    private String uid;
+}

src/main/java/com/backend/auth/domain/RefreshTokenRepository.java

@@ -0,0 +1,6 @@
+package com.backend.auth.domain;
+
+import org.springframework.data.repository.CrudRepository;
+
+public interface RefreshTokenRepository extends CrudRepository<RefreshToken, String> {
+}

src/main/java/com/backend/auth/jwt/TokenProvider.java

@@ -1,10 +1,10 @@
 package com.backend.auth.jwt;
 
-import com.backend.member.domain.Member;
-import io.jsonwebtoken.ExpiredJwtException;
-import io.jsonwebtoken.Jwts;
-import io.jsonwebtoken.SignatureAlgorithm;
-import io.jsonwebtoken.UnsupportedJwtException;
+import com.backend.auth.application.RefreshTokenService;
+import com.backend.auth.domain.RefreshToken;
+import com.backend.global.common.code.ErrorCode;
+import com.backend.global.exception.BusinessException;
+import io.jsonwebtoken.*;
 import io.jsonwebtoken.io.Decoders;
 import io.jsonwebtoken.security.Keys;
 import org.springframework.beans.factory.annotation.Value;
@@ -20,29 +20,39 @@ public class TokenProvider {
 
     private final Key key;
 
-    public TokenProvider(@Value("${jwt.secret}") String secretKey){
+    private final RefreshTokenService refreshTokenService;
+
+    public TokenProvider(@Value("${jwt.secret}") String secretKey, RefreshTokenService refreshTokenService){
+        this.refreshTokenService = refreshTokenService;
         byte[] keyBytes = Decoders.BASE64.decode(secretKey);
         this.key = Keys.hmacShaKeyFor(keyBytes);
     }
 
-    public String generateAccessToken(Member member){
-        return generateToken(member, ACCESS_TOKEN_EXPIRE_TIME);
+    public String generateAccessToken(String uid){
+        return generateToken(uid, ACCESS_TOKEN_EXPIRE_TIME);
     }
 
-    public String generateRefreshToken(Member member){
-        return generateToken(member, REFRESH_TOKEN_EXPIRE_TIME);
+    public String generateRefreshToken(String uid){
+        String refreshToken = generateToken(uid, REFRESH_TOKEN_EXPIRE_TIME);
+        refreshTokenService.saveRefreshToken(refreshToken, uid);
+        return refreshToken;
     }
 
-    public String generateToken(Member member, Long expireTime){
+    public String generateToken(String uid, Long expireTime){
         Date now = new Date();
         return Jwts.builder()
-                .setSubject(member.getSocialId())
+                .setSubject(uid)
                 .setIssuedAt(now)
                 .setExpiration(new Date(now.getTime() + expireTime))
                 .signWith(key, SignatureAlgorithm.HS256)
                 .compact();
     }
 
+    public String reissueAccessToken(String refreshToken) {
+        String uid =  refreshTokenService.findUidByRefreshToken(refreshToken);
+        return generateAccessToken(uid);
+    }
+
     public String getPayload(String token){
         return Jwts.parserBuilder()
                 .setSigningKey(key)
@@ -52,19 +62,16 @@ public String getPayload(String token){
                 .getSubject();
     }
 
-    public boolean validateToken(String token){
+    public void validateToken(String token) throws Exception {
         try{
             Jwts.parserBuilder()
                     .setSigningKey(key)
                     .build()
                     .parseClaimsJws(token);
-            return true;
         } catch (ExpiredJwtException e){
-            throw e;
-        } catch (UnsupportedJwtException e){
-            throw e;
-        } catch (IllegalArgumentException e){
-            throw e;
+            throw new BusinessException(ErrorCode.TOKEN_EXPIRED);
+        } catch (UnsupportedJwtException | MalformedJwtException | IllegalArgumentException e){
+            throw new Exception("잘못된 형식의 토큰입니다.");
         }
     }
 }

src/main/java/com/backend/auth/presentation/OAuthController.java

@@ -1,31 +1,45 @@
 package com.backend.auth.presentation;
 
 import com.backend.auth.application.OAuthService;
-import com.backend.auth.presentation.dto.response.LoginResponse;
+import com.backend.auth.presentation.dto.TokenReissueRequest;
+import com.backend.auth.presentation.dto.response.AccessTokenResponse;
+import com.backend.auth.presentation.dto.response.TokenResponse;
+import com.backend.global.common.code.SuccessCode;
+import com.backend.global.common.response.CustomResponse;
+import io.jsonwebtoken.MalformedJwtException;
+import io.jsonwebtoken.UnsupportedJwtException;
 import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.responses.ApiResponse;
-import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.enums.ParameterIn;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import static com.backend.global.common.code.SuccessCode.*;
+
 @Tag(name = "회원 인증", description = "소셜 로그인 API입니다.")
 @RequiredArgsConstructor
 @RestController
 public class OAuthController {
 
     private final OAuthService oauthService;
 
-    @Operation(summary = "소셜 로그인", description = "소셜 로그인 후 사용자 토큰 발급")
-    @ApiResponses({
-            @ApiResponse(responseCode = "200", description = "소셜 로그인 성공"),
-            @ApiResponse(responseCode = "400", description = "잘못된 요청으로 인한 실패"),
-            @ApiResponse(responseCode = "401", description = "접근 권한 없음")
-    })
+    @Operation(summary = "소셜 로그인",
+                description = "카카오, 애플 서버에서 로그인한 사용자의 userId를 통해 access token과 refresh token을 반환합니다.")
     @PostMapping("/auth/{provider}")
-    public ResponseEntity<LoginResponse> generateAccessToken(@PathVariable String provider, @RequestParam String userId) {
-        return ResponseEntity.ok(oauthService.login(provider, userId));
+    public ResponseEntity<CustomResponse> generateAccessTokenAndRefreshToken(
+            @Parameter(description = "kakao, apple 중 현재 로그인하는 소셜 타입", in = ParameterIn.PATH) @PathVariable String provider,
+            @Parameter(description = "사용자 ID") @RequestParam String userId) {
+        return CustomResponse.success(LOGIN_SUCCESS, oauthService.login(provider, userId));
     }
 
-}
+    @Operation(summary = "토큰 재발급",
+                description = "access token 만료 시 refresh token을 통해 access token을 재발급합니다.")
+    @PostMapping("/reissue")
+    @ExceptionHandler({UnsupportedJwtException.class, MalformedJwtException.class, IllegalArgumentException.class})
+    public ResponseEntity<CustomResponse> reissue(@Valid @RequestBody TokenReissueRequest reissueRequest) throws Exception {
+        return CustomResponse.success(LOGIN_SUCCESS, oauthService.reissue(reissueRequest.refreshToken()));
+    }
+}

src/main/java/com/backend/auth/presentation/dto/TokenReissueRequest.java

@@ -0,0 +1,8 @@
+package com.backend.auth.presentation.dto;
+
+import jakarta.validation.constraints.NotNull;
+
+public record TokenReissueRequest(
+        @NotNull(message = "access token reissue 시 refresh token 입력은 필수입니다.")
+        String refreshToken
+) { }

src/main/java/com/backend/auth/presentation/dto/response/AccessTokenResponse.java

@@ -0,0 +1,5 @@
+package com.backend.auth.presentation.dto.response;
+
+public record AccessTokenResponse (
+        String accessToken
+){ }

src/main/java/com/backend/auth/presentation/dto/response/LoginResponse.java → src/main/java/com/backend/auth/presentation/dto/response/TokenResponse.java

@@ -1,6 +1,6 @@
 package com.backend.auth.presentation.dto.response;
 
-public record LoginResponse (
+public record TokenResponse(
         String accessToken,
         String refreshToken
 ){}

src/main/java/com/backend/global/common/code/ErrorCode.java

@@ -1,9 +1,11 @@
 package com.backend.global.common.code;
 
 import lombok.Getter;
+import org.springframework.http.HttpStatus;
 
 import static org.springframework.http.HttpStatus.*;
 import static org.springframework.http.HttpStatus.NOT_FOUND;
+import static org.springframework.http.HttpStatus.UNAUTHORIZED;
 
 @Getter
 public enum ErrorCode {
@@ -54,9 +56,10 @@ public enum ErrorCode {
      */
 
     /* Plan */
-    PLAN_NOT_FOUND(NOT_FOUND.value(), "PLAN-001", "상위 목표가 존재하지 않습니다.");
-
+    PLAN_NOT_FOUND(NOT_FOUND.value(), "PLAN-001", "상위 목표가 존재하지 않습니다."),
 
+    /* Auth */
+    TOKEN_EXPIRED(UNAUTHORIZED.value(), "AUTH-001", "토큰의 유효기간이 만료되었습니다.");
 
     private final int status;
 

src/main/java/com/backend/global/common/code/SuccessCode.java

@@ -8,7 +8,8 @@ public enum SuccessCode {
     SELECT_SUCCESS(200, "SELECT SUCCESS"),
     INSERT_SUCCESS(201, "INSERT SUCCESS"),
     DELETE_SUCCESS(200, "DELETE SUCCESS"),
-    UPDATE_SUCCESS(200, "UPDATE SUCCESS");
+    UPDATE_SUCCESS(200, "UPDATE SUCCESS"),
+    LOGIN_SUCCESS(200, "LOGIN SUCCESS");
 
     private final int status;
     private final String message;

src/main/java/com/backend/global/exception/GlobalExceptionHandler.java

@@ -10,7 +10,6 @@
 import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.validation.BindException;
 import org.springframework.validation.BindingResult;
-import org.springframework.validation.FieldError;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.MissingServletRequestParameterException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
@@ -123,7 +122,7 @@ protected ResponseEntity<ErrorResponse> handleJsonProcessingException(JsonProces
     // 잡히지 않은 에러들을 일괄 처리
     @ExceptionHandler(Exception.class)
     protected ResponseEntity<ErrorResponse> handleException(Exception ex) {
-        log.error("intenalServerError", ex);
+        log.error("internalServerError", ex);
         ErrorResponse response = ErrorResponse.of(ErrorCode.SERVER_ERROR, ex.getMessage());
         return new ResponseEntity<>(response, HTTP_STATUS_OK);
     }

src/main/java/com/backend/member/application/MemberService.java

@@ -2,6 +2,7 @@
 
 import com.backend.member.domain.Member;
 import com.backend.member.domain.MemberRepository;
+import com.backend.member.domain.Provider;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
@@ -13,8 +14,8 @@ public class MemberService {
 
     private final MemberRepository memberRepository;
 
-    public Member findMemberOrRegister(String provider, String socialId) {
-        Optional<Member> member =  memberRepository.findBySocialId(socialId);
-        return member.orElseGet(() -> memberRepository.save(Member.from(provider, socialId)));
+    public Member findMemberOrRegister(Provider provider, String uid) {
+        Optional<Member> member =  memberRepository.findByUid(uid);
+        return member.orElseGet(() -> memberRepository.save(Member.from(provider, uid)));
     }
 }