[feat/CK-235] Redis 캐시를 적용한다

backend/kirikiri/build.gradle

@@ -177,9 +177,6 @@ dependencies {
     testImplementation 'org.springframework.restdocs:spring-restdocs-mockmvc'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'io.rest-assured:rest-assured'
-
-    // test-containers
-    testImplementation "org.testcontainers:testcontainers:1.19.1"
 }
 
 def generated = 'build/generated'

backend/kirikiri/src/main/java/co/kirikiri/common/config/RedisConfig.java

@@ -1,33 +1,52 @@
 package co.kirikiri.common.config;
 
-import org.springframework.beans.factory.annotation.Value;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import java.time.Duration;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
 @Configuration
+@EnableCaching
+@Profile(value = {"prod", "dev", "local"})
 public class RedisConfig {
 
-    @Value("${spring.data.redis.host}")
-    private String host;
-
-    @Value("${spring.data.redis.port}")
-    private int port;
-
-    @Bean
-    public RedisConnectionFactory redisConnectionFactory() {
-        return new LettuceConnectionFactory(host, port);
-    }
-
     @Bean
-    public RedisTemplate<String, String> redisTemplate() {
+    public RedisTemplate<String, String> redisTemplate(final RedisConnectionFactory redisConnectionFactory) {
         final RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
-        redisTemplate.setConnectionFactory(redisConnectionFactory());
+        redisTemplate.setConnectionFactory(redisConnectionFactory);
         redisTemplate.setKeySerializer(new StringRedisSerializer());
         redisTemplate.setValueSerializer(new StringRedisSerializer());
         return redisTemplate;
     }
+
+    @Bean
+    public CacheManager redisCacheManager(final RedisConnectionFactory redisConnectionFactory) {
+        final ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+        objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.EVERYTHING);
+
+        final RedisSerializer<Object> serializer = new GenericJackson2JsonRedisSerializer(objectMapper);
+
+        final RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
+                .entryTtl(Duration.ofMinutes(30L))
+                .disableCachingNullValues()
+                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));
+
+        return RedisCacheManager.RedisCacheManagerBuilder
+                .fromConnectionFactory(redisConnectionFactory)
+                .cacheDefaults(redisCacheConfiguration)
+                .build();
+    }
 }

backend/kirikiri/src/main/java/co/kirikiri/persistence/auth/RefreshTokenRepository.java

@@ -1,35 +1,10 @@
 package co.kirikiri.persistence.auth;
 
 import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.stereotype.Repository;
 
