[BE] 약속 조회와 약속 추천 서버 캐시 추가 :)

backend/build.gradle

@@ -38,6 +38,9 @@ dependencies {
     implementation 'org.springframework.security:spring-security-crypto'
     implementation 'org.bouncycastle:bcprov-jdk18on:1.78.1'
 
+    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
+    implementation 'com.github.codemonstur:embedded-redis:1.4.3'
+
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
 
@@ -46,6 +49,9 @@ dependencies {
 
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'io.rest-assured:rest-assured'
+    testImplementation 'org.testcontainers:junit-jupiter:1.20.4'
+    testImplementation 'org.testcontainers:testcontainers:1.20.4'
+    testImplementation 'com.redis.testcontainers:testcontainers-redis:1.6.4'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }
 

backend/src/main/java/kr/momo/config/EmbeddedRedisConfig.java

@@ -0,0 +1,32 @@
+package kr.momo.config;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
+import java.io.IOException;
+import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import redis.embedded.RedisServer;
+
+@Configuration
+@Profile("local")
+public class EmbeddedRedisConfig {
+
+    private final RedisServer redisServer;
+
+    public EmbeddedRedisConfig(RedisProperties redisProperties) throws IOException {
+        this.redisServer = new RedisServer(redisProperties.getPort());
+    }
+
+    @PostConstruct
+    public void start() throws IOException {
+        redisServer.start();
+    }
+
+    @PreDestroy
+    public void stop() throws IOException {
+        if (redisServer.isActive()) {
+            redisServer.stop();
+        }
+    }
+}

backend/src/main/java/kr/momo/config/RedisConfig.java

@@ -0,0 +1,32 @@
+package kr.momo.config;
+
+import java.time.Duration;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+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.serializer.RedisSerializationContext.SerializationPair;
+import org.springframework.data.redis.serializer.RedisSerializer;
+
+@EnableCaching
+@Configuration
+public class RedisConfig {
+
+    @Bean
+    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
+        RedisCacheConfiguration cacheConfiguration = getCacheConfiguration();
+        return RedisCacheManager.builder(connectionFactory)
+                .cacheDefaults(cacheConfiguration)
+                .build();
+    }
+
+    private RedisCacheConfiguration getCacheConfiguration() {
+        return RedisCacheConfiguration.defaultCacheConfig()
+                .serializeKeysWith(SerializationPair.fromSerializer(RedisSerializer.string()))
+                .serializeValuesWith(SerializationPair.fromSerializer(RedisSerializer.json()))
+                .entryTtl(Duration.ofMinutes(10))
+                .enableTimeToIdle();
+    }
+}

backend/src/main/java/kr/momo/config/constant/CacheType.java

@@ -0,0 +1,14 @@
+package kr.momo.config.constant;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum CacheType {
+
+    SCHEDULES_STORE("schedules-store"),
+    RECOMMEND_STORE("recommend-store");
+
+    private final String name;
+}

backend/src/main/java/kr/momo/exception/code/CacheErrorCode.java

@@ -0,0 +1,33 @@
+package kr.momo.exception.code;
+
+import org.springframework.http.HttpStatus;
+
+public enum CacheErrorCode implements ErrorCodeType {
+
+    CACHE_NOT_FOUND(HttpStatus.INTERNAL_SERVER_ERROR, "데이터 처리 중 오류가 발생했습니다. 잠시 후 다시 시도해 주세요."),
+    CACHE_JSON_PROCESSING_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "데이터 처리 중 오류가 발생했습니다. 잠시 후 다시 시도해 주세요."),
+    DATA_DESERIALIZATION_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "데이터 변환 중 오류가 발생했습니다. 잠시 후 다시 시도해 주세요.");
+
+    private final HttpStatus httpStatus;
+    private final String message;
+
+    CacheErrorCode(HttpStatus httpStatus, String message) {
+        this.httpStatus = httpStatus;
+        this.message = message;
+    }
+
+    @Override
+    public HttpStatus httpStatus() {
+        return httpStatus;
+    }
+
+    @Override
+    public String message() {
+        return message;
+    }
+
+    @Override
+    public String errorCode() {
+        return name();
+    }
+}

