[volume-5] 인덱스와 캐시를 사용한 성능 최적화

apps/commerce-api/build.gradle.kts

@@ -8,6 +8,7 @@ dependencies {
 
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.springframework.boot:spring-boot-starter-aop")
     implementation("org.springframework.security:spring-security-crypto")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")

apps/commerce-api/src/main/java/com/loopers/application/brand/BrandApplicationService.java

@@ -2,28 +2,33 @@
 
 import com.loopers.application.brand.command.CreateBrandCommand;
 import com.loopers.application.brand.command.UpdateBrandCommand;
+import com.loopers.application.brand.BrandCacheRepository;
 import com.loopers.domain.brand.Brand;
 import com.loopers.domain.brand.BrandRepository;
+import com.loopers.infrastructure.brand.redis.BrandCacheSyncer;
 import com.loopers.domain.brand.vo.BrandName;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Collection;
+import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 import java.util.UUID;
 
 @Service
 @RequiredArgsConstructor
 public class BrandApplicationService {
 
     private final BrandRepository brandRepository;
+    private final BrandCacheRepository brandCacheRepository;
+    private final BrandCacheSyncer brandCacheSyncer;
 
     @Transactional
     public Brand create(CreateBrandCommand command) {
@@ -36,33 +41,34 @@ public Brand create(CreateBrandCommand command) {
         Brand brand = new Brand(brandName, command.description(), command.imageUrl());
 
         try {
-            return brandRepository.save(brand);
+            Brand saved = brandRepository.save(brand);
+            brandCacheSyncer.registerUpsert(saved);
+            return saved;
         } catch (DataIntegrityViolationException e) {
             throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 브랜드 이름입니다.");
         }
     }
 
     @Transactional(readOnly = true)
     public Brand findById(UUID id) {
-        return brandRepository.findById(id)
+        return brandCacheRepository.findById(id)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "브랜드를 찾을 수 없습니다."));
     }
 
     @Transactional(readOnly = true)
     public Page<Brand> list(Pageable pageable) {
-        return brandRepository.findAll(pageable);
+        List<Brand> brands = brandCacheRepository.findAll();
+        if (pageable.isUnpaged()) {
+            return new PageImpl<>(brands, pageable, brands.size());
+        }
+        int start = Math.min((int) pageable.getOffset(), brands.size());
+        int end = Math.min(start + pageable.getPageSize(), brands.size());
+        return new PageImpl<>(brands.subList(start, end), pageable, brands.size());
     }
 
     @Transactional(readOnly = true)
     public Map<UUID, String> findNamesByIds(Collection<UUID> brandIds) {
-        return brandIds.stream()
-                .distinct()
-                .collect(Collectors.toMap(
-                        brandId -> brandId,
-                        brandId -> brandRepository.findById(brandId)
-                                .map(brand -> brand.name().value())
-                                .orElse(null)
-                ));
+        return brandCacheRepository.findNamesByIds(brandIds);
     }
 
     @Transactional
@@ -71,13 +77,16 @@ public Brand update(UUID id, UpdateBrandCommand command) {
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "브랜드를 찾을 수 없습니다."));
 
         Brand updated = brand.update(command.description(), command.imageUrl());
-        return brandRepository.save(updated);
+        Brand saved = brandRepository.save(updated);
+        brandCacheSyncer.registerUpsert(saved);
+        return saved;
     }
 
     @Transactional
     public void delete(UUID id) {
         Brand brand = brandRepository.findById(id)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "브랜드를 찾을 수 없습니다."));
         brandRepository.delete(brand);
+        brandCacheSyncer.registerDelete(id);
     }
 }

apps/commerce-api/src/main/java/com/loopers/application/brand/BrandCacheRepository.java

@@ -0,0 +1,23 @@
+package com.loopers.application.brand;
+
+import com.loopers.domain.brand.Brand;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+public interface BrandCacheRepository {
+    Optional<Brand> findById(UUID id);
+
+    List<Brand> findAll();
+
+    Map<UUID, String> findNamesByIds(Collection<UUID> brandIds);
+
+    boolean existsById(UUID id);
+
+    void save(Brand brand);
+
+    void delete(UUID id);
+}

apps/commerce-api/src/main/java/com/loopers/application/coupon/category/CategoryApplicationService.java

@@ -1,26 +1,35 @@
 package com.loopers.application.coupon.category;
 
+import com.loopers.application.coupon.category.CategoryCacheRepository;
 import com.loopers.domain.category.Category;