-@Repository
-public class RefreshTokenRepository {
+public interface RefreshTokenRepository {
 
-    private final RedisTemplate<String, String> redisTemplate;
-    private final Long refreshTokenValidityInSeconds;
+    void save(final String refreshToken, final String memberIdentifier);
 
-    public RefreshTokenRepository(final RedisTemplate<String, String> redisTemplate,
-                                  @Value("${jwt.refresh-token-validity-in-seconds}") final Long refreshTokenValidityInSeconds) {
-        this.redisTemplate = redisTemplate;
-        this.refreshTokenValidityInSeconds = refreshTokenValidityInSeconds;
-    }
-
-    public void save(final String refreshToken, final String memberIdentifier) {
-        final long timeToLiveSeconds = refreshTokenValidityInSeconds / 1000;
-
-        redisTemplate.opsForValue()
-                .set(refreshToken, memberIdentifier, timeToLiveSeconds, TimeUnit.SECONDS);
-    }
-
-    public Optional<String> findMemberIdentifierByRefreshToken(final String refreshToken) {
-        final String memberIdentifier = redisTemplate.opsForValue().get(refreshToken);
-        if (memberIdentifier == null) {
-            return Optional.empty();
-        }
-        return Optional.of(memberIdentifier);
-    }
+    Optional<String> findMemberIdentifierByRefreshToken(final String refreshToken);
 }

backend/kirikiri/src/main/java/co/kirikiri/persistence/auth/RefreshTokenRepositoryImpl.java

@@ -0,0 +1,37 @@
+package co.kirikiri.persistence.auth;
+
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class RefreshTokenRepositoryImpl implements RefreshTokenRepository {
+
+    private final RedisTemplate<String, String> redisTemplate;
+    private final Long refreshTokenValidityInSeconds;
+
+    public RefreshTokenRepositoryImpl(final RedisTemplate<String, String> redisTemplate,
+                                      @Value("${jwt.refresh-token-validity-in-seconds}") final Long refreshTokenValidityInSeconds) {
+        this.redisTemplate = redisTemplate;
+        this.refreshTokenValidityInSeconds = refreshTokenValidityInSeconds;
+    }
+
+    @Override
+    public void save(final String refreshToken, final String memberIdentifier) {
+        final long timeToLiveSeconds = refreshTokenValidityInSeconds / 1000;
+
+        redisTemplate.opsForValue()
+                .set(refreshToken, memberIdentifier, timeToLiveSeconds, TimeUnit.SECONDS);
+    }
+
+    @Override
+    public Optional<String> findMemberIdentifierByRefreshToken(final String refreshToken) {
+        final String memberIdentifier = redisTemplate.opsForValue().get(refreshToken);
+        if (memberIdentifier == null) {
+            return Optional.empty();
+        }
+        return Optional.of(memberIdentifier);
+    }
+}

backend/kirikiri/src/main/java/co/kirikiri/service/CacheKeyGenerator.java

@@ -0,0 +1,27 @@
+package co.kirikiri.service;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+import org.springframework.cache.interceptor.KeyGenerator;
+import org.springframework.stereotype.Component;
+
+@Component
+public class CacheKeyGenerator implements KeyGenerator {
+
+    private static final String DELIMITER = "_";
+
+    @Override
+    public Object generate(final Object target, final Method method, final Object... params) {
+        return String.format("%s-%s-%s",
+                target.getClass().getSimpleName(),
+                method.getName(),
+                arrayToDelimitedString(params));
+    }
+
+    private Object arrayToDelimitedString(final Object... params) {
+        return Arrays.stream(params)
+                .map(o -> o == null ? "" : String.valueOf(o.hashCode()))
+                .collect(Collectors.joining(DELIMITER));
+    }
+}

backend/kirikiri/src/main/java/co/kirikiri/service/roadmap/RoadmapCreateService.java

@@ -38,6 +38,7 @@
 import co.kirikiri.service.mapper.RoadmapMapper;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -56,6 +57,7 @@ public class RoadmapCreateService {
     private final RoadmapCategoryRepository roadmapCategoryRepository;
     private final ApplicationEventPublisher applicationEventPublisher;
 
+    @CacheEvict(value = "roadmapList", allEntries = true)
     public Long create(final RoadmapSaveRequest request, final String identifier) {
         final Member member = findMemberByIdentifier(identifier);
         final RoadmapCategory roadmapCategory = findRoadmapCategoryById(request.categoryId());
@@ -156,6 +158,7 @@ private void validateReviewCount(final Roadmap roadmap, final Member member) {
         }
     }
 
+    @CacheEvict(value = {"roadmapList", "roadmap"}, allEntries = true)
     public void deleteRoadmap(final String identifier, final Long roadmapId) {
         final Roadmap roadmap = findRoadmapById(roadmapId);
         validateRoadmapCreator(roadmapId, identifier);
@@ -172,6 +175,7 @@ private void validateRoadmapCreator(final Long roadmapId, final String identifie
                 .orElseThrow(() -> new ForbiddenException("해당 로드맵을 생성한 사용자가 아닙니다."));
     }
 
+    @CacheEvict(value = "categoryList", allEntries = true)
     public void createRoadmapCategory(final RoadmapCategorySaveRequest roadmapCategorySaveRequest) {
         final RoadmapCategory roadmapCategory = RoadmapMapper.convertToRoadmapCategory(roadmapCategorySaveRequest);
         roadmapCategoryRepository.findByName(roadmapCategory.getName())

backend/kirikiri/src/main/java/co/kirikiri/service/roadmap/RoadmapReadService.java

@@ -50,6 +50,7 @@
 import java.net.URL;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.http.HttpMethod;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -68,6 +69,7 @@ public class RoadmapReadService {
     private final MemberRepository memberRepository;
     private final FileService fileService;
 
+    @Cacheable(value = "roadmap", keyGenerator = "cacheKeyGenerator", cacheManager = "redisCacheManager")
     public RoadmapResponse findRoadmap(final Long id) {
         final Roadmap roadmap = findRoadmapById(id);
         final RoadmapContent recentRoadmapContent = findRecentContent(roadmap);
@@ -128,6 +130,7 @@ private RoadmapContent findRecentContent(final Roadmap roadmap) {
                 .orElseThrow(() -> new NotFoundException("로드맵에 컨텐츠가 존재하지 않습니다."));
     }
 
+    @Cacheable(value = "roadmapList", keyGenerator = "cacheKeyGenerator", cacheManager = "redisCacheManager")
     public RoadmapForListResponses findRoadmapsByOrderType(final Long categoryId,
                                                            final RoadmapOrderTypeRequest orderTypeRequest,
                                                            final CustomScrollRequest scrollRequest) {
@@ -148,7 +151,7 @@ private RoadmapCategory findCategoryById(final Long categoryId) {
                 .orElseThrow(() -> new NotFoundException("존재하지 않는 카테고리입니다. categoryId = " + categoryId));
     }
 
-    public RoadmapForListScrollDto makeRoadmapForListScrollDto(final List<Roadmap> roadmaps, final int requestSize) {
+    private RoadmapForListScrollDto makeRoadmapForListScrollDto(final List<Roadmap> roadmaps, final int requestSize) {
         final List<RoadmapForListDto> roadmapForListDtos = roadmaps.stream()
                 .map(this::makeRoadmapForListDto)
                 .toList();
@@ -200,6 +203,7 @@ public RoadmapForListResponses search(final RoadmapOrderTypeRequest orderTypeReq
         return RoadmapMapper.convertRoadmapResponses(roadmapForListScrollDto);
     }
 
+    @Cacheable(value = "categoryList", keyGenerator = "cacheKeyGenerator", cacheManager = "redisCacheManager")
     public List<RoadmapCategoryResponse> findAllRoadmapCategories() {
         final List<RoadmapCategory> roadmapCategories = roadmapCategoryRepository.findAll();
         return RoadmapMapper.convertRoadmapCategoryResponses(roadmapCategories);

backend/kirikiri/src/test/java/co/kirikiri/integration/helper/IntegrationTest.java

@@ -1,6 +1,5 @@
 package co.kirikiri.integration.helper;
 
-import co.kirikiri.persistence.helper.RedisTestContainer;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -18,7 +17,7 @@
 @ActiveProfiles("test")
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
 @TestConstructor(autowireMode = AutowireMode.ALL)
-@Import({TestConfig.class, RedisTestContainer.class})
+@Import(TestConfig.class)
 public class IntegrationTest {
 
     @LocalServerPort

backend/kirikiri/src/test/java/co/kirikiri/integration/helper/TestConfig.java

@@ -1,5 +1,6 @@
 package co.kirikiri.integration.helper;
 
+import co.kirikiri.persistence.auth.RefreshTokenRepository;
 import co.kirikiri.persistence.goalroom.GoalRoomMemberRepository;
 import co.kirikiri.persistence.goalroom.GoalRoomRepository;
 import co.kirikiri.service.FileService;
@@ -27,4 +28,9 @@ public FileService fileService() {
     public TestTransactionService testTransactionService() {
         return new TestTransactionService(goalRoomRepository, goalRoomMemberRepository);
     }
+
+    @Bean
+    public RefreshTokenRepository refreshTokenRepository() {
+        return new TestRefreshTokenRepository();
+    }
 }

backend/kirikiri/src/test/java/co/kirikiri/integration/helper/TestRefreshTokenRepository.java

@@ -0,0 +1,18 @@
+package co.kirikiri.integration.helper;
+
+import static co.kirikiri.integration.fixture.MemberAPIFixture.DEFAULT_IDENTIFIER;
+
+import co.kirikiri.persistence.auth.RefreshTokenRepository;
+import java.util.Optional;
+
+public class TestRefreshTokenRepository implements RefreshTokenRepository {
+
+    @Override
+    public void save(final String refreshToken, final String memberIdentifier) {
+    }
+
+    @Override
+    public Optional<String> findMemberIdentifierByRefreshToken(final String refreshToken) {
+        return Optional.of(DEFAULT_IDENTIFIER);
+    }
+}

backend/kirikiri/src/test/java/co/kirikiri/persistence/auth/RefreshTokenRepositoryTest.java

@@ -2,6 +2,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.when;
 
 import co.kirikiri.domain.member.EncryptedPassword;
 import co.kirikiri.domain.member.Gender;
@@ -10,23 +11,39 @@
 import co.kirikiri.domain.member.vo.Identifier;
 import co.kirikiri.domain.member.vo.Nickname;
 import co.kirikiri.domain.member.vo.Password;
-import co.kirikiri.persistence.helper.RedisTest;
 import java.util.Optional;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ValueOperations;
 
-class RefreshTokenRepositoryTest extends RedisTest {
+@ExtendWith(MockitoExtension.class)
+class RefreshTokenRepositoryTest {
+
+    private static final Long refreshTokenValidityInSeconds = 3600000L;
 
     private static Member member;
 
-    private RefreshTokenRepository refreshTokenRepository;
+    @Mock
+    private RedisTemplate<String, String> redisTemplate;
+
+    @Mock
+    private ValueOperations<String, String> valueOperations;
+
+    private RefreshTokenRepositoryImpl refreshTokenRepository;
 
     @BeforeEach
     void init() {
-        refreshTokenRepository = new RefreshTokenRepository(redisTemplate, 2000L);
+        when(redisTemplate.opsForValue())
+                .thenReturn(valueOperations);
+        refreshTokenRepository = new RefreshTokenRepositoryImpl(redisTemplate, refreshTokenValidityInSeconds);
     }
 
+
     @BeforeAll
     static void setUp() {
         final Identifier identifier = new Identifier("identifier1");
@@ -55,7 +72,8 @@ static void setUp() {
         final String refreshToken = "refreshToken";
         final String memberIdentifier = member.getIdentifier().getValue();
 
-        refreshTokenRepository.save(refreshToken, memberIdentifier);
+        when(valueOperations.get(refreshToken))
+                .thenReturn(memberIdentifier);
 
         //when
         final String findMemberIdentifier = refreshTokenRepository.findMemberIdentifierByRefreshToken(refreshToken)