🔍 Controller

/** 메인 페이지 */
@GetMapping("/")
public ResponseEntity<List<List<?>>> mainPage(){
    List<List<?>> returnList = productService.mainPageProductList();
    return (!returnList.isEmpty()) ?
            ResponseEntity.status(HttpStatus.OK).body(returnList) :
            ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
}

/** 상품명으로 검색 */
@GetMapping("/shop/search/{keyword}")
public ResponseEntity<List<ResponseProductSummary>> findByProductName(@PathVariable String keyword, @RequestParam(value = "sort", defaultValue = "hits") String sort){
    List<ResponseProductSummary> productList = productService.findByProductName(keyword, sort);
    return (!productList.isEmpty()) ?
            ResponseEntity.status(HttpStatus.OK).body(productList) :
            ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
}

/** 상품 전체 조회 */
@GetMapping("/shop")
public ResponseEntity<List<ResponseProductSummary>> findAllProduct(@RequestParam(value = "sort", defaultValue = "hits") String sort){
    List<ResponseProductSummary> productList = productService.findAllProduct(sort);
    return (!productList.isEmpty()) ?
            ResponseEntity.status(HttpStatus.OK).body(productList) :
            ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
}

/** 상품 카테고리별 조회 */
@GetMapping("/shop/category/{category}")
public ResponseEntity<List<ResponseProductSummary>> findByCategory(@PathVariable String category, @RequestParam(value = "sort", defaultValue = "hits") String sort){
    List<ResponseProductSummary>productList = productService.findByCategory(category, sort);
    return (!productList.isEmpty()) ?
            ResponseEntity.status(HttpStatus.OK).body(productList) :
            ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
}

/** 상품 상세 페이지 조회 */
@Transactional
@GetMapping("/shop/detail/{id}")
public ResponseEntity<ResponseProduct> findById(@PathVariable Long id){
    productService.increaseHits(id);
    ResponseProduct product = productService.findById(id);
    return (product != null) ?
            ResponseEntity.status(HttpStatus.OK).body(product) :
            ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
}

/** 판매등록한 상품 목록 조회 */
@GetMapping("/register/product")
public ResponseEntity<List<ResponseProductSummary>> findProductByUsername(HttpServletRequest request){
    User user = (User) request.getAttribute("user");
    List<ResponseProductSummary> productList = productService.findProductByUsername(user.getId());
    return (!productList.isEmpty()) ?
            ResponseEntity.status(HttpStatus.OK).body(productList) :
            ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
}

ProductService의 각 조회에 맞는 함수를 호출하고 결과에 따라 200 또는 400의 status code를 반환

상품명으로 검색, 상품 전체 조회, 상품 카테고리별 조회는 원하는 sort 방식으로 사용 가능

🔍 Service

@Override
public List<List<?>> mainPageProductList() {
    List<Product> productList = productRepository.findTop8ByOrderByIdDesc();
    List<Banner> bannerList = bannerRepository.findAll();

    return entityToDtoMainPageList(productList, bannerList);
}

@Override
public List<ResponseProductSummary> findByProductName(String keyword, String sort) {
    List<Product> productList = new ArrayList<>();
    switch (sort) {
        case "hits" -> productList = productRepository.findByNameContainingAndStockGreaterThanOrderByHitsDesc(keyword, 0);
        case "date" -> productList = productRepository.findByNameContainingAndStockGreaterThanOrderByDateDesc(keyword, 0);
        case "favorite"-> productList = productRepository.findByNameContainingAndStockGreaterThanOrderByFavoriteDesc(keyword, 0);
        case "purchase" -> {
            return purchaseSort(productRepository.findSearchProductPurchase(keyword));
        }
    }

    return entityToDtoResponseProductSummary(productList);
}