-import com.loopers.domain.category.CategoryRepository;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
+
+import java.util.List;
 import java.util.UUID;
 
 @Service
 @RequiredArgsConstructor
 public class CategoryApplicationService {
-    private final CategoryRepository categoryRepository;
+    private final CategoryCacheRepository categoryCacheRepository;
 
     public Category findById(UUID categoryId) {
-        return categoryRepository.findById(categoryId)
+        return categoryCacheRepository.findById(categoryId)
                 .orElseThrow(() -> new CoreException(ErrorType.BAD_REQUEST, "카테고리를 찾을 수 없습니다."));
     }
 
     public Page<Category> list(Pageable pageable) {
-        return categoryRepository.findAll(pageable);
+        List<Category> categories = categoryCacheRepository.findAll();
+        if (pageable.isUnpaged()) {
+            return new PageImpl<>(categories, pageable, categories.size());
+        }
+        int start = Math.min((int) pageable.getOffset(), categories.size());
+        int end = Math.min(start + pageable.getPageSize(), categories.size());
+        return new PageImpl<>(categories.subList(start, end), pageable, categories.size());
     }
 }

apps/commerce-api/src/main/java/com/loopers/application/coupon/category/CategoryCacheRepository.java

@@ -0,0 +1,19 @@
+package com.loopers.application.coupon.category;
+
+import com.loopers.domain.category.Category;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+public interface CategoryCacheRepository {
+    Optional<Category> findById(UUID id);
+
+    List<Category> findAll();
+
+    boolean existsById(UUID id);
+
+    void save(Category category);
+
+    void delete(UUID id);
+}

apps/commerce-api/src/main/java/com/loopers/application/member/MemberAuthenticationService.java

@@ -4,13 +4,11 @@
 import com.loopers.domain.member.PasswordEncoder;
 import com.loopers.domain.member.Member;
 import com.loopers.domain.member.MemberRepository;
-import com.loopers.domain.member.vo.MemberId;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import java.util.UUID;
 
 @RequiredArgsConstructor
 @Service
@@ -30,14 +28,4 @@ public Member authenticate(AuthenticateCommand command) {
 
         return member;
     }
-
-    public UUID findDbIdByMemberId(MemberId memberId) {
-        return memberRepository.findDbIdByMemberId(memberId)
-                .orElseThrow(() -> new CoreException(ErrorType.UNAUTHORIZED, "회원을 찾을 수 없습니다."));
-    }
-
-    public UUID findDbIdByMember(Member member) {
-        return memberRepository.findDbIdByMemberId(member.id())
-                .orElseThrow(() -> new CoreException(ErrorType.UNAUTHORIZED, "회원을 찾을 수 없습니다."));
-    }
 }

apps/commerce-api/src/main/java/com/loopers/application/product/ProductApplicationService.java

@@ -1,17 +1,18 @@
 package com.loopers.application.product;
 
+import com.loopers.application.brand.BrandCacheRepository;
+import com.loopers.application.coupon.category.CategoryCacheRepository;
+import com.loopers.application.product.cache.EvictPublicProductDetailCache;
 import com.loopers.application.product.command.CreateProductCommand;
 import com.loopers.application.product.command.UpdateProductCommand;
