[spring] 실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화 #1

이 글은 김영한 님의 인프런 강의 '실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화' 를 수강하고 작성한 글 입니다.

https://www.inflearn.com/course/스프링부트-JPA-API개발-성능최적화/community?type=question 

실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화 질문 & 답변 - 인프런 | 강의

---

1. API 개발 기본

 

1-1. V1 엔티티를 RequestBody, ResponseBody 에 직접 매핑

회원 생성 API

com.wwan13.api.MemberApiController.java

@RestController
@RequiredArgsConstructor
public class MemberApiController {

    private final MemberService memberService;

    @PostMapping("/api/v1/members")
    public CreateMemberResponse saveMemberV1(@RequestBody @Valid Member member)
    {
        Long id = memberService.join(member);
        return new CreateMemberResponse(id);
    }

    @Data
    static class CreateMemberRequest {
        private String name;
    }

    @Data
    static class CreateMemberResponse {
        private Long id;

        public CreateMemberResponse(Long id) {
            this.id = id;
        }
    }

}

 

 

회원 조회 API

com.wwan13.api.MemberApiController.java

    @GetMapping("/api/v1/members")
    public List<Member> membersV1() {
        return memberService.findMembers();
    }

 

문제점

• 엔티티에 프레젠테이션 계층을 위한 로직이 추가된다.
• 엔티티에 API 검증을 위한 로직이 들어간다. (@NotEmpty 등등)
• 응답 스펙을 맞추기 위해 로직이 추가된다. (@JsonIgnore, 별도의 뷰 로직 등등)
• 실무에서는 회원 엔티티를 위한 API가 다양하게 만들어지는데, 한 엔티티에 각각의 API를 위한 모든 요청 요구사항, 응답 로직을 담기는 어렵다.
• 엔티티가 변경되면 API 스펙이 변한다.
• 추가로 컬렉션을 직접 반환하면 향후 API 스펙을 변경하기 어렵다. (별도의 Result 클래스 생성으로 해결)

결론

• API 요청 스펙에 맞춰 별도의 DTO 를 파라미터로 받거나, 별도의 DTO를 반환한다.

 

 

1-2. V2 엔티티 대신 DTO를 RequestBody, ResponseBody 에 매핑

회원 생성 API

com.wwan13.api.MemberApiController.java

@PostMapping("/api/v2/members")
public CreateMemberResponse saveMemberV2(@RequestBody @Valid
                                             CreateMemberRequest request) {
    Member member = new Member();
    member.setName(request.getName());
    Long id = memberService.join(member);
    return new CreateMemberResponse(id);
}

• CreateMemberRequest를 Member 엔티티 대신 RequestBody와 메핑한다.
• 엔티티와 프레젠테이션 계층을 위한 로직을 분리할 수 있다.
• 엔티티와 API 스펙을 명확하게 분리할 수 있다.
• 엔티티가 변해도 API스펙이 변하지 않는다.

 

회원 수정 API

com.wwan13.api.MemberApiController.java

    @PatchMapping("/api/v2/members/{id}")
    public UpdateMemberResponse updateMemberV2(@PathVariable("id") Long id,
                                               @RequestBody @Valid UpdateMemberRequest request) {
        memberService.update(id, request.getName());
        Member findMember = memberService.findOne(id);
        return new UpdateMemberResponse(findMember.getId(), findMember.getName());
    }

    @Data
    static class UpdateMemberRequest {
        private String name;
    }
    @Data
    @AllArgsConstructor
    static class UpdateMemberResponse {
        private Long id;
        private String name;
    }

 

회원 조회 API

com.wwan13.api.MemberApiController.java

    @GetMapping("/api/v2/members")
    public Result membersV2() {
        List<Member> findMembers = memberService.findMembers(); //엔티티 -> DTO 변환
        List<MemberDto> collect = findMembers.stream()
                .map(m -> new MemberDto(m.getName()))
                .collect(Collectors.toList());
        return new Result(collect);
    }
    @Data
    @AllArgsConstructor
    static class Result<T> {
        private T data;
    }
    @Data
    @AllArgsConstructor
    static class MemberDto {
        private String name;
    }

• 엔티티를 DTO로 변환해서 반환한다.
• 엔티티가 변해도 API 스펙이 변경되지 않는다.
• 추가로 Result 클래스로 컬렉션을 감싸서 향후 필요한 필드를 추가할 수 있다.

 

컨트롤러의 반환값을 반환용 Dto 의 타입을 명시하지 않고 제네릭을 사용한 이유, Controller의 반환값으로 배열을 그대로 전달 하면 안되는 이유가 궁금하다면 해당 블로그 글을 참고하자. https://wwan13.tistory.com/22

 

 

2. API 개발 고급 - 지연 로딩과 조회 성능 최적화

 

2-1. 간단한 주문 조회 V1 : 엔티티를 직접 노출

com.wwan13.api.OrderSimpleApiController.java

    @GetMapping("/api/v1/simple-orders")
    public List<Order> ordersV1() {

        List<Order> all = orderRepository.findAllByString(new OrderSearch());

        for (Order order : all) {
            order.getMember().getName(); //Lazy 강제 초기화
            order.getDelivery().getAddress(); //Lazy 강제 초기화
        }

        return all;
    }

