Round5 cache

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

@@ -0,0 +1,34 @@
+package com.loopers.application;
+
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+import java.util.function.Function;
+
+public record PageResult<T>(
+        List<T> items,
+        int page,
+        int size,
+        long totalElements,
+        int totalPages
+) {
+    public static <T> PageResult<T> from(Page<T> page) {
+        return new PageResult<>(
+                page.getContent(),
+                page.getNumber(),
+                page.getSize(),
+                page.getTotalElements(),
+                page.getTotalPages()
+        );
+    }
+
+    public <R> PageResult<R> map(Function<T, R> mapper) {
+        return new PageResult<>(
+                items.stream().map(mapper).toList(),
+                page,
+                size,
+                totalElements,
+                totalPages
+        );
+    }
+}

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

@@ -2,8 +2,13 @@
 
 import com.loopers.application.brand.BrandService;
 import com.loopers.application.like.LikeService;
-import lombok.RequiredArgsConstructor;
+import com.loopers.application.PageResult;
+import com.loopers.config.CacheConfig;
 import org.springframework.data.domain.Page;
+import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.cache.annotation.Caching;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -26,22 +31,28 @@ public ProductInfo register(ProductCreateCommand command) {
         return productService.register(command);
     }
 
+    @Cacheable(cacheNames = CacheConfig.PRODUCT, key = "#id")
     public ProductInfo getActiveProduct(Long id) {
         ProductInfo product = productService.getActiveProduct(id);
         String brandName = brandService.getBrandNameMap(List.of(product.brand().id()))
                                        .get(product.brand().id());
         return product.withBrand(new ProductInfo.BrandSummary(product.brand().id(), brandName));
     }
 
-    public Page<ProductInfo> getActiveProducts(Long brandId, ProductSort sort, Pageable pageable) {
+    @Cacheable(cacheNames = CacheConfig.PRODUCTS, key = "#brandId + ':' + #sort + ':' + #pageable.pageNumber + ':' + #pageable.pageSize")
+    public PageResult<ProductInfo> getActiveProducts(Long brandId, ProductSort sort, Pageable pageable) {
         Page<ProductInfo> products = productService.getActiveProducts(brandId, sort, pageable);
         Set<Long> brandIds = products.stream().map(p -> p.brand().id()).collect(Collectors.toSet());
         Map<Long, String> brandNameMap = brandService.getBrandNameMap(brandIds);
-        return products.map(p -> p.withBrand(
+        return PageResult.from(products.map(p -> p.withBrand(
                 new ProductInfo.BrandSummary(p.brand().id(), brandNameMap.getOrDefault(p.brand().id(), null))
-        ));
+        )));
     }
 
+    @Caching(evict = {
+            @CacheEvict(cacheNames = CacheConfig.PRODUCT, key = "#id"),
+            @CacheEvict(cacheNames = CacheConfig.PRODUCTS, allEntries = true)
+    })
     @Transactional
     public void delete(Long id) {
         likeService.deleteAllByProductIds(List.of(id));

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

@@ -3,9 +3,12 @@
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.application.order.OrderItemCommand;
+import com.loopers.config.CacheConfig;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Caching;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
@@ -55,6 +58,10 @@ public Page<ProductInfo> getProducts(Long brandId, Pageable pageable) {
         return productRepository.findAllProducts(brandId, pageable).map(ProductInfo::from);
     }
 
+    @Caching(evict = {
+            @CacheEvict(cacheNames = CacheConfig.PRODUCT, key = "#id"),
+            @CacheEvict(cacheNames = CacheConfig.PRODUCTS, allEntries = true)
+    })
     @Transactional
     public ProductInfo update(Long id, ProductUpdateCommand command) {
         Product product = findById(id);

apps/commerce-api/src/main/java/com/loopers/config/CacheConfig.java

@@ -0,0 +1,59 @@
+package com.loopers.config;
+
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import com.loopers.application.PageResult;
+import com.loopers.application.product.ProductInfo;
+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.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import java.time.Duration;
+
+@EnableCaching
+@Configuration
+public class CacheConfig {
+
+    public static final String PRODUCT = "product";
+    public static final String PRODUCTS = "products";
+
+    @Bean
+    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
+        ObjectMapper objectMapper = new ObjectMapper()
+                .registerModule(new JavaTimeModule())
+                .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+
+        StringRedisSerializer keySerializer = new StringRedisSerializer();
+
+        RedisCacheConfiguration productConfig = RedisCacheConfiguration.defaultCacheConfig()
+                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer))
+                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
+                        new Jackson2JsonRedisSerializer<>(objectMapper, ProductInfo.class)
+                ))
+                .entryTtl(Duration.ofMinutes(30))
+                .disableCachingNullValues();
+
+        JavaType pageResultType = objectMapper.getTypeFactory()
+                .constructParametricType(PageResult.class, ProductInfo.class);
+        RedisCacheConfiguration productsConfig = RedisCacheConfiguration.defaultCacheConfig()
+                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer))
+                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
+                        new Jackson2JsonRedisSerializer<>(objectMapper, pageResultType)
+                ))
+                .entryTtl(Duration.ofMinutes(10))
+                .disableCachingNullValues();
+
+        return RedisCacheManager.builder(connectionFactory)
+                .withCacheConfiguration(PRODUCT, productConfig)
+                .withCacheConfiguration(PRODUCTS, productsConfig)
+                .build();
+    }
+}