-import com.loopers.domain.brand.BrandRepository;
-import com.loopers.domain.category.CategoryRepository;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.product.query.ProductCursorPage;
 import com.loopers.domain.product.query.ProductListCriteria;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -23,15 +24,15 @@
 public class ProductApplicationService {
 
     private final ProductRepository productRepository;
-    private final BrandRepository brandRepository;
-    private final CategoryRepository categoryRepository;
+    private final BrandCacheRepository brandCacheRepository;
+    private final CategoryCacheRepository categoryCacheRepository;
 
     @Transactional
     public Product create(CreateProductCommand command) {
-        if (brandRepository.findById(command.brandId()).isEmpty()) {
+        if (!brandCacheRepository.existsById(command.brandId())) {
             throw new CoreException(ErrorType.BAD_REQUEST, "존재하지 않거나 삭제된 브랜드입니다.");
         }
-        if (categoryRepository.findById(command.categoryId()).isEmpty()) {
+        if (!categoryCacheRepository.existsById(command.categoryId())) {
             throw new CoreException(ErrorType.BAD_REQUEST, "존재하지 않거나 삭제된 카테고리입니다.");
         }
 
@@ -53,13 +54,8 @@ public Product get(UUID productId) {
     }
 
     @Transactional(readOnly = true)
-    public Page<Product> list(UUID brandId, Pageable pageable) {
-        return productRepository.findAll(brandId, pageable);
-    }
-
-    @Transactional(readOnly = true)
-    public Page<Product> list(ProductListCriteria criteria) {
-        return productRepository.findAll(criteria.brandId(), criteria.toPageable());
+    public ProductCursorPage listByCursor(ProductListCriteria criteria) {
+        return productRepository.searchByCursor(criteria);
     }
 
     @Transactional(readOnly = true)
@@ -68,14 +64,9 @@ public Product getIncludingDeleted(UUID productId) {
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
     }
 
-    @Transactional(readOnly = true)
-    public Page<Product> listIncludingDeleted(UUID brandId, Pageable pageable) {
-        return productRepository.findAllIncludingDeleted(brandId, pageable);
-    }
-
     @Transactional(readOnly = true)
     public Page<Product> listIncludingDeleted(ProductListCriteria criteria) {
-        return productRepository.findAllIncludingDeleted(criteria.brandId(), criteria.toPageable());
+        return productRepository.findAllIncludingDeleted(criteria);
     }
 
     @Transactional(readOnly = true)
@@ -89,6 +80,7 @@ public void deleteSoftByBrandId(UUID brandId) {
     }
 
     @Transactional
+    @EvictPublicProductDetailCache
     public Product update(UUID productId, UpdateProductCommand command) {
         Product existing = productRepository.findById(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));
@@ -97,7 +89,7 @@ public Product update(UUID productId, UpdateProductCommand command) {
             throw new CoreException(ErrorType.BAD_REQUEST, "브랜드는 수정할 수 없습니다.");
         }
 
-        if (categoryRepository.findById(command.categoryId()).isEmpty()) {
+        if (!categoryCacheRepository.existsById(command.categoryId())) {
             throw new CoreException(ErrorType.BAD_REQUEST, "존재하지 않거나 삭제된 카테고리입니다.");
         }
 
@@ -116,6 +108,7 @@ public Product update(UUID productId, UpdateProductCommand command) {
     }
 
     @Transactional
+    @EvictPublicProductDetailCache
     public void deleteSoft(UUID productId) {
         Product existing = productRepository.findById(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));

apps/commerce-api/src/main/java/com/loopers/application/product/ProductLikeAplicationService.java

@@ -1,5 +1,6 @@
 package com.loopers.application.product;
 
+import com.loopers.application.product.cache.EvictPublicProductDetailCache;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.support.error.CoreException;
@@ -40,6 +41,7 @@ public void validateCancelable(UUID productId) {
     }
 
     @Transactional
+    @EvictPublicProductDetailCache
     public void increaseLikeCount(UUID productId) {
         int updatedCount = productRepository.updateLikeCount(productId, 1);
         if (updatedCount == 0) {
@@ -48,6 +50,7 @@ public void increaseLikeCount(UUID productId) {
     }
 
     @Transactional
+    @EvictPublicProductDetailCache
     public void decreaseLikeCount(UUID productId) {
         int updatedCount = productRepository.updateLikeCount(productId, -1);
         if (updatedCount == 0) {
@@ -56,6 +59,7 @@ public void decreaseLikeCount(UUID productId) {
     }
 
     @Transactional
+    @EvictPublicProductDetailCache
     public void decreaseLikeCountIfPresent(UUID productId) {
         productRepository.updateLikeCount(productId, -1);
     }

apps/commerce-api/src/main/java/com/loopers/application/product/ProductQueryFacade.java

@@ -1,10 +1,10 @@
 package com.loopers.application.product;
 
 import com.loopers.application.brand.BrandApplicationService;
+import com.loopers.application.product.cache.CachedPublicProductDetail;
 import com.loopers.application.product.view.ProductListView;
 import com.loopers.application.product.view.ProductView;
 import com.loopers.domain.product.Product;
-import com.loopers.domain.product.ProductService;
 import com.loopers.domain.product.query.ProductListCriteria;
 import com.loopers.domain.product.query.ProductListQuery;
 import lombok.RequiredArgsConstructor;
@@ -21,8 +21,8 @@ public class ProductQueryFacade {
 
     private final ProductApplicationService productApplicationService;
     private final BrandApplicationService brandApplicationService;
-    private final ProductService productService;
 
+    @CachedPublicProductDetail
     public ProductView get(UUID productId) {
         Product product = productApplicationService.get(productId);
         Map<UUID, String> brandNames = brandApplicationService.findNamesByIds(List.of(product.brandId()));
@@ -35,26 +35,8 @@ public ProductView getIncludingDeleted(UUID productId) {
         return ProductView.from(product, brandNames.get(product.brandId()));
     }
 
-    public ProductListView list(ProductListQuery query) {
-        ProductListCriteria criteria = productService.toCriteria(query);
-        Page<Product> products = productApplicationService.list(criteria);
-        Map<UUID, String> brandNames = brandApplicationService.findNamesByIds(
-                products.getContent().stream().map(Product::brandId).toList()
-        );
-        List<ProductView> items = products.getContent().stream()
-                .map(product -> ProductView.from(product, brandNames.get(product.brandId())))
-                .toList();
-        return new ProductListView(
-                items,
-                products.getNumber(),
-                products.getSize(),
-                products.getTotalElements(),
-                products.getTotalPages()
-        );
-    }
-
     public ProductListView listIncludingDeleted(ProductListQuery query) {
-        ProductListCriteria criteria = productService.toCriteria(query);
+        ProductListCriteria criteria = ProductListCriteria.fromAdmin(query);
         Page<Product> products = productApplicationService.listIncludingDeleted(criteria);
         Map<UUID, String> brandNames = brandApplicationService.findNamesByIds(
                 products.getContent().stream().map(Product::brandId).toList()