• 엔티티를 직접 노출하는 것은 좋지 않다.
• order -> member, order -> address 는 지연로딩이다. 따라서 실제 엔티티 대신 프록시 존재
• jackson 라이브러리는 기본적으로 이 프록시 객체를 json으로 생성하는 법을 몰라 예외가 발생

 

Hibernate5Module을 스프링 빈으로 등록하여 위 문제를 해결하는 방법이 있지만, 위와 같이 엔티티를 직접 노출하는 방법은 좋지 않은 방법 이기 때문에, 이 글에서 해결 방법은 제시하지 않겠다.
자세한 해결 방법이 궁금하면 김영한님의 인프런 강의 '실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화' 를 참고하자.

지연로딩과, 프록시에 대한 자세한 내용이 궁금하다면 아래 블로그 글을 참고하자.
지연로딩 - https://wwan13.tistory.com/20
프록시 - https://wwan13.tistory.com/21

 

 

2-2. 간단한 주문 조회 V2: 엔티티를 DTO로 변환

com.wwan13.api.OrderSimpleApiController.java

    @GetMapping("/api/v2/simple-orders")
    public List<SimpleOrderDto> ordersV2() {
        List<Order> orders = orderRepository.findAllByString(new OrderSearch());
        List<SimpleOrderDto> result = orders.stream()
                .map(o -> new SimpleOrderDto(o))
                .collect(toList());
        return result;
    }

    @Data
    static class SimpleOrderDto {

        private Long orderId;
        private String name;
        private LocalDateTime orderDate;
        private OrderStatus orderStatus;
        private Address address;
        public SimpleOrderDto(Order order) {
            orderId = order.getId();
            name = order.getMember().getName();
            orderDate = order.getOrderDate();
            orderStatus = order.getStatus();
            address = order.getDelivery().getAddress();
        }
    }

• 엔티티를 DTO로 변환하는 일반적인 방법이다.
• 쿼리가 총 1 + N + N 번 실행된다. (v1과 쿼리 수 결과는 같다)
  • order 조회 1번 ( order 조회 결과 수가 N 이 된다.)
  • order -> member 지연 로딩 조회 N번
  • order -> delivery 지연 로딩 조회 N번

 

 

2-3. 간단한 주문 조회 V3: 엔티티를 DTO로 변환 - 페치 조인 최적화

com.wwan13.api.OrderSimpleApiController.java

    @GetMapping("/api/v3/simple-orders")
    public List<SimpleOrderDto> orderV3() {
        List<Order> orders = orderRepository.findAllWithMemberDelivery();
        List<SimpleOrderDto> result = orders.stream()
                .map(o -> new SimpleOrderDto(o))
                .collect(toList());
        return result;
    }

com.wwan13.repository.OrderRepository.java

    public List<Order> findAllWithMemberDelivery() {
        return em.createQuery("select o from Order o" +
                    " join fetch o.member m" +
                    " join fetch o.delivery d", Order.class)
                .getResultList();

    }

• 엔티티를 페치조인(fetch join)을 사용해 쿼리 1번에 조회
• 페치 조인으로 order -> member, order -> delivery 는 이미 조회 된 상태 이므로 지연로딩이 이뤄지지 않는다.

 

 

2-4. 간단한 주문 조회 V4: JPA에서 DTO로 바로 조회

com.wwan13.api.OrderSimpleApiController.java

    @GetMapping("/api/v4/simple-orders")
    public List<OrderSimpleQueryDto> ordersV4() {
        return orderSimpleQueryRepository.findOrderDtos();
    }

com.wwan13.repository.OrderSimpleQueryRepository.java

    public List<OrderSimpleQueryDto> findOrderDtos() {
        return em.createQuery(
                "select new jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto(o.id, m.name, o.orderDate, o.status, d.address)"
                + " from Order o"
                + " join o.member m"
                + " join o.delivery d", OrderSimpleQueryDto.class)
                .getResultList();
    }

• 일반적인 SQL을 사용할 때 처럼 원하는 값을 선택해서 ㄷ조회
• new 명령어를 사용해 JPQL의 결과를 DTO로 즉시 변환
• SELECT절 에서 원하는 데이터를 직접 선택하므로 DB -> 애플리케이션 네트워크 용량 최적화 (생각보다 미비)
• 리포지토리 재사용성이 떨어짐, API 스펙에 맞춘 코드가 리포지토리에 들어가는 단점

 

 

3. 쿼리 방식 선택 권장 순서

1. 엔티티를 DTO로 변환하는 방법을 선택한다.
2. 필요하면 페치 조인으로 성능을 최적화 한다 (대부분의 성능 이슈 해결)
3. 그래도 안된다면 DTO로 직접 조회하는 방법을 사용한다.
4. 최후의 방법은 JPA가 제공하는 네이티브 SQL 이나 스프링 JDBC 템프릿을 이용해 SQL을 직접 사용한다.