📌 [MarketBridge] 07. 개발일지 - DTO 구조를 개선해보자!

📖 DTO 구조에 대한 문제점 인식

필요한 이름으로 작성하다보니 팀원이 원하는 Dto명과 이미 내가 작성한 Dto명이 겹치게 되었다. 일단 나도 컨벤션없이 그럴듯한 이름으로 작성하다보니 뭐가 뭔지 모르는 현상까지 되어버렸다...

이러한 문제점을 인식하고 깔끔한 dto 컨벤션을 작성해야겠다고 느꼈다.

✏️ 리팩토링

Inner Class를 사용하여 깔끔히 문제를 해결할 수 있도록 하였다.
우리팀끼리의 컨벤션은 외부 클래스명은 controller의 메서드명을 따라가기로 했다.
더하여 Controller에서는 Http를 사용, Service에서는 dto, Repository에서는 dtio를 사용하였다. (dtio : DataTransformInfraObjcet -> 우리팀에서 정한 임의의 정한 이름이니까 이게 뭔 듣보잡? 같은 오해는 안했으면 좋겠다.)

이렇게 계층별로 이름을 나눈 이유는 어디에서 사용하는 dto인지 바로 알 수 있도록 하기 위함이다.

@Getter
@NoArgsConstructor
public class OrderCancelRequest {

    @NotNull
    private String orderNo;
    @NotNull
    private String cancelReason;


    @Builder
    public OrderCancelRequest(String orderNo, String cancelReason) {
        this.orderNo = orderNo;
        this.cancelReason = cancelReason;
    }

    public CancelRequestDto toServiceRequest() {
        return CancelRequestDto.builder()
                .orderNo(orderNo)
                .cancelReason(cancelReason)
                .build();
    }
}

@Getter
@NoArgsConstructor
public class OrderReturnResponse {

    private List<ProductInfoResponse> productResponses;
    private ReturnRefundInfoResponse returnRefundInfoResponse;

    @Builder
    private OrderReturnResponse(List<ProductInfoResponse> productResponses, ReturnRefundInfoResponse returnRefundInfoResponse) {
        this.productResponses = productResponses;
        this.returnRefundInfoResponse = returnRefundInfoResponse;
    }

    public static OrderReturnResponse of(ReturnResponseDto serviceDto) {
        return OrderReturnResponse.builder()
                .productResponses(
                        serviceDto.getProductInfoResponseDtos()
                        .stream()
                        .map(ProductInfoResponse::of)
                        .toList()
                )
                .returnRefundInfoResponse(
                        ReturnRefundInfoResponse.of(serviceDto.getReturnRefundInfoResponseDto())
                )
                .build();

    }
}

이렇던 것들이 Inner Class를 사용하여 깔끔히 만들었다.

public class ConfirmCancelReturnHttp {

    public static class Request {

        @NotNull
        private String orderNo;
        @NotNull
        private String cancelReason;

        @Builder
        public Request(String orderNo, String cancelReason) {
            this.orderNo = orderNo;
            this.cancelReason = cancelReason;
        }

        public ConfirmCancelReturnDto.Request toServiceRequest() {
            return ConfirmCancelReturnDto.Request.builder()
                    .orderNo(orderNo)
                    .cancelReason(cancelReason)
                    .build();
        }
    }

    @Getter
    @NoArgsConstructor
    public static class Response {
        private Long orderId;
        private String orderNumber;
        private Long totalPrice;
        private LocalDateTime cancellationDate; // 주문 취소 일자
        private List<ProductResponse> cancelledItems;
        private RefundInfo refundInfo;

        @Builder
        private Response(Long orderId, String orderNumber, Long totalPrice, LocalDateTime cancellationDate, RefundInfo refundInfo, List<ProductResponse> cancelledItems) {
            this.orderId = orderId;
            this.orderNumber = orderNumber;
            this.totalPrice = totalPrice;
            this.cancellationDate = cancellationDate;
            this.refundInfo = refundInfo;
            this.cancelledItems = cancelledItems;
        }

        public static Response of(ConfirmCancelReturnDto.Response serviceDto) {
            return Response.builder()
                    .orderId(serviceDto.getOrderId())
                    .orderNumber(serviceDto.getOrderNumber())
                    .totalPrice(serviceDto.getTotalPrice())
                    .cancellationDate(serviceDto.getCancellationDate())
                    .refundInfo(serviceDto.getRefundInfo())
                    .cancelledItems(serviceDto.getCancelledItems())
                    .build();

        }
    }
}

이렇게 하니까 무슨 메서드에서 사용하는지 쉽게 알아챌 수 있게 되었다.

Service 계층에서 사용하는 dto도 보자.

@Getter
public class CancelRequestDto {

    private String orderNo;
    private String cancelReason;

    @Builder
    private CancelRequestDto(String orderNo, String cancelReason) {
        this.orderNo = orderNo;
        this.cancelReason = cancelReason;
    }
}

@Getter
@NoArgsConstructor
public class CancelReturnResponseDto {
    private Long orderId;
    private String orderNumber;
    private Long totalPrice;
    private LocalDateTime cancellationDate; // 주문 취소 일자
    private List<ProductResponse> cancelledItems;
    private RefundInfo refundInfo;

