Merge pull request #55 from IT-Cotato/feature/17

[Feat] 검색 기능 (ElasticSearch, Redis)

Author: marshmallowing

src/main/java/com/ongil/backend/Application.java

@@ -4,10 +4,12 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.cloud.openfeign.EnableFeignClients;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+import org.springframework.scheduling.annotation.EnableAsync;
 
 @EnableJpaAuditing
 @SpringBootApplication
 @EnableFeignClients
+@EnableAsync
 public class Application {
 
 	public static void main(String[] args) {

src/main/java/com/ongil/backend/domain/auth/service/AuthService.java

@@ -19,7 +19,6 @@
 import com.ongil.backend.global.config.redis.RedisRefreshTokenStore;
 import com.ongil.backend.global.security.jwt.JwtTokenProvider;
 
-import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 
 @Service

src/main/java/com/ongil/backend/domain/product/controller/ProductController.java

@@ -11,6 +11,7 @@
 
 import com.ongil.backend.domain.product.dto.request.ProductSearchCondition;
 import com.ongil.backend.domain.product.dto.response.ProductDetailResponse;
+import com.ongil.backend.domain.product.dto.response.ProductSearchPageResDto;
 import com.ongil.backend.domain.product.dto.response.ProductSimpleResponse;
 import com.ongil.backend.domain.product.dto.response.SizeGuideResponse;
 import com.ongil.backend.domain.product.enums.ProductSortType;
@@ -41,15 +42,27 @@ public DataResponse<ProductDetailResponse> getProductDetail(@PathVariable Long p
 		return DataResponse.from(productDetail);
 	}
 
-	@Operation(summary = "상품 목록 조회", description = "조건에 맞는 상품들의 목록을 조회합니다.")
+	@Operation(
+		summary = "상품 목록 조회 (검색 포함)",
+		description = """
+    조건에 맞는 상품 목록을 조회합니다.
+    - query가 없는 경우: 일반 상품 목록 조회(카테고리/브랜드/가격/사이즈 필터 + 정렬 + 페이징)
+    - query가 있는 경우: Elasticsearch로 검색어에 매칭되는 상품 ID를 먼저 조회한 뒤,
+      해당 ID 범위 내에서 필터/정렬/페이징을 적용하여 '검색 결과 목록'을 반환합니다.
+    - 검색 결과가 0개인 경우: products는 빈 페이지로 반환하고, alternatives(최대 4개 대체 검색어)를 함께 반환합니다.
+    - 로그인 사용자(userId 존재)인 경우: 검색 성공 시 최근검색어/검색 로그가 저장됩니다.
+  """
+	)
 	@GetMapping
-	public DataResponse<Page<ProductSimpleResponse>> getProducts(
+	public DataResponse<ProductSearchPageResDto> getProducts(
+		@RequestParam(required = false) String query,
 		@RequestParam(required = false) Long categoryId,
 		@RequestParam(required = false) Long brandId,
 		@RequestParam(required = false) String priceRange,
 		@RequestParam(required = false) String clothingSize,
 		@RequestParam(required = false, defaultValue = "POPULAR") ProductSortType sortType,
-		@PageableDefault(size = 20) Pageable pageable
+		@PageableDefault(size = 20) Pageable pageable,
+		@AuthenticationPrincipal Long userId
 	) {
 		ProductSearchCondition condition = ProductSearchCondition.builder()
 			.categoryId(categoryId)
@@ -58,9 +71,8 @@ public DataResponse<Page<ProductSimpleResponse>> getProducts(
 			.size(clothingSize)
 			.build();
 
-		Page<ProductSimpleResponse> products = productService.getProducts(condition, sortType, pageable);
-
-		return DataResponse.from(products);
+		ProductSearchPageResDto res = productService.getProducts(condition, sortType, pageable, query, userId);
+		return DataResponse.from(res);
 	}
 
 	@Operation(summary = "특가 상품 조회", description = "할인율이 높은 특가 상품 TOP 10을 조회합니다.")

src/main/java/com/ongil/backend/domain/product/dto/response/ProductSearchPageResDto.java

@@ -0,0 +1,15 @@
+package com.ongil.backend.domain.product.dto.response;
+
+import java.util.List;
+
+import org.springframework.data.domain.Page;
+
+public record ProductSearchPageResDto(
+	Page<ProductSimpleResponse> products,
+	List<String> alternatives,
+	boolean hasResult
+) {
+	public static ProductSearchPageResDto of(Page<ProductSimpleResponse> products, List<String> alternatives) {
+		return new ProductSearchPageResDto(products, alternatives, !products.isEmpty());
+	}
+}

src/main/java/com/ongil/backend/domain/product/repository/ProductRepository.java

@@ -28,15 +28,17 @@ public interface ProductRepository extends JpaRepository<Product, Long> {
 	// 조건에 따른 상품 조회
 	@EntityGraph(attributePaths = {"brand", "category"})
 	@Query("""
-		SELECT p FROM Product p
-		WHERE (:categoryId IS NULL OR p.category.id = :categoryId)
-		  AND (:brandId IS NULL OR p.brand.id = :brandId)
-		  AND (:minPrice IS NULL OR p.price >= :minPrice)
-		  AND (:maxPrice IS NULL OR p.price <= :maxPrice)
-		  AND (:size IS NULL OR p.sizes LIKE CONCAT('%', :size, '%'))
-		  AND p.onSale = true
-		""")
+    SELECT p FROM Product p
+    WHERE (:targetIds IS NULL OR p.id IN :targetIds)
+      AND (:categoryId IS NULL OR p.category.id = :categoryId)
+      AND (:brandId IS NULL OR p.brand.id = :brandId)
+      AND (:minPrice IS NULL OR p.price >= :minPrice)
+      AND (:maxPrice IS NULL OR p.price <= :maxPrice)
+      AND (:size IS NULL OR p.sizes LIKE CONCAT('%', :size, '%'))
+      AND p.onSale = true
+    """)
 	Page<Product> findAllByCondition(
+		@Param("targetIds") List<Long> targetIds,
 		@Param("categoryId") Long categoryId,
 		@Param("brandId") Long brandId,
 		@Param("minPrice") Integer minPrice,

src/main/java/com/ongil/backend/domain/product/service/ProductService.java

@@ -14,6 +14,7 @@
 import com.ongil.backend.domain.product.dto.request.ProductSearchCondition;
 import com.ongil.backend.domain.product.dto.response.AiMaterialDescriptionResponse;
 import com.ongil.backend.domain.product.dto.response.ProductDetailResponse;
+import com.ongil.backend.domain.product.dto.response.ProductSearchPageResDto;
 import com.ongil.backend.domain.product.dto.response.ProductSimpleResponse;
 import com.ongil.backend.domain.product.dto.response.SizeGuideResponse;
 import com.ongil.backend.domain.product.entity.Product;
@@ -22,16 +23,21 @@
 import com.ongil.backend.domain.product.enums.ProductType;
 import com.ongil.backend.domain.product.repository.ProductOptionRepository;
 import com.ongil.backend.domain.product.repository.ProductRepository;
+import com.ongil.backend.domain.search.service.RecentSearchService;
+import com.ongil.backend.domain.search.service.SearchService;
+import com.ongil.backend.domain.search.validator.SearchValidator;
 import com.ongil.backend.domain.user.entity.User;
 import com.ongil.backend.domain.user.repository.UserRepository;
 import com.ongil.backend.global.common.exception.EntityNotFoundException;
 import com.ongil.backend.global.common.exception.ErrorCode;
 
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 
 @Transactional(readOnly = true)
 @Service
 @RequiredArgsConstructor
+@Slf4j
 public class ProductService {
 
 	private final ProductRepository productRepository;
@@ -40,6 +46,8 @@ public class ProductService {
 	private final AiMaterialService aiMaterialService;
 	private final UserRepository userRepository;
 	private final SizeGuideConverter sizeGuideConverter;
+	private final SearchService searchService;
+	private final RecentSearchService recentSearchService;
 
 	private static final int SIMILAR_CUSTOMERS_LIMIT = 4;
 
@@ -61,16 +69,28 @@ public ProductDetailResponse getProductDetail(Long productId) {
 	}
 
 	// 조건에 따른 상품 조회
-	public Page<ProductSimpleResponse> getProducts(
+	public ProductSearchPageResDto getProducts(
 		ProductSearchCondition condition,
 		ProductSortType sortType,
-		Pageable pageable
+		Pageable pageable,
+		String query,
+		Long userId
 	) {
+
+		// 검색어(query)가 있을 시 Elasticsearch 관련 동작
+		boolean hasQuery = query != null && !query.isBlank();
+		List<Long> targetIds = hasQuery ? searchService.getProductIdsByQuery(query) : null;
+
+		if (hasQuery && targetIds.isEmpty()) {
+			String keyword = SearchValidator.normalize(query);
+			List<String> alternatives = searchService.recommendAlternatives(keyword, 4);
+			return ProductSearchPageResDto.of(Page.empty(pageable), alternatives);
+		}
+
 		Integer[] priceRange = condition.parsePriceRange();
 		Integer minPrice = priceRange != null ? priceRange[0] : null;
 		Integer maxPrice = priceRange != null ? priceRange[1] : null;
 
-		// 정렬 조건 생성
 		Sort sort = createSort(sortType);
 		Pageable pageableWithSort = PageRequest.of(
 			pageable.getPageNumber(),
@@ -79,6 +99,7 @@ public Page<ProductSimpleResponse> getProducts(
 		);
 
 		Page<Product> products = productRepository.findAllByCondition(
+			targetIds,
 			condition.getCategoryId(),
 			condition.getBrandId(),
 			minPrice,
@@ -87,7 +108,40 @@ public Page<ProductSimpleResponse> getProducts(
 			pageableWithSort
 		);
 
-		return products.map(productConverter::toSimpleResponse);
+		// 추천 검색어에 이용하기 위한 과정
+		if (hasQuery && !products.isEmpty()) {
+			Product firstProduct = products.getContent().get(0);
+			String savedKeyword = null;
+
+			if (firstProduct.getBrand() != null && firstProduct.getBrand().getName() != null) {
+				savedKeyword = firstProduct.getBrand().getName();
+			}
+			else if (firstProduct.getCategory() != null && firstProduct.getCategory().getName() != null) {
+				savedKeyword = firstProduct.getCategory().getName();
+			}
+
+			if (savedKeyword != null && !savedKeyword.isBlank()) {
+				recordSearchSideEffects(savedKeyword, userId);
+			}
+		}
+
+		Page<ProductSimpleResponse> pageRes = products.map(productConverter::toSimpleResponse);
+		return ProductSearchPageResDto.of(pageRes, List.of());
+	}
+
+	// 로그인 유저) 최근 검색어 저장
+	private void recordSearchSideEffects(String query, Long userId) {
+		String keyword = SearchValidator.normalize(query);
+		if (keyword.isEmpty()) return;
+
+		searchService.saveSearchLog(keyword, userId);
+		if (userId != null) {
+			try {
+				recentSearchService.saveRecentSearch(userId, keyword);
+			} catch (Exception e) {
+				log.error("Redis 최근 검색어 저장 실패: {}", e.getMessage());
+			}
+		}
 	}
 
 	// 특가 상품 조회

src/main/java/com/ongil/backend/domain/search/controller/SearchController.java

@@ -1,71 +1,92 @@
 package com.ongil.backend.domain.search.controller;
 
-import com.ongil.backend.domain.search.dto.response.SearchAutocompleteResponse;
-import com.ongil.backend.domain.search.dto.response.SearchLogResponse;
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.ongil.backend.domain.search.service.RecentSearchService;
+import com.ongil.backend.domain.search.service.SearchIndexingService;
 import com.ongil.backend.domain.search.service.SearchService;
-import com.ongil.backend.global.common.dto.DataResponse; // DataResponse 사용
+import com.ongil.backend.global.common.dto.DataResponse;
+
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.security.core.annotation.AuthenticationPrincipal;
-import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.*;
 
-import java.util.List;
-
-@Slf4j
-@Tag(name = "Search", description = "검색 관련 API")
-@Validated
 @RestController
-@RequestMapping("/api/v1/search")
 @RequiredArgsConstructor
+@RequestMapping("/api/search")
+@Tag(name = "Search", description = "검색 API")
 public class SearchController {
 
-    private final SearchService searchService;
-
-    @Operation(summary = "검색 초기 화면 데이터", description = "로그인: 최근 검색어(7개) / 비로그인: 추천 검색어(5개)")
-    @GetMapping("/logs")
-    public DataResponse<List<SearchLogResponse>> getSearchLogs(
-            @AuthenticationPrincipal Long userId) { // UserDetails 대신 Long userId 바로 사용
-
-        List<SearchLogResponse> response = searchService.getInitialSearchLog(userId);
-        return DataResponse.from(response);
-    }
-
-    @Operation(summary = "검색어 기록 저장", description = "검색 버튼 클릭 시 호출 (상품 목록 이동 전)")
-    @PostMapping("/log")
-    public DataResponse<Void> saveSearchLog(
-            @AuthenticationPrincipal Long userId,
-            @RequestParam String keyword) {
+	private final SearchService searchService;
+	private final SearchIndexingService searchIndexingService;
+	private final RecentSearchService recentSearchService;
 
-        searchService.saveSearchLog(userId, keyword);
-        return DataResponse.from(null);
-    }
+	// 자동 완성
+	@GetMapping("/autocomplete")
+	public ResponseEntity<DataResponse<List<String>>> autocomplete(
+		@RequestParam String query) {
+		List<String> suggestions = searchService.getAutocomplete(query);
+		return ResponseEntity.ok(DataResponse.from(suggestions));
+	}
 
-    @Operation(summary = "최근 검색어 개별 삭제")
-    @DeleteMapping("/log")
-    public DataResponse<Void> deleteSearchLog(
-            @AuthenticationPrincipal Long userId,
-            @RequestParam String keyword) {
+	// 추천 검색어
+	@GetMapping("/recommend")
+	public ResponseEntity<DataResponse<List<String>>> getRecommend() {
+		return ResponseEntity.ok(DataResponse.from(searchService.getTopKeywords()));
+	}
 
-        searchService.deleteRecentSearch(userId, keyword);
-        return DataResponse.from(null);
-    }
+	// 최근 검색어
+	@GetMapping("/recent")
+	public ResponseEntity<DataResponse<List<String>>> getRecent(
+		@AuthenticationPrincipal Long userId) {
+		if (userId == null) {
+			return ResponseEntity.ok(DataResponse.from(Collections.emptyList()));
+		}
+		List<String> recentSearches = recentSearchService.getRecentSearches(userId);
+		return ResponseEntity.ok(DataResponse.from(recentSearches));
+	}
 
-    @Operation(summary = "최근 검색어 전체 삭제")
-    @DeleteMapping("/logs")
-    public DataResponse<Void> deleteAllSearchLogs(
-            @AuthenticationPrincipal Long userId) {
+	// 최근 검색어 개별 삭제
+	@DeleteMapping("/recent")
+	public ResponseEntity<DataResponse<Void>> removeRecent(
+		@AuthenticationPrincipal Long userId,
+		@RequestParam String keyword) {
+		if (userId != null) {
+			recentSearchService.removeRecentSearch(userId, keyword);
+		}
+		return ResponseEntity.ok(DataResponse.from(null));
+	}
 
-        searchService.deleteAllRecentSearch(userId);
-        return DataResponse.from(null);
-    }
+	// 최근 검색어 전체 삭제
+	@DeleteMapping("/recent/all")
+	public ResponseEntity<DataResponse<Void>> clearAllRecent(
+		@AuthenticationPrincipal Long userId) {
+		if (userId != null) {
+			recentSearchService.clearRecentSearches(userId);
+		}
+		return ResponseEntity.ok(DataResponse.from(null));
+	}
 
-    @Operation(summary = "실시간 자동완성", description = "카테고리 & 브랜드 검색 (우선순위: 카테고리)")
-    @GetMapping("/autocomplete")
-    public DataResponse<List<SearchAutocompleteResponse>> getAutocomplete(@RequestParam String keyword) {
-        List<SearchAutocompleteResponse> response = searchService.getAutocomplete(keyword);
-        return DataResponse.from(response);
-    }
+	/**
+	 * [관리자용] 데이터 전체 동기화 API
+	 */
+	@PostMapping("/admin/reindex")
+	@Operation(
+		summary = "데이터 전체 동기화 (관리자용)",
+		description = "데이터베이스의 모든 상품 정보를 Elasticsearch로 다시 색인합니다."
+	)
+	public ResponseEntity<String> reindex() {
+		searchIndexingService.indexAllProducts();
+		return ResponseEntity.ok("전체 데이터 색인이 완료되었습니다.");
+	}
 }