[로그인, 로그아웃] 글로벌 캐시Redis에서 로컬 캐시로 변경

build.gradle

@@ -106,6 +106,12 @@ dependencies {
     // spatial type
     implementation 'org.hibernate:hibernate-spatial:6.3.1.Final'
 
+    // Spring cache
+    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-cache', version: '3.2.0'
+
+    // Caffeine
+    implementation group: 'com.github.ben-manes.caffeine', name: 'caffeine', version: '3.1.8'
+
     // Netty/Resolver/DNS/Native/MacOS
     implementation("io.netty:netty-resolver-dns-native-macos:4.1.79.Final:osx-aarch_64")
 
@@ -114,6 +120,7 @@ dependencies {
 
     // Spring Actuator
     implementation 'org.springframework.boot:spring-boot-starter-actuator'
+
 }
 
 tasks.named('test') {

src/main/java/org/guzzing/studayserver/domain/auth/config/JwtTokenCacheConfig.java

@@ -0,0 +1,35 @@
+package org.guzzing.studayserver.domain.auth.config;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.concurrent.TimeUnit;
+
+@EnableCaching
+@Configuration
+public class JwtTokenCacheConfig {
+
+    private static final int REFRESH_TOKEN_EXPIRED_DURATION = 30;
+    private static final int ACCESS_TOKEN_EXPIRED_DURATION = 1;
+    private static final int MAXIMUM_CACHE_SIZE = 10000;
+
+    @Bean
+    public Cache<String, String> refreshCacheConfig() {
+        return Caffeine.newBuilder()
+                .expireAfterWrite(REFRESH_TOKEN_EXPIRED_DURATION, TimeUnit.DAYS)
+                .maximumSize(MAXIMUM_CACHE_SIZE)
+                .build();
+    }
+
+    @Bean
+    public Cache<String, String> logoutCacheConfig() {
+        return Caffeine.newBuilder()
+                .expireAfterWrite(ACCESS_TOKEN_EXPIRED_DURATION, TimeUnit.DAYS)
+                .maximumSize(MAXIMUM_CACHE_SIZE)
+                .build();
+    }
+
+}

src/main/java/org/guzzing/studayserver/domain/auth/repository/LogoutTokenRepository.java

@@ -1,10 +1,33 @@
 package org.guzzing.studayserver.domain.auth.repository;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import org.guzzing.studayserver.domain.auth.config.JwtTokenCacheConfig;
+import org.springframework.stereotype.Repository;
+
 import java.util.Optional;
-import org.guzzing.studayserver.domain.auth.jwt.logout.LogoutToken;
-import org.springframework.data.repository.CrudRepository;
 
-public interface LogoutTokenRepository extends CrudRepository<LogoutToken, String> {
+@Repository
+public class LogoutTokenRepository {
+
+    private final JwtTokenCacheConfig jwtTokenCacheConfig;
+    private final Cache<String, String> logoutCache;
+
+    public LogoutTokenRepository(JwtTokenCacheConfig jwtTokenCacheConfig) {
+        this.jwtTokenCacheConfig = jwtTokenCacheConfig;
+        this.logoutCache = jwtTokenCacheConfig.logoutCacheConfig();
+    }
+
+    public String save(String logoutToken) {
+        logoutCache.put(logoutToken, logoutToken);
+        return logoutToken;
+    }
+
+    public Optional<String> findByLogoutToken(String logoutToken) {
+        return Optional.ofNullable(logoutCache.getIfPresent(logoutToken));
+    }
+
+    public void delete(String logoutToken) {
+        logoutCache.invalidate(logoutToken);
+    }
 
-    Optional<LogoutToken> findById(String accessToken);
 }

src/main/java/org/guzzing/studayserver/domain/auth/repository/RefreshTokenRepository.java

@@ -1,13 +1,42 @@
 package org.guzzing.studayserver.domain.auth.repository;
 
-import java.util.Optional;
-import org.guzzing.studayserver.domain.auth.jwt.JwtToken;
-import org.springframework.data.repository.CrudRepository;
+import com.github.benmanes.caffeine.cache.Cache;
+import org.guzzing.studayserver.domain.auth.config.JwtTokenCacheConfig;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
 @Repository
-public interface RefreshTokenRepository extends CrudRepository<JwtToken, String> {
+public class RefreshTokenRepository {
+
+    private final JwtTokenCacheConfig jwtTokenCacheConfig;
+    private final Cache<String, String> refreshCache;
+
+    public RefreshTokenRepository(JwtTokenCacheConfig jwtTokenCacheConfig) {
+        this.jwtTokenCacheConfig = jwtTokenCacheConfig;
+        this.refreshCache = jwtTokenCacheConfig.refreshCacheConfig();
+    }
+
+    public String save(String accessToken, String refreshToken) {
+        refreshCache.put(accessToken, refreshToken);
+        return refreshToken;
+    }
+
+    public Optional<String> findByAccessToken(String accessToken) {
+        return Optional.ofNullable(refreshCache.getIfPresent(accessToken));
+    }
+
+    public List<Map.Entry<String, String>> findAll() {
+        return refreshCache.asMap()
+                .entrySet()
+                .stream()
+                .toList();
+    }
 
-    Optional<JwtToken> findById(String accessToken);
+    public void deleteByAccessToken(String accessToken) {
+        refreshCache.invalidate(accessToken);
+    }
 
 }

src/main/java/org/guzzing/studayserver/domain/auth/service/AuthService.java

@@ -1,14 +1,15 @@
 package org.guzzing.studayserver.domain.auth.service;
 
 import io.jsonwebtoken.Claims;
+
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import lombok.extern.slf4j.Slf4j;
 import org.guzzing.studayserver.domain.auth.exception.TokenExpiredException;
 import org.guzzing.studayserver.domain.auth.exception.TokenIsLogoutException;
 import org.guzzing.studayserver.domain.auth.jwt.AuthToken;
 import org.guzzing.studayserver.domain.auth.jwt.AuthTokenProvider;
-import org.guzzing.studayserver.domain.auth.jwt.JwtToken;
-import org.guzzing.studayserver.domain.auth.jwt.logout.LogoutToken;
 import org.guzzing.studayserver.domain.auth.repository.LogoutTokenRepository;
 import org.guzzing.studayserver.domain.auth.repository.RefreshTokenRepository;
 import org.guzzing.studayserver.domain.auth.service.dto.AuthLogoutResult;
@@ -22,15 +23,15 @@
 public class AuthService {
 
     private final AuthTokenProvider authTokenProvider;
-    private final LogoutTokenRepository logoutTokenRepository;
     private final RefreshTokenRepository refreshTokenRepository;
+    private final LogoutTokenRepository logoutTokenRepository;
 
     public AuthService(AuthTokenProvider authTokenProvider,
-            LogoutTokenRepository logoutTokenRepository,
-            RefreshTokenRepository refreshTokenRepository) {
+                      RefreshTokenRepository refreshTokenCacheRepository,
+                       LogoutTokenRepository logoutTokenCacheRepository) {
         this.authTokenProvider = authTokenProvider;
-        this.logoutTokenRepository = logoutTokenRepository;
-        this.refreshTokenRepository = refreshTokenRepository;
+        this.refreshTokenRepository = refreshTokenCacheRepository;
+        this.logoutTokenRepository = logoutTokenCacheRepository;
     }
 
     @Transactional
@@ -47,16 +48,16 @@ public AuthRefreshResult updateToken(AuthToken authToken, Long memberId) {
 
     @Transactional
     public AuthLogoutResult logout(AuthToken authToken) {
-        refreshTokenRepository.deleteById(authToken.getToken());
-        logoutTokenRepository.save(LogoutToken.of(authToken.getToken()));
+        refreshTokenRepository.deleteByAccessToken(authToken.getToken());
+        logoutTokenRepository.save(authToken.getToken());
 
         return new AuthLogoutResult(true);
     }
 
     @Transactional(readOnly = true)
     public boolean isLogout(String accessToken) {
-        Optional<LogoutToken> byAccessToken = logoutTokenRepository.findById(accessToken);
-        if (byAccessToken.isPresent()) {
+        Optional<String> logoutToken = logoutTokenRepository.findByLogoutToken(accessToken);
+        if (logoutToken.isPresent()) {
             throw new TokenIsLogoutException(ErrorCode.IS_LOGOUT_TOKEN);
         }
 
@@ -68,7 +69,7 @@ public AuthToken saveNewAccessTokenInfo(Long memberId, String socialId, String a
         AuthToken refreshToken = findRefreshToken(accessToken);
         AuthToken newAccessToken = authTokenProvider.createAccessToken(socialId, memberId);
 
-        refreshTokenRepository.save(new JwtToken(refreshToken.getToken(), newAccessToken.getToken()));
+        refreshTokenRepository.save(newAccessToken.getToken(), refreshToken.getToken());
 
         return newAccessToken;
     }
@@ -78,7 +79,7 @@ public AuthToken saveAccessTokenCache(Long memberId, String socialId) {
         AuthToken newAccessToken = authTokenProvider.createAccessToken(socialId, memberId);
         AuthToken newRefreshToken = authTokenProvider.createRefreshToken();
 
-        refreshTokenRepository.save(new JwtToken(newRefreshToken.getToken(), newAccessToken.getToken()));
+        refreshTokenRepository.save(newAccessToken.getToken(), newRefreshToken.getToken());
 
         return newAccessToken;
     }
@@ -88,9 +89,13 @@ private boolean isNotExpiredRefreshToken(String accessToken) {
     }
 
     private AuthToken findRefreshToken(String accessToken) {
-        JwtToken jwtToken = refreshTokenRepository.findById(accessToken)
+        String refreshToken = refreshTokenRepository.findByAccessToken(accessToken)
                 .orElseThrow(() -> new TokenExpiredException(ErrorCode.EXPIRED_REFRESH_TOKEN));
-        return authTokenProvider.convertAuthToken(jwtToken.getRefreshToken());
+        return authTokenProvider.convertAuthToken(refreshToken);
+    }
+
+    public List<Map.Entry<String, String>> findAll() {
+        return refreshTokenRepository.findAll();
     }
 
 }