@Override
public List<ResponseProductSummary> findAllProduct(String sort) {
    List<Product> productList = new ArrayList<>();
    switch (sort) {
        case "hits" -> productList = productRepository.findByStockGreaterThanOrderByHitsDesc(0);
        case "date" -> productList = productRepository.findByStockGreaterThanOrderByDateDesc(0);
        case "favorite"-> productList = productRepository.findByStockGreaterThanOrderByFavoriteDesc(0);
        case "purchase" -> {
            return purchaseSort(productRepository.findAllProductPurchase());
        }
    }

    return entityToDtoResponseProductSummary(productList);
}

@Override
public List<ResponseProductSummary> findByCategory(String category, String sort) {
    List<Product> productList = new ArrayList<>();
    switch (sort) {
        case "hits" -> productList = productRepository.findByCategoryAndStockGreaterThanOrderByHitsDesc(category, 0);
        case "date" -> productList = productRepository.findByCategoryAndStockGreaterThanOrderByDateDesc(category, 0);
        case "favorite"-> productList = productRepository.findByCategoryAndStockGreaterThanOrderByFavoriteDesc(category, 0);
        case "purchase" -> {
            return purchaseSort(productRepository.findCategoryProductPurchase(category));
        }
    }

    return entityToDtoResponseProductSummary(productList);
}

@Override
public ResponseProductDetails findById(User user, Long id) {
    Product product = productRepository.findById(id).orElse(null);
    if (product == null){
        return null;
    }

    Boolean status = false;
    if(user != null) {
        status = favoriteRepository.existUserProductByFavorite(user.getId(), id);
    }

    return ResponseProductDetails.builder().product(product).status(status).build();
}

@Override
public List<ResponseProductSummary> findProductByUsername(Long userId) {
    List<Product> productList = productRepository.findByUserId(userId);

    return entityToDtoResponseProductSummary(productList);
}

/** Entity to Dto */
public List<ResponseProductSummary> entityToDtoResponseProductSummary(List<Product> productList) {
    List<ResponseProductSummary> responseProductList = new ArrayList<>();
    if (!productList.isEmpty()){
        for(Product product : productList){
            responseProductList.add(ResponseProductSummary.builder().product(product).build());
        }
    }

    return responseProductList;
}

public List<ResponseProductSummary> purchaseSort(List<ResponseProductPurchase> productPurchaseList) {
    Collections.sort(productPurchaseList);

    return productPurchaseList.stream().map(productPurchase -> ResponseProductSummary
            .dtoBuilder()
            .responseProductPurchase(productPurchase)
            .dtoBuild()).toList();
}

/** Entity to Dto */
public List<List<?>> entityToDtoMainPageList(List<Product> productList, List<Banner> bannerList) {
    List<ResponseProductMain> responseProductList = new ArrayList<>();
    List<ResponseBanner> responseBannerList = new ArrayList<>();
    List<List<?>> returnList = new ArrayList<>();

    if (!productList.isEmpty() && !bannerList.isEmpty()) {
        for(Product product : productList){
            responseProductList.add(ResponseProductMain.builder().product(product).build());
        }
        for (Banner banner : bannerList) {
            responseBannerList.add(ResponseBanner.builder().banner(banner).build());
        }
        returnList.add(responseProductList);
        returnList.add(responseBannerList);
    }

    return returnList;
}

각 원하는 조건을 컨트롤러에서 받아와 적절한 쿼리를 수행

메인 페이지는 상품과 베너를 같이 전달, entityToDtoMainPageList 함수를 사용해 Entity to Dto 수행

다른 모든 조회는 Product 라는 Entity만을 조회하므로 메인 페이지와는 다른 entityToDtoResponseProductSummary 함수로 Entity to Dto 수행

구매 순 정렬은 쿼리 특성 상 WAS 단에서 정렬 로직 수행

🔍 Repository

/**메인 페이지 상품 조회*/
List<Product> findTop8ByOrderByIdDesc();

// =================================================================
/**상품명으로 검색 조회수높은순으로 조회*/
List<Product> findByNameContainingAndStockGreaterThanOrderByHitsDesc(String name, int stock);