    @Builder
    private CancelReturnResponseDto(Long orderId, String orderNumber, Long totalPrice, LocalDateTime cancellationDate, RefundInfo refundInfo, List<ProductResponse> cancelledItems) {
        this.orderId = orderId;
        this.orderNumber = orderNumber;
        this.totalPrice = totalPrice;
        this.cancellationDate = cancellationDate;
        this.refundInfo = refundInfo;
        this.cancelledItems = cancelledItems;
    }

    public static CancelReturnResponseDto of(Order order, RefundDto refundDto, DateTimeHolder dateTimeHolder) {
        return CancelReturnResponseDto.builder()
                .orderId(order.getId())
                .orderNumber(order.getOrderNo())
                .totalPrice(order.getOrderDetails().stream()
                        .mapToLong(OrderDetail::totalAmount)
                        .sum()
                )
                .cancellationDate(dateTimeHolder.getUpdateTime(order))
                .refundInfo(RefundInfo.of(refundDto))
                .cancelledItems(
                        order.getOrderDetails().stream()
                                .map(orderDetail -> ProductResponse.of(orderDetail.getProduct(), orderDetail.getQuantity()))
                                .toList()
                )
                .build();
    }
}

이렇게 되어있었던 dto들을 Inner Class를 사용하여 깔끔히 만들었다.

public class ConfirmCancelReturnDto {

    @Getter
    @NoArgsConstructor
    public static class Request {

        private String orderNo;
        private String cancelReason;

        @Builder
        private Request(String orderNo, String cancelReason) {
            this.orderNo = orderNo;
            this.cancelReason = cancelReason;
        }
    }

    @Getter
    @NoArgsConstructor
    public static class Response {

        private Long orderId;
        private String orderNo;
        private Long totalPrice;
        private LocalDateTime cancellationDate; // 주문 취소 일자
        private List<ProductInfo> cancelledItems;
        private RefundInfo refundInfo;

        @Builder
        private Response(Long orderId, String orderNo, Long totalPrice, LocalDateTime cancellationDate, RefundInfo refundInfo, List<ProductInfo> cancelledItems) {
            this.orderId = orderId;
            this.orderNo = orderNo;
            this.totalPrice = totalPrice;
            this.cancellationDate = cancellationDate;
            this.refundInfo = refundInfo;
            this.cancelledItems = cancelledItems;
        }

        public static Response of(Order order, RefundDto refundDto, DateTimeHolder dateTimeHolder) {
            return Response.builder()
                    .orderId(order.getId())
                    .orderNo(order.getOrderNo())
                    .totalPrice(
                            order.getOrderDetails()
                                    .stream()
                                    .mapToLong(OrderDetail::totalAmount)
                                    .sum()
                    )
                    .cancellationDate(dateTimeHolder.getUpdateTime(order))
                    .refundInfo(RefundInfo.of(refundDto))
                    .cancelledItems(
                            order.getOrderDetails().stream()
                                    .map(orderDetail -> ProductInfo.of(orderDetail.getProduct(), orderDetail.getQuantity()))
                                    .toList()
                    )
                    .build();
        }
    }

    @Getter
    @NoArgsConstructor
    public static class ProductInfo {

        private Long productId;
        private String productNo;
        private String name;
        private Long price;
        private Long quantity;

        @Builder
        private ProductInfo(Long productId, String productNo, String name, Long price, Long quantity) {
            this.productId = productId;
            this.productNo = productNo;
            this.name = name;
            this.price = price;
            this.quantity = quantity;
        }

        public static ProductInfo of(Product product, Long quantity) {
            return ProductInfo.builder()
                    .productId(product.getId())
                    .name(product.getName())
                    .price(product.getPrice())
                    .quantity(quantity)
                    .productNo(product.getProductNo())
                    .build();
        }
    }

    @Getter
    @NoArgsConstructor
    public static class RefundInfo {

        private Long totalRefundAmount;
        private String refundMethod;
        private LocalDateTime refundProcessedAt; // 환불 일자

        @Builder
        public RefundInfo(Long totalRefundAmount, String refundMethod, LocalDateTime refundProcessedAt) {
            this.totalRefundAmount = totalRefundAmount;
            this.refundMethod = refundMethod;
            this.refundProcessedAt = refundProcessedAt;
        }

        public static RefundInfo of(RefundDto refundDto) {
            return RefundInfo.builder()
                    .totalRefundAmount(refundDto.getTotalRefundAmount())
                    .refundMethod(refundDto.getRefundMethod())
                    .refundProcessedAt(refundDto.getRefundProcessedAt())
                    .build();
        }
    }

}

이렇게 변경하니 어디에서 어떤 메서드의 어디 계층에서 사용하는 dto인지 바로 알 수 있게 되었다.
모두 바꾼 후에 기존과 어떻게 달라졌는지 확인하자!

🕶️ 결론

<Controller>

---

<Service>

이전과 비교했을 때 어느 계층, 메서드에서 사용되는지 쉽게 알 수 있게 되었다.

ps. 테스트까지 수정하는데 너무 힘들었다 흑흑