apps/commerce-api/src/main/java/com/loopers/interfaces/api/PageResponse.java

@@ -1,5 +1,6 @@
 package com.loopers.interfaces.api;
 
+import com.loopers.application.PageResult;
 import org.springframework.data.domain.Page;
 
 import java.util.List;
@@ -20,4 +21,14 @@ public static <T> PageResponse<T> from(Page<T> page) {
                 page.getTotalPages()
         );
     }
+
+    public static <T> PageResponse<T> from(PageResult<T> result) {
+        return new PageResponse<>(
+                result.items(),
+                result.page(),
+                result.size(),
+                result.totalElements(),
+                result.totalPages()
+        );
+    }
 }

apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java

@@ -1,13 +1,13 @@
 package com.loopers.interfaces.api.product;
 
+import com.loopers.application.PageResult;
 import com.loopers.application.product.ProductFacade;
 import com.loopers.application.product.ProductInfo;
 import com.loopers.application.product.ProductSort;
 import com.loopers.interfaces.api.ApiResponse;
 import com.loopers.interfaces.api.PageResponse;
 import com.loopers.interfaces.api.product.dto.ProductV1Dto;
 import lombok.RequiredArgsConstructor;
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.web.PageableDefault;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -35,9 +35,9 @@ public ApiResponse<PageResponse<ProductV1Dto.ProductResponse>> getProducts(
             @RequestParam(defaultValue = "LATEST") ProductSort sort,
             @PageableDefault(size = 20) Pageable pageable
     ) {
-        Page<ProductV1Dto.ProductResponse> page = productFacade.getActiveProducts(brandId, sort, pageable)
-                                                               .map(ProductV1Dto.ProductResponse::from);
+        PageResult<ProductV1Dto.ProductResponse> result = productFacade.getActiveProducts(brandId, sort, pageable)
+                                                                       .map(ProductV1Dto.ProductResponse::from);
 
-        return ApiResponse.success(PageResponse.from(page));
+        return ApiResponse.success(PageResponse.from(result));
     }
 }

apps/commerce-api/src/test/java/com/loopers/DataInitializer.java

