refactor: 스프링 시큐리티 코드 리팩터링

src/main/java/com/example/solidconnection/SolidConnectionApplication.java

@@ -2,10 +2,12 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 import org.springframework.scheduling.annotation.EnableScheduling;
 
+@ConfigurationPropertiesScan
 @EnableScheduling
 @EnableJpaAuditing
 @EnableCaching

src/main/java/com/example/solidconnection/config/token/TokenType.java → src/main/java/com/example/solidconnection/auth/domain/TokenType.java

@@ -1,13 +1,13 @@
-package com.example.solidconnection.config.token;
+package com.example.solidconnection.auth.domain;
 
 import lombok.Getter;
 
 @Getter
 public enum TokenType {
 
-    ACCESS("", 1000 * 60 * 60),
-    REFRESH("refresh:", 1000 * 60 * 60 * 24 * 7),
-    KAKAO_OAUTH("kakao:", 1000 * 60 * 60);
+    ACCESS("ACCESS:", 1000 * 60 * 60), // 1hour
+    REFRESH("REFRESH:", 1000 * 60 * 60 * 24 * 7), // 7days
+    KAKAO_OAUTH("KAKAO:", 1000 * 60 * 60); // 1hour
 
     private final String prefix;
     private final int expireTime;
@@ -17,7 +17,7 @@ public enum TokenType {
         this.expireTime = expireTime;
     }
 
-    public String addTokenPrefixToSubject(String subject) {
+    public String addPrefixToSubject(String subject) {
         return prefix + subject;
     }
 }

src/main/java/com/example/solidconnection/auth/service/AuthService.java

@@ -2,8 +2,6 @@
 
 
 import com.example.solidconnection.auth.dto.ReissueResponse;
-import com.example.solidconnection.config.token.TokenService;
-import com.example.solidconnection.config.token.TokenType;
 import com.example.solidconnection.custom.exception.CustomException;
 import com.example.solidconnection.siteuser.domain.SiteUser;
 import com.example.solidconnection.siteuser.repository.SiteUserRepository;
@@ -16,15 +14,18 @@
 import java.time.LocalDate;
 import java.util.concurrent.TimeUnit;
 
-import static com.example.solidconnection.config.token.TokenValidator.SIGN_OUT_VALUE;
+import static com.example.solidconnection.auth.domain.TokenType.ACCESS;
+import static com.example.solidconnection.auth.domain.TokenType.REFRESH;
 import static com.example.solidconnection.custom.exception.ErrorCode.REFRESH_TOKEN_EXPIRED;
 
 @RequiredArgsConstructor
 @Service
 public class AuthService {
 
+    public static final String SIGN_OUT_VALUE = "signOut";
+
     private final RedisTemplate<String, String> redisTemplate;
-    private final TokenService tokenService;
+    private final TokenProvider tokenProvider;
     private final SiteUserRepository siteUserRepository;
 
     /*
@@ -36,9 +37,9 @@ public class AuthService {
      * */
     public void signOut(String email) {
         redisTemplate.opsForValue().set(
-                TokenType.REFRESH.addTokenPrefixToSubject(email),
+                REFRESH.addPrefixToSubject(email),
                 SIGN_OUT_VALUE,
-                TokenType.REFRESH.getExpireTime(),
+                REFRESH.getExpireTime(),
                 TimeUnit.MILLISECONDS
         );
     }
@@ -62,14 +63,14 @@ public void quit(String email) {
      * */
     public ReissueResponse reissue(String email) {
         // 리프레시 토큰 만료 확인
-        String refreshTokenKey = TokenType.REFRESH.addTokenPrefixToSubject(email);
+        String refreshTokenKey = REFRESH.addPrefixToSubject(email);
         String refreshToken = redisTemplate.opsForValue().get(refreshTokenKey);
         if (ObjectUtils.isEmpty(refreshToken)) {
             throw new CustomException(REFRESH_TOKEN_EXPIRED);
         }
         // 액세스 토큰 재발급
-        String newAccessToken = tokenService.generateToken(email, TokenType.ACCESS);
-        tokenService.saveToken(newAccessToken, TokenType.ACCESS);
+        String newAccessToken = tokenProvider.generateToken(email, ACCESS);
+        tokenProvider.saveToken(newAccessToken, ACCESS);
         return new ReissueResponse(newAccessToken);
     }
 }

src/main/java/com/example/solidconnection/auth/service/SignInService.java

@@ -6,8 +6,7 @@
 import com.example.solidconnection.auth.dto.kakao.KakaoCodeRequest;
 import com.example.solidconnection.auth.dto.kakao.KakaoOauthResponse;
 import com.example.solidconnection.auth.dto.kakao.KakaoUserInfoDto;
-import com.example.solidconnection.config.token.TokenService;
-import com.example.solidconnection.config.token.TokenType;
+import com.example.solidconnection.auth.domain.TokenType;
 import com.example.solidconnection.siteuser.domain.SiteUser;
 import com.example.solidconnection.siteuser.repository.SiteUserRepository;
 import lombok.RequiredArgsConstructor;
@@ -18,7 +17,7 @@
 @Service
 public class SignInService {
 
-    private final TokenService tokenService;
+    private final TokenProvider tokenProvider;
     private final SiteUserRepository siteUserRepository;
     private final KakaoOAuthClient kakaoOAuthClient;
 
@@ -58,15 +57,15 @@ private void resetQuitedAt(String email) {
     }
 
     private SignInResponse getSignInInfo(String email) {
-        String accessToken = tokenService.generateToken(email, TokenType.ACCESS);
-        String refreshToken = tokenService.generateToken(email, TokenType.REFRESH);
-        tokenService.saveToken(refreshToken, TokenType.REFRESH);
+        String accessToken = tokenProvider.generateToken(email, TokenType.ACCESS);
+        String refreshToken = tokenProvider.generateToken(email, TokenType.REFRESH);
+        tokenProvider.saveToken(refreshToken, TokenType.REFRESH);
         return new SignInResponse(true, accessToken, refreshToken);
     }
 
     private FirstAccessResponse getFirstAccessInfo(KakaoUserInfoDto kakaoUserInfoDto) {
-        String kakaoOauthToken = tokenService.generateToken(kakaoUserInfoDto.kakaoAccountDto().email(), TokenType.KAKAO_OAUTH);
-        tokenService.saveToken(kakaoOauthToken, TokenType.KAKAO_OAUTH);
+        String kakaoOauthToken = tokenProvider.generateToken(kakaoUserInfoDto.kakaoAccountDto().email(), TokenType.KAKAO_OAUTH);
+        tokenProvider.saveToken(kakaoOauthToken, TokenType.KAKAO_OAUTH);
         return FirstAccessResponse.of(kakaoUserInfoDto, kakaoOauthToken);
     }
 }

src/main/java/com/example/solidconnection/auth/service/SignUpService.java

@@ -2,9 +2,7 @@
 
 import com.example.solidconnection.auth.dto.SignUpRequest;
 import com.example.solidconnection.auth.dto.SignUpResponse;
-import com.example.solidconnection.config.token.TokenService;
-import com.example.solidconnection.config.token.TokenType;
-import com.example.solidconnection.config.token.TokenValidator;
+import com.example.solidconnection.auth.domain.TokenType;
 import com.example.solidconnection.custom.exception.CustomException;
 import com.example.solidconnection.entity.InterestedCountry;
 import com.example.solidconnection.entity.InterestedRegion;
@@ -29,7 +27,7 @@
 public class SignUpService {
 
     private final TokenValidator tokenValidator;
-    private final TokenService tokenService;
+    private final TokenProvider tokenProvider;
     private final SiteUserRepository siteUserRepository;
     private final RegionRepository regionRepository;
     private final InterestedRegionRepository interestedRegionRepository;
@@ -51,7 +49,7 @@ public class SignUpService {
     public SignUpResponse signUp(SignUpRequest signUpRequest) {
         // 검증
         tokenValidator.validateKakaoToken(signUpRequest.kakaoOauthToken());
-        String email = tokenService.getEmail(signUpRequest.kakaoOauthToken());
+        String email = tokenProvider.getEmail(signUpRequest.kakaoOauthToken());
         validateNicknameDuplicated(signUpRequest.nickname());
         validateUserNotDuplicated(email);
 
@@ -64,9 +62,9 @@ public SignUpResponse signUp(SignUpRequest signUpRequest) {
         saveInterestedCountry(signUpRequest, savedSiteUser);
 
         // 토큰 발급
-        String accessToken = tokenService.generateToken(email, TokenType.ACCESS);
-        String refreshToken = tokenService.generateToken(email, TokenType.REFRESH);
-        tokenService.saveToken(refreshToken, TokenType.REFRESH);
+        String accessToken = tokenProvider.generateToken(email, TokenType.ACCESS);
+        String refreshToken = tokenProvider.generateToken(email, TokenType.REFRESH);
+        tokenProvider.saveToken(refreshToken, TokenType.REFRESH);
         return new SignUpResponse(accessToken, refreshToken);
     }
 

src/main/java/com/example/solidconnection/auth/service/TokenProvider.java

@@ -0,0 +1,51 @@
+package com.example.solidconnection.auth.service;
+
+import com.example.solidconnection.auth.domain.TokenType;
+import com.example.solidconnection.config.security.JwtProperties;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.concurrent.TimeUnit;
+
+import static com.example.solidconnection.util.JwtUtils.parseSubject;
+import static com.example.solidconnection.util.JwtUtils.parseSubjectOrElseThrow;
+
+@RequiredArgsConstructor
+@Component
+public class TokenProvider {
+
+    private final RedisTemplate<String, String> redisTemplate;
+    private final JwtProperties jwtProperties;
+
+    public String generateToken(String email, TokenType tokenType) {
+        Claims claims = Jwts.claims().setSubject(email);
+        Date now = new Date();
+        Date expiredDate = new Date(now.getTime() + tokenType.getExpireTime());
+        return Jwts.builder()
+                .setClaims(claims)
+                .setIssuedAt(now)
+                .setExpiration(expiredDate)
+                .signWith(SignatureAlgorithm.HS512, jwtProperties.secret())
+                .compact();
+    }
+
+    public String saveToken(String token, TokenType tokenType) {
+        String subject = parseSubjectOrElseThrow(token, jwtProperties.secret());
+        redisTemplate.opsForValue().set(
+                tokenType.addPrefixToSubject(subject),
+                token,
+                tokenType.getExpireTime(),
+                TimeUnit.MILLISECONDS
+        );
+        return token;
+    }
+
+    public String getEmail(String token) {
+        return parseSubject(token, jwtProperties.secret());
+    }
+}

src/main/java/com/example/solidconnection/config/token/TokenValidator.java → src/main/java/com/example/solidconnection/auth/service/TokenValidator.java

@@ -1,5 +1,6 @@
-package com.example.solidconnection.config.token;
+package com.example.solidconnection.auth.service;
 
+import com.example.solidconnection.auth.domain.TokenType;
 import com.example.solidconnection.custom.exception.CustomException;
 import io.jsonwebtoken.Claims;
 import io.jsonwebtoken.Jwts;
@@ -12,72 +13,64 @@
 import java.util.Date;
 import java.util.Objects;
 
+import static com.example.solidconnection.auth.domain.TokenType.ACCESS;
+import static com.example.solidconnection.auth.domain.TokenType.KAKAO_OAUTH;
+import static com.example.solidconnection.auth.domain.TokenType.REFRESH;
 import static com.example.solidconnection.custom.exception.ErrorCode.ACCESS_TOKEN_EXPIRED;
+import static com.example.solidconnection.custom.exception.ErrorCode.EMPTY_TOKEN;
 import static com.example.solidconnection.custom.exception.ErrorCode.INVALID_SERVICE_PUBLISHED_KAKAO_TOKEN;
-import static com.example.solidconnection.custom.exception.ErrorCode.INVALID_TOKEN;
 import static com.example.solidconnection.custom.exception.ErrorCode.REFRESH_TOKEN_EXPIRED;
-import static com.example.solidconnection.custom.exception.ErrorCode.USER_ALREADY_SIGN_OUT;
 
 @Component
 @RequiredArgsConstructor
 public class TokenValidator {
 
-    public static final String SIGN_OUT_VALUE = "signOut";
-
     private final RedisTemplate<String, String> redisTemplate;
 
     @Value("${jwt.secret}")
     private String secretKey;
 
     public void validateAccessToken(String token) {
         validateTokenNotEmpty(token);
-        validateTokenNotExpired(token, TokenType.ACCESS);
-        validateNotSignOut(token);
+        validateTokenNotExpired(token, ACCESS);
         validateRefreshToken(token);
     }
 
     public void validateKakaoToken(String token) {
         validateTokenNotEmpty(token);
-        validateTokenNotExpired(token, TokenType.KAKAO_OAUTH);
+        validateTokenNotExpired(token, KAKAO_OAUTH);
         validateKakaoTokenNotUsed(token);
     }
 
     private void validateTokenNotEmpty(String token) {
         if (!StringUtils.hasText(token)) {
-            throw new CustomException(INVALID_TOKEN);
+            throw new CustomException(EMPTY_TOKEN);
         }
     }
 
     private void validateTokenNotExpired(String token, TokenType tokenType) {
         Date expiration = getClaim(token).getExpiration();
         long now = new Date().getTime();
         if ((expiration.getTime() - now) < 0) {
-            if (tokenType.equals(TokenType.ACCESS)) {
+            if (tokenType.equals(ACCESS)) {
                 throw new CustomException(ACCESS_TOKEN_EXPIRED);
             }
-            if (token.equals(TokenType.KAKAO_OAUTH)) {
+            if (token.equals(KAKAO_OAUTH)) {
                 throw new CustomException(INVALID_SERVICE_PUBLISHED_KAKAO_TOKEN);
             }
         }
     }
 
-    private void validateNotSignOut(String token) {
-        String email = getClaim(token).getSubject();
-        if (SIGN_OUT_VALUE.equals(redisTemplate.opsForValue().get(TokenType.REFRESH.addTokenPrefixToSubject(email)))) {
-            throw new CustomException(USER_ALREADY_SIGN_OUT);
-        }
-    }
-
     private void validateRefreshToken(String token) {
         String email = getClaim(token).getSubject();
-        if (redisTemplate.opsForValue().get(TokenType.REFRESH.addTokenPrefixToSubject(email)) == null) {
+        if (redisTemplate.opsForValue().get(REFRESH.addPrefixToSubject(email)) == null) {
             throw new CustomException(REFRESH_TOKEN_EXPIRED);
         }
     }
 
     private void validateKakaoTokenNotUsed(String token) {
         String email = getClaim(token).getSubject();
-        if (!Objects.equals(redisTemplate.opsForValue().get(TokenType.KAKAO_OAUTH.addTokenPrefixToSubject(email)), token)) {
+        if (!Objects.equals(redisTemplate.opsForValue().get(KAKAO_OAUTH.addPrefixToSubject(email)), token)) {
             throw new CustomException(INVALID_SERVICE_PUBLISHED_KAKAO_TOKEN);
         }
     }

src/main/java/com/example/solidconnection/config/security/CorsProperties.java

@@ -0,0 +1,9 @@
+package com.example.solidconnection.config.security;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import java.util.List;
+
+@ConfigurationProperties(prefix = "cors")
+public record CorsProperties(List<String> allowedOrigins) {
+}