backend/src/main/java/kr/momo/service/schedule/ScheduleCache.java

@@ -0,0 +1,80 @@
+package kr.momo.service.schedule;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import kr.momo.config.constant.CacheType;
+import kr.momo.exception.MomoException;
+import kr.momo.exception.code.CacheErrorCode;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ScheduleCache {
+
+    public static final String INVALID_STATUS = "invalid";
+
+    private final ObjectMapper objectMapper;
+    private final CacheManager cacheManager;
+
+    public boolean isHit(CacheType cacheType, String key) {
+        Cache cache = cacheManager.getCache(cacheType.getName());
+        if (cache == null) {
+            return false;
+        }
+        String json = cache.get(key, String.class);
+        return json != null && !INVALID_STATUS.equals(json);
+    }
+
+    public <T> T get(CacheType cacheType, String key, Class<T> clazz) {
+        String cacheName = cacheType.getName();
+        Cache cache = cacheManager.getCache(cacheName);
+        validateCacheNotNull(key, cache);
+        String value = cache.get(key, String.class);
+        log.debug("CACHE NAME: {}, KEY: {}, STATE: HIT", cacheName, key);
+        return convertObject(cacheName, key, clazz, value);
+    }
+
+    private void validateCacheNotNull(String key, Cache cache) {
+        if (cache == null || cache.get(key, String.class) == null) {
+            throw new MomoException(CacheErrorCode.CACHE_NOT_FOUND);
+        }
+    }
+
+    private <T> T convertObject(String cacheName, String key, Class<T> clazz, String value) {
+        try {
+            return objectMapper.readValue(value, clazz);
+        } catch (JsonProcessingException e) {
+            log.error("캐시 값을 JSON으로 변환하는데 실패했습니다. CACHE NAME: {}, KEY: {}", cacheName, key);
+            throw new MomoException(CacheErrorCode.CACHE_JSON_PROCESSING_ERROR);
+        }
+    }
+
+    public <T> void put(CacheType cacheType, String key, T value) {
+        String cacheName = cacheType.getName();
+        Cache cache = cacheManager.getCache(cacheName);
+        if (cache == null) {
+            log.error("캐싱에 해당하는 이름이 존재하지 않습니다. 캐싱 이름: {}", cacheName);
+            return;
+        }
+        log.debug("CACHE NAME: {}, KEY: {}, STATE: MISS", cacheName, key);
+        cache.put(key, convertToJson(cacheName, key, value));
+    }
+
+    private <T> String convertToJson(String cacheName, String key, T value) {
+        try {
+            return objectMapper.writeValueAsString(value);
+        } catch (JsonProcessingException e) {
+            log.error("캐시 값을 객체로 변환하는데 실패했습니다. CACHE NAME: {}, KEY: {}", cacheName, key);
+            throw new MomoException(CacheErrorCode.DATA_DESERIALIZATION_ERROR);
+        }
+    }
+
+    public void putInvalid(CacheType cacheType, String key) {
+        put(cacheType, key, INVALID_STATUS);
+    }
+}

backend/src/main/java/kr/momo/service/schedule/ScheduleService.java

@@ -1,8 +1,10 @@
 package kr.momo.service.schedule;
 
 import java.time.LocalTime;
+import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Stream;
+import kr.momo.config.constant.CacheType;
 import kr.momo.domain.attendee.Attendee;
 import kr.momo.domain.attendee.AttendeeGroup;
 import kr.momo.domain.attendee.AttendeeName;
@@ -16,6 +18,7 @@
 import kr.momo.domain.schedule.ScheduleBatchRepository;
 import kr.momo.domain.schedule.ScheduleRepository;
 import kr.momo.domain.schedule.recommend.CandidateSchedule;