@@ -0,0 +1,94 @@
+package com.loopers;
+
+import com.loopers.domain.brand.Brand;
+import com.loopers.domain.product.Product;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.springframework.transaction.support.TransactionTemplate;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.ThreadLocalRandom;
+
+@SpringBootTest
+@ActiveProfiles("local")
+public class DataInitializer {
+
+    // TestContainers(MySqlTestContainersConfig)가 System.setProperty로 DB URL을 덮어쓰므로
+    // DynamicPropertySource로 로컬 MySQL로 재설정 (우선순위: DynamicPropertySource > System.setProperty)
+    @DynamicPropertySource
+    static void overrideDataSource(DynamicPropertyRegistry registry) {
+        registry.add("datasource.mysql-jpa.main.jdbc-url", () -> "jdbc:mysql://localhost:3306/loopers");
+        registry.add("datasource.mysql-jpa.main.username", () -> "application");
+        registry.add("datasource.mysql-jpa.main.password", () -> "application");
+    }
+
+    @PersistenceContext
+    EntityManager entityManager;
+
+    @Autowired
+    TransactionTemplate transactionTemplate;
+
+    @Test
+    void initialize() {
+        List<Long> brandIds = saveBrands(50);
+
+        for (int i = 0; i < brandIds.size(); i++) {
+            Long brandId = brandIds.get(i);
+
+            boolean isTopBrand = i < 10; // 앞 10개 브랜드만 top
+            int productCount = isTopBrand ? 10_000 : 2_500;
+            int likeMin = isTopBrand ? 300 : 0;
+            int likeMax = isTopBrand ? 3_000 : 2_000;
+
+            insertProducts(brandId, productCount);
+            updateLikeCount(brandId, likeMin, likeMax);
+        }
+    }
+
+    List<Long> saveBrands(int count) {
+        return transactionTemplate.execute(status -> {
+            List<Long> ids = new ArrayList<>();
+            for (int i = 1; i <= count; i++) {
+                Brand brand = Brand.create("브랜드-" + i, null);
+                entityManager.persist(brand);
+                entityManager.flush();
+                ids.add(brand.getId());
+            }
+
+            return ids;
+        });
+    }
+
+    void insertProducts(Long brandId, int count) {
+        transactionTemplate.executeWithoutResult(status -> {
+            for (int i = 0; i < count; i++) {
+                int price = ThreadLocalRandom.current().nextInt(1_000, 100_001);
+                entityManager.persist(Product.create(brandId,
+                                        "상품_" + UUID.randomUUID().toString()
+                                                            .substring(0, 8), null, price, 100));
+                if (i % 500 == 499) {
+                    entityManager.flush();
+                    entityManager.clear();
+                }
+            }
+        });
+    }
+
+    void updateLikeCount(Long brandId, int min, int max) {
+        transactionTemplate.executeWithoutResult(status ->
+            entityManager.createNativeQuery("UPDATE products SET like_count = FLOOR(:min + RAND() * (:max - :min + 1)) WHERE brand_id = :brandId")
+                .setParameter("min", min)
+                .setParameter("max", max)
+                .setParameter("brandId", brandId)
+                .executeUpdate()
+        );
+    }
+}

apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java

@@ -6,13 +6,13 @@
 import com.loopers.domain.brand.InMemoryBrandRepository;
 import com.loopers.domain.like.InMemoryLikeRepository;
 import com.loopers.domain.product.InMemoryProductRepository;
+import com.loopers.application.PageResult;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -68,11 +68,11 @@ void returnsBrandName_forEachProduct() {
             productService.register(new ProductCreateCommand(adidas.id(), "슈퍼스타", "신발", 120000, 8));
 
             // act
-            Page<ProductInfo> result = productFacade.getActiveProducts(null, ProductSort.LATEST, PageRequest.of(0, 20));
+            PageResult<ProductInfo> result = productFacade.getActiveProducts(null, ProductSort.LATEST, PageRequest.of(0, 20));
 
             // assert
             assertAll(
-                    () -> assertThat(result.getContent()).extracting(p -> p.brand().name())
+                    () -> assertThat(result.items()).extracting(p -> p.brand().name())
                             .containsExactlyInAnyOrder("나이키", "아디다스")
             );
         }
@@ -86,10 +86,10 @@ void returnsSameBrandName_whenMultipleProductsOfSameBrand() {
             productService.register(new ProductCreateCommand(brand.id(), "조던", "농구화", 200000, 5));
 
             // act
-            Page<ProductInfo> result = productFacade.getActiveProducts(null, ProductSort.LATEST, PageRequest.of(0, 20));
+            PageResult<ProductInfo> result = productFacade.getActiveProducts(null, ProductSort.LATEST, PageRequest.of(0, 20));
 
             // assert
-            assertThat(result.getContent()).extracting(p -> p.brand().name())
+            assertThat(result.items()).extracting(p -> p.brand().name())
                     .containsOnly("나이키");
         }
     }