Merge pull request #140 from Kimjipang/main

Kimjipang · web-flow · commit bd8fb7bb54c6 · 2025-12-04T02:18:35.000+09:00
[volume-5] 인덱스 및 Redis 캐시 적용
diff --git a/apps/commerce-api/src/main/java/com/loopers/CommerceApiApplication.java b/apps/commerce-api/src/main/java/com/loopers/CommerceApiApplication.java
@@ -4,10 +4,13 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
+import org.springframework.cache.annotation.EnableCaching;
+
 import java.util.TimeZone;
 
 @ConfigurationPropertiesScan
 @SpringBootApplication
+@EnableCaching
 public class CommerceApiApplication {
 
     @PostConstruct
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/like/LikeFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/like/LikeFacade.java
@@ -2,6 +2,7 @@
 
 import com.loopers.domain.like.Like;
 import com.loopers.domain.like.LikeRepository;
+import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.domain.user.UserRepository;
 import com.loopers.interfaces.api.like.LikeV1Dto;
@@ -32,7 +33,7 @@ public LikeInfo doLike(LikeV1Dto.LikeRequest request) {
                 () -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 유저입니다.")
         );
 
-        productRepository.findById(productId).orElseThrow(
+        Product product = productRepository.findById(productId).orElseThrow(
                 () -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 상품입니다.")
         );
 
@@ -42,6 +43,8 @@ public LikeInfo doLike(LikeV1Dto.LikeRequest request) {
                     Like newLike = request.toEntity();
                     likeRepository.save(newLike);
 
+                    product.addLikeCount();
+
                     return LikeInfo.from(newLike);
                 });
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java
@@ -1,66 +1,87 @@
 package com.loopers.application.product;
 
+import com.loopers.domain.brand.BrandRepository;
 import com.loopers.domain.like.LikeRepository;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.interfaces.api.product.ProductV1Dto;
 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.Cacheable;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.math.BigDecimal;
 import java.util.List;
 
 @Component
 @RequiredArgsConstructor
 public class ProductFacade {
     private final ProductRepository productRepository;
     private final LikeRepository likeRepository;
+    private final BrandRepository brandRepository;
 
 
     @Transactional
     public ProductInfo registerProduct(ProductV1Dto.ProductRequest request) {
+        Long brandId = request.brandId();
+
+        brandRepository.findById(brandId).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "등록하고자 하는 상품의 브랜드가 존재하지 않습니다.")
+        );
+
         Product product = request.toEntity();
         productRepository.save(product);
 
-        return ProductInfo.from(product, 0);
+        return ProductInfo.from(product);
     }
 
     @Transactional(readOnly = true)
+    @Cacheable(value = "products", key = "'all'")
     public List<ProductInfo> findAllProducts() {
         List<Product> products = productRepository.findAll();
 
         return products.stream()
-                .map(product -> {
-                    int likeCount = likeRepository.countByProductId(product.getId());
-                    return ProductInfo.from(product, likeCount);
-                })
+                .map(ProductInfo::from)
                 .toList();
     }
 
     @Transactional(readOnly = true)
+    @Cacheable(value = "product", key = "#id")
     public ProductInfo findProductById(Long id) {
         Product product = productRepository.findById(id).orElseThrow(
                 () -> new CoreException(ErrorType.NOT_FOUND, "찾고자 하는 상품이 존재하지 않습니다.")
         );
 
-        int likeCount = likeRepository.countByProductId(id);
-
-        return ProductInfo.from(product, likeCount);
+        return ProductInfo.from(product);
     }
 
     @Transactional(readOnly = true)
     public List<ProductInfo> searchProductsByCondition(ProductV1Dto.SearchProductRequest request) {
+        request.filterCondition().conditionValidate();
         request.sortCondition().conditionValidate();
 
         List<Product> products = productRepository.searchProductsByCondition(request);
 
         return products.stream()
-                .map(product -> {
-                    int likeCount = likeRepository.countByProductId(product.getId());
-                    return ProductInfo.from(product, likeCount);
-                })
+                .map(ProductInfo::from)
                 .toList();
     }
