MOSU-267 refactor: 도메인 캐싱 적용

src/main/java/life/mosu/mosuserver/application/caffeine/LocalCacheConfig.java

@@ -0,0 +1,42 @@
+package life.mosu.mosuserver.application.caffeine;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import life.mosu.mosuserver.domain.caffeine.CacheGroup;
+import life.mosu.mosuserver.domain.caffeine.CacheType;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.caffeine.CaffeineCache;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+@EnableCaching
+@Configuration
+public class LocalCacheConfig {
+
+    @Bean
+    public LocalCacheManager localCacheManager() {
+        List<Cache> caches = Arrays.stream(CacheGroup.values())
+                .filter(g -> g.getCacheType() == CacheType.LOCAL
+                        || g.getCacheType() == CacheType.COMPOSITE)
+                .map(g -> new CaffeineCache(
+                        g.getCacheName(),
+                        Caffeine.newBuilder()
+                                .recordStats()
+                                .expireAfterWrite(g.getExpiredAfterWrite())
+                                .build()
+                )).collect(Collectors.toList());
+
+        return new LocalCacheManager(caches);
+    }
+
+    @Bean
+    @Primary
+    public CacheManager appCacheManager(LocalCacheManager localCacheManager) {
+        return localCacheManager;
+    }
+}

src/main/java/life/mosu/mosuserver/application/caffeine/LocalCacheManager.java

@@ -0,0 +1,59 @@
+package life.mosu.mosuserver.application.caffeine;
+
+import jakarta.annotation.Nullable;
+import jakarta.annotation.PostConstruct;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+
+public class LocalCacheManager implements CacheManager, UpdatableCacheManager {
+
+    private final List<Cache> caches;
+    private Map<String, Cache> cacheMap = new ConcurrentHashMap<>();
+    private volatile Set<String> cacheNames = Collections.emptySet();
+
+    public LocalCacheManager(List<Cache> caches) {
+        this.caches = (caches != null) ? caches : Collections.emptyList();
+    }
+
+    @PostConstruct
+    public void init() {
+        Set<String> cacheNamesSet = new LinkedHashSet<>(caches.size());
+        Map<String, Cache> cacheMapTemp = new ConcurrentHashMap<>(16);
+
+        for (Cache cache : caches) {
+            String name = cache.getName();
+            cacheNamesSet.add(name);
+            cacheMapTemp.put(name, cache);
+        }
+        this.cacheMap = cacheMapTemp;
+        this.cacheNames = cacheNamesSet;
+    }
+
+    @Override
+    @Nullable
+    public Cache getCache(String name) {
+        return cacheMap.get(name);
+    }
+
+    @Override
+    public Collection<String> getCacheNames() {
+        return cacheNames;
+    }
+
+    @Override
+    public void putIfAbsent(Cache cache, String key, Object value) {
+        Cache localCache = getCache(cache.getName());
+        if (localCache != null) {
+            localCache.putIfAbsent(key, value);
+        }
+    }
+
+
+}

src/main/java/life/mosu/mosuserver/application/caffeine/UpdatableCacheManager.java

@@ -0,0 +1,8 @@
+package life.mosu.mosuserver.application.caffeine;
+
+import org.springframework.cache.Cache;
+
+public interface UpdatableCacheManager {
+
+    void putIfAbsent(Cache cache, String key, Object value);
+}

src/main/java/life/mosu/mosuserver/application/inquiry/InquiryService.java

@@ -3,10 +3,8 @@
 import life.mosu.mosuserver.domain.inquiry.entity.InquiryJpaEntity;
 import life.mosu.mosuserver.domain.inquiry.entity.InquiryStatus;
 import life.mosu.mosuserver.domain.inquiry.repository.InquiryJpaRepository;
-import life.mosu.mosuserver.domain.inquiryAnswer.repository.InquiryAnswerJpaRepository;
 import life.mosu.mosuserver.domain.user.entity.UserJpaEntity;
 import life.mosu.mosuserver.domain.user.entity.UserRole;