+import kr.momo.domain.schedule.recommend.RecommendedScheduleSortStandard;
 import kr.momo.domain.timeslot.Timeslot;
 import kr.momo.exception.MomoException;
 import kr.momo.exception.code.AttendeeErrorCode;
@@ -43,6 +46,7 @@ public class ScheduleService {
     private final AvailableDateRepository availableDateRepository;
     private final ScheduleBatchRepository scheduleBatchRepository;
     private final ScheduleRecommenderFactory scheduleRecommenderFactory;
+    private final ScheduleCache scheduleCache;
 
     @Transactional
     public void create(String uuid, long attendeeId, ScheduleCreateRequest request) {
@@ -56,6 +60,10 @@ public void create(String uuid, long attendeeId, ScheduleCreateRequest request)
         scheduleRepository.deleteByAttendee(attendee);
         List<Schedule> schedules = createSchedules(request, meeting, attendee);
         scheduleBatchRepository.batchInsert(schedules);
+        scheduleCache.putInvalid(CacheType.SCHEDULES_STORE, uuid);
+        Arrays.stream(RecommendedScheduleSortStandard.values())
+                .map(RecommendedScheduleSortStandard::getType)
+                .forEach(type -> scheduleCache.putInvalid(CacheType.RECOMMEND_STORE, type + uuid));
     }
 
     private void validateMeetingUnLocked(Meeting meeting) {
@@ -89,12 +97,19 @@ private Schedule createSchedule(Meeting meeting, Attendee attendee, AvailableDat
 
     @Transactional(readOnly = true)
     public SchedulesResponse findAllSchedules(String uuid) {
+        if (scheduleCache.isHit(CacheType.SCHEDULES_STORE, uuid)) {
+            return scheduleCache.get(CacheType.SCHEDULES_STORE, uuid, SchedulesResponse.class);
+        }
+
         Meeting meeting = meetingRepository.findByUuid(uuid)
                 .orElseThrow(() -> new MomoException(MeetingErrorCode.NOT_FOUND_MEETING));
         List<Attendee> attendees = attendeeRepository.findAllByMeeting(meeting);
         List<Schedule> schedules = scheduleRepository.findAllByAttendeeIn(attendees);
+        SchedulesResponse schedulesResponse = SchedulesResponse.from(schedules);
 
-        return SchedulesResponse.from(schedules);
+        scheduleCache.put(CacheType.SCHEDULES_STORE, uuid, schedulesResponse);
+
+        return schedulesResponse;
     }
 
     @Transactional(readOnly = true)
@@ -125,6 +140,10 @@ public AttendeeScheduleResponse findMySchedule(String uuid, long attendeeId) {
     public RecommendedSchedulesResponse recommendSchedules(
             String uuid, String recommendType, List<String> names, int minimumTime
     ) {
+        String key = recommendType + uuid;
+        if (scheduleCache.isHit(CacheType.RECOMMEND_STORE, key)) {
+            return scheduleCache.get(CacheType.RECOMMEND_STORE, key, RecommendedSchedulesResponse.class);
+        }
         Meeting meeting = meetingRepository.findByUuid(uuid)
                 .orElseThrow(() -> new MomoException(MeetingErrorCode.NOT_FOUND_MEETING));
         AttendeeGroup attendeeGroup = new AttendeeGroup(attendeeRepository.findAllByMeeting(meeting));
@@ -140,6 +159,12 @@ public RecommendedSchedulesResponse recommendSchedules(
         List<RecommendedScheduleResponse> scheduleResponses = RecommendedScheduleResponse.fromCandidateSchedules(
                 recommendedResult
         );
-        return RecommendedSchedulesResponse.of(meeting.getType(), scheduleResponses);
+        RecommendedSchedulesResponse recommendedSchedulesResponse = RecommendedSchedulesResponse.of(
+                meeting.getType(), scheduleResponses
+        );
+
+        scheduleCache.put(CacheType.RECOMMEND_STORE, key, recommendedSchedulesResponse);
+
+        return recommendedSchedulesResponse;
     }
 }

backend/src/main/resources/application-dev.yml

@@ -7,6 +7,7 @@ spring:
       - ${SECURITY_PATH:classpath:security}/cors.yml
       - ${SECURITY_PATH:classpath:security}/logback.yml
       - ${SECURITY_PATH:classpath:security}/actuator.yml
+      - ${SECURITY_PATH:classpath:security}/cache-dev.yml
 
   jpa:
     hibernate:

backend/src/main/resources/application-local.yml

@@ -3,7 +3,6 @@ spring:
     activate.on-profile: local
     import:
       - classpath:datasource.yml
-
   jpa:
     hibernate:
       ddl-auto: create
@@ -19,6 +18,13 @@ spring:
       path: /h2-console
       settings:
         web-allow-others: true
+  cache:
+    type: redis
+  data:
+    redis:
+      host: localhost
+      port: ${REDIS_PORT:6379}
+      timeout: 2000
 
 security:
   jwt:

backend/src/main/resources/application-prod.yml

@@ -7,6 +7,7 @@ spring:
       - ${SECURITY_PATH:classpath:security}/cors.yml
       - ${SECURITY_PATH:classpath:security}/logback.yml
       - ${SECURITY_PATH:classpath:security}/actuator.yml
+      - ${SECURITY_PATH:classpath:security}/cache-prod.yml
 
   jpa:
     hibernate:

backend/src/test/java/kr/momo/controller/schedule/ScheduleControllerTest.java

@@ -8,6 +8,8 @@
 import java.time.LocalTime;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
+import kr.momo.support.TestContainers;
 import kr.momo.domain.attendee.Attendee;
 import kr.momo.domain.attendee.AttendeeRepository;
 import kr.momo.domain.availabledate.AvailableDate;
@@ -30,12 +32,14 @@
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
 import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
 import org.springframework.http.HttpStatus;
 import org.springframework.security.crypto.password.PasswordEncoder;
 
 @IsolateDatabase
 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
-class ScheduleControllerTest {
+class ScheduleControllerTest extends TestContainers {
 
     @LocalServerPort
     private int port;
@@ -55,6 +59,9 @@ class ScheduleControllerTest {
     @Autowired
     private PasswordEncoder passwordEncoder;
 
+    @Autowired
+    private CacheManager cacheManager;
+
     private Meeting meeting;
     private AttendeeFixture fixture;
     private Attendee attendee;
@@ -69,6 +76,11 @@ void setUp() {
         attendee = attendeeRepository.save(fixture.create(meeting));
         today = availableDateRepository.save(new AvailableDate(LocalDate.now(), meeting));
         tomorrow = availableDateRepository.save(new AvailableDate(LocalDate.now().plusDays(1), meeting));
+
+        for (String name : cacheManager.getCacheNames()) {
+            Cache cache = cacheManager.getCache(name);
+            Objects.requireNonNull(cache).clear();
+        }
     }
 
     @DisplayName("참가자가 스케줄을 생성하는데 성공하면 200 상태 코드를 응답한다.")

backend/src/test/java/kr/momo/service/meeting/MeetingServiceTest.java

@@ -25,8 +25,8 @@
 import kr.momo.exception.code.MeetingErrorCode;
 import kr.momo.fixture.AttendeeFixture;
 import kr.momo.fixture.MeetingFixture;
-import kr.momo.service.meeting.dto.MeetingHomeResponse;
 import kr.momo.service.meeting.dto.MeetingCreateRequest;
+import kr.momo.service.meeting.dto.MeetingHomeResponse;
 import kr.momo.service.meeting.dto.MeetingResponse;
 import kr.momo.service.meeting.dto.MeetingSharingResponse;
 import kr.momo.support.IsolateDatabase;