+
+    @Transactional
+    @CacheEvict(value = "product", key = "#request.id()")
+    public ProductInfo changePrice(ProductV1Dto.ChangePriceRequest request) {
+        Long id = request.id();
+        BigDecimal newPrice = request.newPrice();
+
+        Product product = productRepository.findById(id).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 상품입니다.")
+        );
+
+        Product changedProduct = product.changePrice(newPrice);
+
+        return ProductInfo.from(changedProduct);
+    }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java
@@ -5,14 +5,15 @@
 import java.math.BigDecimal;
 
 public record ProductInfo(Long id, Long brandId, String name, BigDecimal price, int stock, int likeCount) {
-    public static ProductInfo from(Product product, int likeCount) {
+    public static ProductInfo from(Product product) {
         return new ProductInfo(
-            product.getId(),
-            product.getBrandId(),
-            product.getName(),
-            product.getPrice(),
-            product.getStock(),
-            likeCount
+                product.getId(),
+                product.getBrandId(),
+                product.getName(),
+                product.getPrice(),
+                product.getStock(),
+                product.getLikeCount()
         );
+
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandRepository.java
@@ -0,0 +1,7 @@
+package com.loopers.domain.brand;
+
+import java.util.Optional;
+
+public interface BrandRepository {
+    Optional<Brand> findById(Long id);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/Product.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/Product.java
@@ -29,20 +29,24 @@ public class Product extends BaseEntity {
     @Column(name = "stock", nullable = false)
     private int stock;
 
+    @Column(name = "like_count", nullable = false)
+    private int likeCount;
 
-    public Product(Long brandId, String name, BigDecimal price, int stock) {
+
+    public Product(Long brandId, String name, BigDecimal price, int stock, int likeCount) {
         this.brandId = brandId;
         this.name = name;
         this.price = price;
         this.stock = stock;
+        this.likeCount = likeCount;
     }
 
     public Product changePrice(BigDecimal newPrice) {
         this.price = newPrice;
         return this;
     }
 
-    public Product decreaseStock(int amount) {
+    public void decreaseStock(int amount) {
         if (amount <= 0) {
             throw new CoreException(ErrorType.BAD_REQUEST, "재고 감소량은 0보다 커야 합니다.");
         }
@@ -51,11 +55,14 @@ public Product decreaseStock(int amount) {
         }
         this.stock -= amount;
 
-        return this;
     }
 
     public boolean isInStock(int quantity) {
         return this.stock >= quantity;
     }
 
+    public int addLikeCount() {
+        return this.likeCount++;
+    }
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandJpaRepository.java
@@ -0,0 +1,8 @@
+package com.loopers.infrastructure.brand;
+
+import com.loopers.domain.brand.Brand;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface BrandJpaRepository extends JpaRepository<Brand, Long> {
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandRepositoryImpl.java
@@ -0,0 +1,19 @@
+package com.loopers.infrastructure.brand;
+
+import com.loopers.domain.brand.Brand;
+import com.loopers.domain.brand.BrandRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+@Component
+@RequiredArgsConstructor
+public class BrandRepositoryImpl implements BrandRepository {
+    private final BrandJpaRepository brandJpaRepository;
+
+    @Override
+    public Optional<Brand> findById(Long id) {
+        return brandJpaRepository.findById(id);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java
@@ -41,7 +41,7 @@ public List<Product> findAll() {
 
     @Override
     public List<Product> searchProductsByCondition(ProductV1Dto.SearchProductRequest request) {
-        System.out.println("sortBy = " + request.sortCondition().sortBy());
+
         boolean isAsc = request.sortCondition().order().equals("asc");
 
         JPAQuery<Product> query = queryFactory
@@ -50,6 +50,10 @@ public List<Product> searchProductsByCondition(ProductV1Dto.SearchProductRequest
                 .on(product.id.eq(like.productId))
                 .groupBy(product.id);
 
+        switch (request.filterCondition().filterBy()) {
+            case "brandId" -> query.where(product.brandId.eq(request.filterCondition().filterValue()));
+        }
+
 
         switch (request.sortCondition().sortBy()) {
             case "price" -> query.orderBy(isAsc ? product.price.asc() : product.price.desc());
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1ApiSpec.java
@@ -9,14 +9,18 @@
 @Tag(name = "Product V1 API", description = "Product API 입니다.")
 public interface ProductV1ApiSpec {
     @Operation(summary = "상품 등록")
-    ApiResponse<ProductV1Dto.ProductResponse> registerProduct (ProductV1Dto.ProductRequest request);
+    ApiResponse<ProductV1Dto.ProductResponse> registerProduct(ProductV1Dto.ProductRequest request);
 
     @Operation(summary = "상품 목록 조회")
-    ApiResponse<List<ProductV1Dto.ProductResponse>> findAllProducts ();
+    ApiResponse<List<ProductV1Dto.ProductResponse>> findAllProducts();
 
     @Operation(summary = "상품 상세 조회")
-    ApiResponse<ProductV1Dto.ProductResponse> findProductById (Long id);
+    ApiResponse<ProductV1Dto.ProductResponse> findProductById(Long id);
 
     @Operation(summary = "상품 정렬 조회")
-    ApiResponse<List<ProductV1Dto.ProductResponse>> findProductsBySortCondition (ProductV1Dto.SearchProductRequest request);
+    ApiResponse<List<ProductV1Dto.ProductResponse>> findProductsBySortCondition(ProductV1Dto.SearchProductRequest request);
+
+    @Operation(summary = "상품 가격 변경")
+    ApiResponse<ProductV1Dto.ProductResponse> changePrice(ProductV1Dto.ChangePriceRequest request);
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java
@@ -60,4 +60,14 @@ public ApiResponse<List<ProductV1Dto.ProductResponse>> findProductsBySortConditi
 
         return ApiResponse.success(responses);
     }
+
+    @PostMapping("/change")
+    @Override
+    public ApiResponse<ProductV1Dto.ProductResponse> changePrice(@RequestBody ProductV1Dto.ChangePriceRequest request) {
+        ProductInfo info = productFacade.changePrice(request);
+
+        ProductV1Dto.ProductResponse response = ProductV1Dto.ProductResponse.from(info);
+
+        return ApiResponse.success(response);
+    }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Dto.java
@@ -27,12 +27,22 @@ public Product toEntity() {
                     brandId,
                     name,
                     price,
-                    stock
+                    stock,
+                    0
             );
         }
     }
 
-    public record SearchProductRequest(SortCondition sortCondition) {
+    public record SearchProductRequest(FilterCondition filterCondition, SortCondition sortCondition) {
+        public record FilterCondition(String filterBy, Long filterValue) {
+            public void conditionValidate() {
+                if (!filterBy.equals("brandId")) {
+                    throw new CoreException(ErrorType.BAD_REQUEST, "유효하지 않은 필터 조건입니다.");
+                }
+            }
+
+        }
+
         public record SortCondition(String sortBy, String order) {
             public void conditionValidate() {
                 if (!sortBy.equals("price") && !sortBy.equals("likeCount") && !sortBy.equals("createdAt")) {
@@ -44,4 +54,7 @@ public void conditionValidate() {
             }
         }
     }
+
+    public record ChangePriceRequest(Long id, BigDecimal newPrice) {
+    }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeConcurrencyIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeConcurrencyIntegrationTest.java
@@ -52,7 +52,8 @@ public class LikeConcurrencyIntegrationTest {
                         1L,
                         "테스트 상품",
                         BigDecimal.valueOf(10000),
-                        100
+                        100,
+                        0
                 )
         );
 
diff --git a/modules/redis/build.gradle.kts b/modules/redis/build.gradle.kts
@@ -5,6 +5,7 @@ plugins {
 
 dependencies {
     api("org.springframework.boot:spring-boot-starter-data-redis")
+    implementation("org.springframework.boot:spring-boot-starter-cache")
 
     testFixturesImplementation("com.redis:testcontainers-redis")
 }
diff --git a/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java b/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java
@@ -7,12 +7,17 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
 import org.springframework.data.redis.connection.RedisStaticMasterReplicaConfiguration;
 import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
 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.StringRedisSerializer;
 
+import java.time.Duration;
 import java.util.List;
 import java.util.function.Consumer;
 
@@ -98,4 +103,21 @@ private <K,V> RedisTemplate<K,V> defaultRedisTemplate(
         template.setConnectionFactory(connectionFactory);
         return template;
     }
+
+    @Bean
+    public RedisCacheManager redisCacheManager(
+            @Qualifier("redisConnectionMaster") LettuceConnectionFactory masterConnectionFactory
+    ) {
+        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
+                .entryTtl(Duration.ofMinutes(10))
+                .serializeKeysWith(
+                        RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
+                .serializeValuesWith(
+                        RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
+                .disableCachingNullValues();
+
+        return RedisCacheManager.builder(masterConnectionFactory)
+                .cacheDefaults(config)
+                .build();
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -29,20 +29,24 @@ public class Product extends BaseEntity {`
`29`	`29`	`@Column(name = "stock", nullable = false)`
`30`	`30`	`private int stock;`
`31`	`31`
	`32`	`+ @Column(name = "like_count", nullable = false)`
	`33`	`+ private int likeCount;`
`32`	`34`
`33`		`- public Product(Long brandId, String name, BigDecimal price, int stock) {`
	`35`	`+`
	`36`	`+ public Product(Long brandId, String name, BigDecimal price, int stock, int likeCount) {`
`34`	`37`	`this.brandId = brandId;`
`35`	`38`	`this.name = name;`
`36`	`39`	`this.price = price;`
`37`	`40`	`this.stock = stock;`
	`41`	`+ this.likeCount = likeCount;`
`38`	`42`	`}`
`39`	`43`
`40`	`44`	`public Product changePrice(BigDecimal newPrice) {`
`41`	`45`	`this.price = newPrice;`
`42`	`46`	`return this;`
`43`	`47`	`}`
`44`	`48`
`45`		`- public Product decreaseStock(int amount) {`
	`49`	`+ public void decreaseStock(int amount) {`
`46`	`50`	`if (amount <= 0) {`
`47`	`51`	`throw new CoreException(ErrorType.BAD_REQUEST, "재고 감소량은 0보다 커야 합니다.");`
`48`	`52`	`}`
`@@ -51,11 +55,14 @@ public Product decreaseStock(int amount) {`
`51`	`55`	`}`
`52`	`56`	`this.stock -= amount;`
`53`	`57`
`54`		`- return this;`
`55`	`58`	`}`
`56`	`59`
`57`	`60`	`public boolean isInStock(int quantity) {`
`58`	`61`	`return this.stock >= quantity;`
`59`	`62`	`}`
`60`	`63`
	`64`	`+ public int addLikeCount() {`
	`65`	`+ return this.likeCount++;`
	`66`	`+ }`
	`67`	`+`
`61`	`68`	`}`