-import life.mosu.mosuserver.domain.user.repository.UserJpaRepository;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryCreateRequest;
@@ -26,11 +24,9 @@
 @RequiredArgsConstructor
 public class InquiryService {
 
-    private final UserJpaRepository userJpaRepository;
     private final InquiryAttachmentService inquiryAttachmentService;
     private final InquiryJpaRepository inquiryJpaRepository;
     private final InquiryAnswerService inquiryAnswerService;
-    private final InquiryAnswerJpaRepository inquiryAnswerJpaRepository;
 
     @Transactional
     public void createInquiry(UserJpaEntity user, InquiryCreateRequest request) {

src/main/java/life/mosu/mosuserver/application/notice/NoticeService.java

@@ -12,6 +12,8 @@
 import life.mosu.mosuserver.presentation.notice.dto.NoticeUpdateRequest;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
@@ -28,12 +30,15 @@ public class NoticeService {
     private final NoticeJpaRepository noticeJpaRepository;
     private final NoticeAttachmentService attachmentService;
 
+    @CacheEvict(cacheNames = "notice", allEntries = true)
     @Transactional
     public void createNotice(NoticeCreateRequest request, UserJpaEntity user) {
         NoticeJpaEntity noticeEntity = noticeJpaRepository.save(request.toEntity(user));
         attachmentService.createAttachment(request.attachments(), noticeEntity);
     }
 
+    @Cacheable(cacheNames = "notice",
+            key = "'page=' + #page + ',size=' + #size")
     @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
     public List<NoticeResponse> getNotices(int page, int size) {
         Pageable pageable = PageRequest.of(page, size, Sort.by("id"));
@@ -44,19 +49,22 @@ public List<NoticeResponse> getNotices(int page, int size) {
                 .toList();
     }
 
+    @Cacheable(cacheNames = "notice", key = "#noticeId")
     @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
     public NoticeDetailResponse getNoticeDetail(Long noticeId) {
         NoticeJpaEntity notice = getNotice(noticeId);
 
         return toNoticeDetailResponse(notice);
     }
 
+    @CacheEvict(cacheNames = "notice", allEntries = true)
     @Transactional
     public void deleteNotice(Long noticeId) {
         NoticeJpaEntity noticeEntity = getNotice(noticeId);
         noticeJpaRepository.delete(noticeEntity);
     }
 
+    @CacheEvict(cacheNames = "notice", allEntries = true)
     @Transactional
     public void updateNotice(Long noticeId, NoticeUpdateRequest request, UserJpaEntity user) {
         NoticeJpaEntity noticeEntity = getNotice(noticeId);

src/main/java/life/mosu/mosuserver/domain/caffeine/CacheGroup.java

@@ -0,0 +1,33 @@
+package life.mosu.mosuserver.domain.caffeine;
+
+import java.time.Duration;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum CacheGroup {
+
+    NOTICE(
+            "notice",
+            Duration.ofMinutes(10),
+            CacheType.LOCAL
+    ),
+
+    INQUIRY(
+            "inquiry",
+            Duration.ofMinutes(10),
+            CacheType.GLOBAL
+    ),
+
+    COMPOSITE_ALL(
+            "composite",
+            Duration.ofMinutes(10),
+            CacheType.COMPOSITE
+    );
+
+
+    private final String cacheName;
+    private final Duration expiredAfterWrite;
+    private final CacheType cacheType;
+}

src/main/java/life/mosu/mosuserver/domain/caffeine/CacheType.java

@@ -0,0 +1,13 @@
+package life.mosu.mosuserver.domain.caffeine;
+
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+public enum CacheType {
+    LOCAL("로컬 타입만 적용"),
+    GLOBAL("분산 캐시만 적용"),
+    COMPOSITE("로컬 + 분산 캐시 모두 적용");
+
+    private final String type;
+
+}

src/main/java/life/mosu/mosuserver/global/config/CaffeineCacheConfig.java → src/main/java/life/mosu/mosuserver/global/config/CaffeineFilterCacheConfig.java

@@ -12,7 +12,7 @@
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
-public class CaffeineCacheConfig {
+public class CaffeineFilterCacheConfig {
 
     @Bean
     public Cache<String, RequestCounter> ipRequestCountsCache(IpRateLimitingProperties properties) {