/**상품명으로 검색 최신순으로 조회*/
List<Product> findByNameContainingAndStockGreaterThanOrderByDateDesc(String name, int stock);

/**상품명으로 검색 좋아요순으로 조회*/
List<Product> findByNameContainingAndStockGreaterThanOrderByFavoriteDesc(String name, int stock);

// =================================================================
/**상품 전체 조회수높은순으로 조회*/
List<Product> findByStockGreaterThanOrderByHitsDesc(int stock);

/**상품 전체 최신순으로 조회*/
List<Product> findByStockGreaterThanOrderByDateDesc(int stock);

/**상품 전체 좋아요순으로 조회*/
List<Product> findByStockGreaterThanOrderByFavoriteDesc(int stock);

// =================================================================
/**상품 카테고리별 조회수높은순으로 조회*/
List<Product> findByCategoryAndStockGreaterThanOrderByHitsDesc(String category, int stock);

/**상품 카테고리별 최신순으로 조회*/
List<Product> findByCategoryAndStockGreaterThanOrderByDateDesc(String category, int stock);

/**상품 카테고리별 좋아요순으로 조회*/
List<Product> findByCategoryAndStockGreaterThanOrderByFavoriteDesc(String category, int stock);

// =================================================================

/**판매등록한 상품 목록 조회*/
List<Product> findByUserId(Long userId);

정렬 쿼리는 조회 수, 검색 순, 좋아요 순은 JPA 기본 문법 사용

@Override
public List<ResponseProductPurchase> findAllProductPurchase() {

    return queryFactory.select(Projections.fields(ResponseProductPurchase.class,
										product.id,
										product.name,
										product.price,
										product.favorite,
										product.imgKey,
                    ExpressionUtils.as(
                            JPAExpressions.select(orderProduct.count.sum())
                                    .from(orderProduct)
                                    .groupBy(orderProduct.product.id)
                                    .orderBy(OrderByNull.DEFAULT)
                                    .where(orderProduct.product.eq(product)), "count"
                    )))
            .from(product)
            .where(product.stock.gt(0))
            .fetch();
}

@Override
public List<ResponseProductPurchase> findSearchProductPurchase(String keyword) {
    BooleanExpression status = null;
    status = containKeyword(keyword);

    if (status == null) {
        return null;
    }

    return queryFactory.select(Projections.fields(ResponseProductPurchase.class,
										product.id,
										product.name,
										product.price,
										product.favorite,
										product.imgKey,
                    ExpressionUtils.as(
                            JPAExpressions.select(orderProduct.count.sum())
                                    .from(orderProduct)
                                    .groupBy(orderProduct.product.id)
                                    .orderBy(OrderByNull.DEFAULT)
                                    .where(orderProduct.product.eq(product)), "count"
                    )))
            .from(product)
            .where(status,product.stock.gt(0))
            .fetch();
}

@Override
public List<ResponseProductPurchase> findCategoryProductPurchase(String category) {
    BooleanExpression status = null;
    status = eqCategory(category);

    if (status == null) {
        return null;
    }

    return queryFactory.select(Projections.fields(ResponseProductPurchase.class,
										product.id,
										product.name,
										product.price,
										product.favorite,
										product.imgKey,
                    ExpressionUtils.as(
                            JPAExpressions.select(orderProduct.count.sum())
                                    .from(orderProduct)
                                    .groupBy(orderProduct.product.id)
                                    .orderBy(OrderByNull.DEFAULT)
                                    .where(orderProduct.product.eq(product)), "count"
                    )))
            .from(product)
            .where(status,product.stock.gt(0))
            .fetch();
}

구매 순은 서브 쿼리로 OrderProduct의 count값을 product_id를 기준으로 GroupBy로 가져와서 진행

최종 쿼리에서 stock이 0이라면 재고가 없다는 뜻이기 때문에 0 초과일 때만 조회