refactor: service 계층이 Response 객체를 반환하지 않도록 리팩터링

src/main/java/cart/dto/response/PointResponse.java

@@ -1,13 +1,15 @@
 package cart.dto.response;
 
+import cart.domain.Point;
+
 public class PointResponse {
 
     private final int userPoint;
     private final int minUsagePoint;
 
-    public PointResponse(int userPoint, int minUsagePoint) {
+    public PointResponse(int userPoint) {
         this.userPoint = userPoint;
-        this.minUsagePoint = minUsagePoint;
+        this.minUsagePoint = Point.MIN_USAGE_VALUE;
     }
 
     public int getUserPoint() {

src/main/java/cart/presentation/CartItemApiController.java

@@ -1,16 +1,26 @@
 package cart.presentation;
 
+import cart.domain.CartItem;
 import cart.domain.Member;
 import cart.dto.request.CartItemAddRequest;
 import cart.dto.request.CartItemQuantityUpdateRequest;
 import cart.dto.response.CartItemResponse;
 import cart.service.CartItemService;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PatchMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
 import java.net.URI;
 import java.util.List;
 
+import static java.util.stream.Collectors.toList;
+
 @RestController
 @RequestMapping("/cart-items")
 public class CartItemApiController {
@@ -30,7 +40,13 @@ public ResponseEntity<Void> addCartItems(final Member member, final @RequestBody
 
     @GetMapping
     public ResponseEntity<List<CartItemResponse>> showCartItems(final Member member) {
-        return ResponseEntity.ok(cartItemService.findByMember(member));
+        List<CartItem> cartItems = cartItemService.findByMember(member);
+
+        List<CartItemResponse> response = cartItems.stream()
+                .map(CartItemResponse::from)
+                .collect(toList());
+
+        return ResponseEntity.ok(response);
     }
 
     @PatchMapping("/{cartItemId}")

src/main/java/cart/presentation/OrderApiController.java

@@ -1,23 +1,40 @@
 package cart.presentation;
 
 import cart.domain.Member;
+import cart.domain.OrderEntity;
+import cart.domain.OrderItemEntity;
+import cart.domain.Product;
 import cart.dto.request.OrderRequest;
+import cart.dto.response.OrderItemResponse;
 import cart.dto.response.OrderResponse;
 import cart.service.OrderService;
+import cart.service.ProductService;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
 import java.net.URI;
+import java.util.ArrayList;
 import java.util.List;
 
+import static java.util.stream.Collectors.toList;
+
 @RestController
 @RequestMapping("/orders")
 public class OrderApiController {
 
+    private static final int SHOW_ORDER_ITEM_COUNT = 2;
+
     private final OrderService orderService;
+    private final ProductService productService;
 
-    public OrderApiController(OrderService orderService) {
+    public OrderApiController(OrderService orderService, ProductService productService) {
         this.orderService = orderService;
+        this.productService = productService;
     }
 
     @PostMapping
@@ -29,15 +46,48 @@ public ResponseEntity<Void> order(final Member member, final @RequestBody OrderR
 
     @GetMapping
     public ResponseEntity<List<OrderResponse>> getAllOrders(final Member member) {
-        List<OrderResponse> orderResponses = orderService.getAllOrderBy(member.getId());
+        List<OrderResponse> response = new ArrayList<>();
+
+        for (final OrderEntity orderEntity : orderService.getAllOrderBy(member)) {
+            List<OrderItemResponse> orderItemResponses = toSpecificCountOrderItemResponses(orderEntity);
+
+            response.add(OrderResponse.of(orderEntity, orderItemResponses));
+        }
 
-        return ResponseEntity.ok(orderResponses);
+        return ResponseEntity.ok(response);
+    }
+
+    private List<OrderItemResponse> toSpecificCountOrderItemResponses(final OrderEntity orderEntity) {
+        List<OrderItemEntity> orderItemEntities = orderService.getSpecificCountOrderItemBy(orderEntity, SHOW_ORDER_ITEM_COUNT);
+
+        return createOrderItemResponses(orderItemEntities);
+    }
+
+    private List<OrderItemResponse> createOrderItemResponses(final List<OrderItemEntity> orderItemEntities) {
+        List<OrderItemResponse> result = new ArrayList<>();
+
+        List<Product> products = orderItemEntities.stream()
+                .map(orderItemEntity -> productService.getProductById(orderItemEntity.getProductId()))
+                .collect(toList());
+
+        for (int index = 0; index < orderItemEntities.size(); index++) {
+            result.add(OrderItemResponse.of(orderItemEntities.get(index), products.get(index)));
+        }
+        return result;
     }
 
     @GetMapping("/{orderId}")
     public ResponseEntity<OrderResponse> getOrder(final @PathVariable Long orderId) {
-        OrderResponse orderResponse = orderService.findOrderBy(orderId);
+        OrderEntity orderEntity = orderService.findByOrderId(orderId);
+
+        List<OrderItemResponse> orderItemResponses = toAllOrderItemResponses(orderEntity);
+
+        return ResponseEntity.ok(OrderResponse.of(orderEntity, orderItemResponses));
+    }
+
+    private List<OrderItemResponse> toAllOrderItemResponses(final OrderEntity orderEntity) {
+        List<OrderItemEntity> orderItemEntities = orderService.getAllOrderItemBy(orderEntity);
 
-        return ResponseEntity.ok(orderResponse);
+        return createOrderItemResponses(orderItemEntities);
     }
 }

src/main/java/cart/presentation/PointApiController.java

@@ -20,8 +20,9 @@ public PointApiController(PointService pointService) {
 
     @GetMapping
     public ResponseEntity<PointResponse> getUserPoint(final Member member) {
-        PointResponse pointResponse = pointService.getUserPoint(member);
+        int userPoint = pointService.getUserPoint(member);
+        PointResponse response = new PointResponse(userPoint);
 
-        return ResponseEntity.ok(pointResponse);
+        return ResponseEntity.ok(response);
     }
 }

src/main/java/cart/presentation/ProductApiController.java

@@ -1,15 +1,25 @@
 package cart.presentation;
 
+import cart.domain.Product;
 import cart.dto.request.ProductAddRequest;
 import cart.dto.response.ProductResponse;
 import cart.service.ProductService;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
 import java.net.URI;
 import java.util.List;
 
+import static java.util.stream.Collectors.toList;
+
 @RestController
 @RequestMapping("/products")
 public class ProductApiController {
@@ -22,12 +32,20 @@ public ProductApiController(ProductService productService) {
 
     @GetMapping
     public ResponseEntity<List<ProductResponse>> getAllProducts() {
-        return ResponseEntity.ok(productService.getAllProducts());
+        List<Product> products = productService.getAllProducts();
+        List<ProductResponse> response = products.stream()
+                .map(ProductResponse::from)
+                .collect(toList());
+
+        return ResponseEntity.ok(response);
     }
 
     @GetMapping("/{productId}")
     public ResponseEntity<ProductResponse> getProductById(@PathVariable Long productId) {
-        return ResponseEntity.ok(productService.getProductById(productId));
+        Product product = productService.getProductById(productId);
+        ProductResponse response = ProductResponse.from(product);
+
+        return ResponseEntity.ok(response);
     }
 
     @PostMapping

src/main/java/cart/service/CartItemService.java

@@ -33,16 +33,14 @@ public Long add(final Member member, final CartItemAddRequest cartItemAddRequest
         return cartItemRepository.save(cartItem);
     }
 
-    public List<CartItemResponse> findByMember(final Member member) {
+    public List<CartItem> findByMember(final Member member) {
         List<CartItem> cartItems = cartItemRepository.findByMemberId(member.getId());
 
         for (final CartItem cartItem : cartItems) {
             cartItem.validateOwner(member);
         }
 
-        return cartItems.stream()
-                .map(CartItemResponse::from)
-                .collect(Collectors.toList());
+        return cartItems;
     }
 
     public void updateQuantity(final Member member, final Long id, final CartItemQuantityUpdateRequest request) {

src/main/java/cart/service/OrderService.java

@@ -141,30 +141,23 @@ private OrderItemEntity toOrderItemEntity(final long orderId, final ProductInfoR
         );
     }
 
-    public List<OrderResponse> getAllOrderBy(final Long memberId) {
-        List<OrderResponse> result = new ArrayList<>();
-
-        for (final OrderEntity orderEntity : orderDao.findAllByMemberId(memberId)) {
-            List<OrderItemEntity> twoOrderItemEntities = orderItemDao.findTwoByOrderId(orderEntity.getId());
-
-            List<OrderItemResponse> orderItemResponses = twoOrderItemEntities.stream()
-                    .map(orderItemEntity -> OrderItemResponse.of(orderItemEntity, productDao.findById(orderItemEntity.getProductId())))
-                    .collect(toList());
-
-            result.add(OrderResponse.of(orderEntity, orderItemResponses));
-        }
+    public List<OrderEntity> getAllOrderBy(final Member member) {
+        return orderDao.findAllByMemberId(member.getId());
+    }
 
-        return result;
+    public List<OrderItemEntity> getAllOrderItemBy(final OrderEntity orderEntity) {
+        return orderItemDao.findByOrderId(orderEntity.getId());
     }
 
-    public OrderResponse findOrderBy(final Long orderId) {
-        OrderEntity orderEntity = orderDao.findById(orderId);
-        List<OrderItemEntity> orderItemEntities = orderItemDao.findByOrderId(orderEntity.getId());
+    public List<OrderItemEntity> getSpecificCountOrderItemBy(final OrderEntity orderEntity, final int count) {
+        List<OrderItemEntity> orderItemEntities = getAllOrderItemBy(orderEntity);
 
-        List<OrderItemResponse> orderItemResponses = orderItemEntities.stream()
-                .map(orderItemEntity -> OrderItemResponse.of(orderItemEntity, productDao.findById(orderItemEntity.getProductId())))
+        return orderItemEntities.stream()
+                .limit(count)
                 .collect(toList());
+    }
 
-        return OrderResponse.of(orderEntity, orderItemResponses);
+    public OrderEntity findByOrderId(final Long orderId) {
+        return orderDao.findById(orderId);
     }
 }

src/main/java/cart/service/PointService.java

@@ -8,7 +8,7 @@
 @Service
 public class PointService {
 
-    public PointResponse getUserPoint(final Member member) {
-        return new PointResponse(member.getPointValue(), Point.MIN_USAGE_VALUE);
+    public int getUserPoint(final Member member) {
+        return member.getPointValue();
     }
 }

src/main/java/cart/service/ProductService.java

@@ -4,11 +4,9 @@
 import cart.domain.Price;
 import cart.domain.Product;
 import cart.dto.request.ProductAddRequest;
-import cart.dto.response.ProductResponse;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
-import java.util.stream.Collectors;
 
 @Service
 public class ProductService {
@@ -19,16 +17,12 @@ public ProductService(ProductDao productDao) {
         this.productDao = productDao;
     }
 
-    public List<ProductResponse> getAllProducts() {
-        List<Product> products = productDao.findAll();
-
-        return products.stream().map(ProductResponse::from).collect(Collectors.toList());
+    public List<Product> getAllProducts() {
+        return productDao.findAll();
     }
 
-    public ProductResponse getProductById(Long productId) {
-        Product product = productDao.findById(productId);
-
-        return ProductResponse.from(product);
+    public Product getProductById(Long productId) {
+        return productDao.findById(productId);
     }
 
     public Long createProduct(ProductAddRequest productAddRequest) {