선장 일지

엔티티 클래스

ERD

위의 설계대로 구현을 스프링 데이터 JPA를 사용하며 스프링 데이터 JPA에 대해 배워봅시다.

Member

package study.datajpa.entity;

import lombok.*;

import javax.persistence.*;

@Entity
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@ToString(of = {"id", "username", "age"})
public class Member {
    @Id
    @GeneratedValue
    private Long id;
    private String username;
    private int age;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "team_id")
    private Team team;

    public void changeTeam(Team team){
        this.team = team;
        team.getMembers().add(this);
    }

    public Member(String username, int age, Team team) {
        this.username = username;
        this.age = age;
        changeTeam(team);
    }
}

Team

package study.datajpa.entity;

import lombok.*;

import javax.persistence.*;
import java.util.*;

@Entity
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@ToString(of = {"id", "name"})
public class Team {
    @Id @GeneratedValue
    @Column(name = "team_id")
    private Long id;
    private String name;

    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();

    public Team(String name){
        this.name = name;
    }
}

위의 Entity에 해당하는 Repository의 CRUD 기능을 JPA를 통해 만들어 보도록 하겠습니다.

MemberJpaRepository

package study.datajpa.repository;

import org.springframework.stereotype.Repository;
import study.datajpa.entity.Member;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.*;

@Repository
public class MemberJpaRepository {
    @PersistenceContext //스프링 컨테이너가 엔티티 매니저를 가져다 줌
    private EntityManager em;

    public Member save(Member member){
        em.persist(member);
        return member;
    }

    public void delete(Member member){
        em.remove(member);
    }

    public List<Member> findAll() {
        //JPQL
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
    }

    public Optional<Member> findById(Long id){
        Member member = em.find(Member.class, id);
        return Optional.ofNullable(member);
    }

    public long count() {
        return em.createQuery("select count(m) from Member m", Long.class)
                .getSingleResult();
    }

    public Member find(Long id){
        return em.find(Member.class ,id);
    }
}

TeamJpaRepository

package study.datajpa.repository;

import org.springframework.stereotype.Repository;
import study.datajpa.entity.Member;
import study.datajpa.entity.Team;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.*;

@Repository
public class TeamJpaRepository {
    @PersistenceContext
    private EntityManager em;

    public Team save(Team team){
        em.persist(team);
        return team;
    }

    public void delete(Team team){
        em.remove(team);
    }

    public List<Team> findAll() {
        return em.createQuery("select t from Team t", Team.class)
                .getResultList();
    }

    public Optional<Team> findById(Long id){
        Team team = em.find(Team.class, id);
        return Optional.ofNullable(team);
    }

    public long count() {
        return em.createQuery("select count(t) from Team t", Long.class)
                .getSingleResult();
    }

    public Team find(Long id){
        return em.find(Team.class ,id);
    }
}

Team과 Member에 대한 CRUD 기능을 갖춘 Repository를 만들었습니다. 위의 코드를 직접 쳐보시면 기본적인 CRUD 같은경우 클래스명과 관련된 것을 제외하고는 같은 코드인 것을 볼 수 있습니다. 즉, 반복적인 코드가 엔티티마다 발생하게 됩니다. 미리 결론부터 말하자면 이런 반복적인 코드를 줄여주는 기능을 하는 것이 바로 Spring Data JPA입니다.

공통 인터페이스 설정

Srping Data JPA가 제공하는 공통 인터페이스 기능을 쓰기 위한 준비 단계로 공통 인터페이스를 어떻게 설정하는 지 알아보자.

이전 JpaRepository를 상속받는 Spring Data JPA를 사용해 본 적이 있다. 해당 클래스는 interface이고 구현체가 없지만 기능이 정상적으로 작동한다. 이유는 무엇일까? 

실제 @Autowired한 Spring Data JPA를 사용한 interface를 출력해보면 아래와 같이 뜬다. interface에 Spring Data JPA가 구현클래스를 만들어서 대입했다고 보면 좋을 것 같다.

그렇기 때문에 구현체를 Spring Data JPA가 만들어서 injection을 해준 것이다.

그림으로 봐보자

Spring Data JPA가 애플리케이션 로딩 시점에 Spring Data JPA와 관련된 interface를 가지고 있으면 구현 클래스를 내부에서 만들어 냅니다. 즉, 애플리케이션 로딩 시점에 Spring Data JPA와 관련된 구현 클래스를 만들고 필요할 때 내부에서 injection을 해주는 것 입니다. 

참고로 Spring Data JPA를 상속받은 interface는 @Repository를 하지 않아도 됩니다. 

공통 인터페이스 분석

공통 인터페이스 구성

• getOne(ID)
  • 엔티티를 프록시로 조회하는 기능. 레퍼런스를 가져올 때 쿼리문이 나가지 않고, 실제 엔티티에 접근할 때 쿼리문이 나간다.
  • Lazy.Loading을 생각하면 될 것 같다.
• findAll(...)
  • 모든 엔티티를 조회한다. 정렬('Sort') 이나 페이징('Pageable') 조건을 파라미터로 제공할 수 있다.

출처

기본 Member Entity와 Repository를 만들어 보았습니다.

Member

package study.datajpa.entity;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
@Getter
@Setter
public class Member {
    @Id
    @GeneratedValue
    private Long id;
    private String username;

}

MemberJpaRepository

package study.datajpa.repository;

import org.springframework.stereotype.Repository;
import study.datajpa.entity.Member;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Repository
public class MemberJpaRepository {
    @PersistenceContext //스프링 컨테이너가 엔티티 매니저를 가져다 줌
    private EntityManager em;

    public Member save(Member member){
        em.persist(member);
        return member;
    }

    public Member find(Long id){
        return em.find(Member.class ,id);
    }
}

이전에 배웠던 JPA 강의에서 배웠던 기본 insert, select(1) 하는 쿼리문이 발생하게하는 메소드입니다. 이를 스프링 데이터 JPA를 통해 더 간단하게 구현하면서 더 많은 기능을 제공받을 수 있습니다.

MemberRepository (Spring Data JPA)

package study.datajpa.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import study.datajpa.entity.Member;

public interface MemberRepository extends JpaRepository<Member, Long> {
}

interface 이지만 테스트에서 돌려보면 findById, findAll, save 등 모든 기본적인 CRUD 기능이 정상적으로 작동하는 것을 확인할 수 있습니다. 

이러한 기능을 어떻게 제공하는 것인지, 어떻게 해야 잘 사용할 수 있을지 알아봅시다!

출처

OSIV와 성능 최적화

• Open Session In View : 하이버네이트
• Open EntityManager In View : JPA (관례상 OSIV라고 한다.)

OSIV ON

• spring.jpa.open-in-view : true 기본 값

스프링 부트 프로젝트를 실행하면 아래와 같은 WARNING이 하나 뜰 것 입니다.

읽어보면 open-in-view와 관련된 경고문인 것을 확인할 수 있습니다. 기본값을 뿌리면서 애플리케이션 시작 시점에 waning로그를 남기는 것은 이유가 있습니다. OSIV 전략은 트랜잭션 시작처럼 최소 데이터베이스 커넥션 시작 시점부터 API 응답이 끝날 때(Html 랜더링이 전부 다 안료하고, 더이상 DB가 필요없을  때) 까지 영속성 컨텍스트와 데이터베이스 커넥션을 유지합니다. 그래서 지금까지 View Template나 API 컨트롤러에서 지연 로딩이 가능했던 것입니다. 

지연 로딩은  영속성 컨텍스트가 살아있어야 가능하고, 영속성 컨텍스트는 기본적으로 데이터베이스 커넥션을 유지한다. 이것 자체가 큰 장점이다!!

그런데 이 전략은 너무 오랜시간동안 데이터베이스 커넥션 리소스를 사용하기 때문에, 실시간 트래픽이 중요한 애플리케이션에서는 커넥션이 모자를 수 있다. 이것은 결국 장애로 이어진다. (치명적)

예를들어, 컨트롤러에서 외부 API를 호출하면 외부 API 대기 시간만큼 커넥션 리소스를 반환하지 못하고, 유지해야 한다. (외부 API DB가 blocking된 경우 매우 치명적일 수 있다.)

OSIV OFF

• spring.jpa.open-in-view : false (OSIV 종료)

OSIV를 끄면 트랜잭션을 종료할 때 영속성 컨텍스트를 닫고, 데이터베이스 커넥션도 반환한다. 따라서 커넥션 리소스를 낭비하지 않는다. 

OSIV를 끄면 모든 지연로딩을 트랜잭션 안에서 처리해야 한다. 따라서 지금까지 작성한 많은 지연 로딩 코드를 트랜잭션 안으로 넣어야 하는 단점이 있다. 그리고 view template에서 지연 로딩이 동작하지 않는다. 결론적으로 트랜잭션이 끝나기 전에 지연 로딩을 강제로 호출해 두어야 한다.

우리가 지금까지 작성했던 코드들은 Controller에서 지연로딩 하는 코드들도 많이 있습니다. 만약 OSIV를 종료한다면, 에러가 발생할 것입니다. 이유는 Controller에서 영속성 컨텍스트가 생존하고 있지않기 때문입니다. 그렇기때문에 OSIV를 false로 두는 경우는 지연 로딩 코드들을 모두 Transaction안에서 처리하기 위해 Service나 Respository 계층에서 사용해야 합니다. 예) fetch join

커맨드와 쿼리 분리

실무에서 OSIV를 끈 상태로 복잡성을 관리하는 좋은 방법이 있다. 바로 Command와 Query를 분리하는 것이다.

참고

참고
김영한님은 고객 서비스의 실시간 API는 OSIV를 끄고, ADMIN 처럼 커넥션을 많이 사용하지 않는 곳에서는 OSIV를 킨다고 합니다.

참고
OSIV에 관해 더 깊이 알고 싶으면 자바 ORM 표준 JPA 프로그래밍 13장 웹 애플리케이션과 영속성 관리를 참고하자!

출처

주문 조회 V1 : 엔티티 직접 노출

OrderApiController 생성

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.OrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    private final OrderService orderService;

    @GetMapping("/api/v1/orders")
    public List<Order> ordersV1() {
        List<Order> orders = orderService.findOrders(new OrderSearch());
        for (Order order : orders) {
            order.getMember().getName();            // 강제 초기화   
            order.getDelivery().getAddress();          // 강제 초기화
            List<OrderItem> orderItems = order.getOrderItems();
            for (OrderItem orderItem : orderItems) {
                orderItem.getItem().getName();          // 강제 초기화
            }
        }
        return orders;
    }

}

테스트

모든 데이터를 가져온 것을 볼 수 있습니다.

주문 조회 V2 : 엔티티를 DTO로 변환

OrderApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.OrderService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    
    ...

    @GetMapping("/api/v2/orders")
    public List<OrderDto> ordersV2() {
        List<Order> orders = orderService.findOrders(new OrderSearch());
        List<OrderDto> result = orders.stream()
                .map(o -> new OrderDto(o))
                .collect(Collectors.toList());

        return result;
    }

    @Data
    static class OrderDto{
        private Long orderId;
        private String name;
        private LocalDateTime orderDate;
        private OrderStatus orderStatus;
        private Address address;
        private List<OrderItem> orderItems;

        public OrderDto(Order order) {
            orderId = order.getId();
            name = order.getMember().getName();
            orderDate = order.getOrderDate();
            orderStatus = order.getStatus();
            address = order.getMember().getAddress();
            order.getOrderItems().stream().forEach(o -> o.getItem().getName());
            orderItems = order.getOrderItems();
        }
    }
}

테스트

엔티티를 사용하지않고 DTO를 만들어 반환해주었습니다. 하지만, DTO안 필드를 보시면 엔티티로 만들어진 컬렉션이 있습니다.

private List<OrderItem> orderItems;

이렇게 되면 OrderItem의 스펙이 외부로 모두 노출되고 있습니다. 모든 엔티티의 의존을 끊어야합니다. OrderDto 내의 OrderItem도 DTO로 변환해줍시다.

OrderApiController 코드 변경

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.OrderService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    
    ...

    @Data
    static class OrderDto{
        private Long orderId;
        private String name;
        private LocalDateTime orderDate;
        private OrderStatus orderStatus;
        private Address address;
        private List<OrderItemDto> orderItems;

        public OrderDto(Order order) {
            orderId = order.getId();
            name = order.getMember().getName();
            orderDate = order.getOrderDate();
            orderStatus = order.getStatus();
            address = order.getMember().getAddress();
            orderItems = order.getOrderItems().stream()
                    .map(orderItem -> new OrderItemDto(orderItem))
                    .collect(Collectors.toList());
        }
    }

    @Data
    static class OrderItemDto {

        private String itemName;
        private int orderPrice;
        private int count;

        public OrderItemDto(OrderItem orderItem){
            itemName = orderItem.getItem().getName();
            orderPrice = orderItem.getOrderPirce();
            count = orderItem.getItem().getPrice();
        }
    }
}

테스트

위처럼 DTO로 감싸서 필요한 데이터만 JSON에 나올수 있도록 했습니다.

코드 최적화

    //전
    @GetMapping("/api/v2/orders")
    public List<OrderDto> ordersV2() {
        List<Order> orders = orderService.findOrders(new OrderSearch());
        List<OrderDto> result = orders.stream()
                .map(o -> new OrderDto(o))
                .collect(Collectors.toList());

        return result;
    }

    //후
    @GetMapping("/api/v2/orders")
    public List<OrderDto> ordersV2() {
        return orderService.findOrders(new OrderSearch()).stream()
                .map(OrderDto::new)
                .collect(toList());
    }

람다와 import를 이용해서 조금 더 코드를 깔끔하게 변경할 수 있습니다.

테스트를 해보면 쿼리문이 생각만큼 혹은 생각보다 많이 나가는 걸 확인할 수 있을 겁니다. 더 최적화를 하기위해 이전에 써보았던 fetch join을 적용해봅시다



주문 조회 V3 : 엔티티를 DTO로 변환 - 페치 조인 최적화

OrderApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.OrderService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.*;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    ...

    @GetMapping("/api/v3/orders")
    public List<OrderDto> ordersV3() {
        return orderService.findAllWithMemberDeliveryItem().stream()
                .map(OrderDto::new)
                .collect(toList());
    }

    ...
}

OrderRepository 코드 추가

package jpabook.jpashop.repository;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import java.util.*;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.*;

@Repository
@RequiredArgsConstructor
public class OrderRepository {

	...

    public List<Order> findAllWithMemberDeliveryItem(){
        return em.createQuery("select o from Order o" +
                        " join fetch o.member m" +
                        " join fetch o.delivery d" +
                        " join fetch o.orderItems oi" +
                        " join fetch oi.item i", Order.class)
                .getResultList();
    }
}

OrderService 추가 코드는 Repository 메소드만 return하기때문에 추가하지 않았습니다.

테스트

조인을 잘 아시는분들은 2개의 order와 4개의 아이템을 join하면 4개의 컬럼이 나온다는 것을 알 수 있을 겁니다. 여기서 문제는 데이터가 뻥튀기가 된다는 것 입니다. (뻥튀기란 중복된 데이터인 필요하지 않은 데이터가 여러개가 생긴다는 것 입니다.) 지금은 1개씩 뻥튀기 됐지만, 이런 엔티티가 많이 연관되어 있을 경우 몇개가 뻥튀기가 될지 알 수 없을 것 입니다.

Order의 참조값을 확인해보면 같은 참조값이 2번씩 나오는 걸 확인할 수 있습니다. 해당 문제는 distinct를 썼던 걸 기억했다면 해결할 수 있습니다. 실제로 dinstinct를 써보면 중복된 데이터가 사라지는 걸 확인할 수 있습니다. 여기서 데이터가 사라지는 이유는 JPA에서 distinct가 있고, 갖고온 데이터가 같은 id 값이면 제거해주는 기능을 했기때문에 postman에서는 중복된 데이터가 사라지는 것 입니다. 

DB는 확인해보면 여전히 컬럼이 4개 있습니다. (참고로, DB에서 distinct는 모든 데이터가 같아야 합니다.)

해당 방법은 어마어마한 단점이 있습니다. 바로, 페이징이 불가능하다는 점 입니다. (DB는 중복된 데이터가 그대로있지만, 애플리케이션에서 중복을 제거해주었기때문에 제대로된 페이징을 할 수 없기 때문입니다.) (이전 distinct 설명에서도 말했듯 중요하기때문에 이해합시다!)

참고
컬렉션 페치 조인을 사용하면 페이징이 불가능하다. 하이버네이트는 경고 로그를 남기면서 모든 데이터를 DB에서 읽어오고, 메모리에서 페이징 해버린다. (매우 위험하다) 자세한 내용은 자바 ORM 표준 JPA 프로그래밍의 페치 조인 부분을 참고.

참고
컬렉션 페치 조인은 1개만 사용할 수 있다. 컬렉션 둘 이상에 페치 조인을 사용하면 안된다. 데이터가 부정합하게 조회될 수 있다. 자세한 내용은 자바 ORM 표준 JPA 프로그래밍 참고.

주문 조회 V3.1 : 엔티티를 DTO로 변환 - 페이징과 한계 돌파

페이징과 한계 돌파

• 컬렉션을 페치 조인하면 페이징이 불가능하다.
  • 컬렉션을 페치 조인하면 일대다 조인이 발생하므로 데이터가 예측할 수 없이 증가한다.
  • 일대다에서 일(1)을 기준으로 페이징을 하는 것이 목적이다. 하지만, 데이터는 다(N)를 기준으로 row가 생성된다.
  • Order를 기준으로 페이징하고 싶은데, 다(N)인 OrderItem을 조인하면 OrderItem이 기준이 되어버린다.
• 이 경우 하이버네이트는 경고 로그를 남기고 모든 DB 데이터를 읽어서 메모리에서 페이징을 시도한다. 최악의 경우 장애로 이어질 수 있다.

한계 돌파

그렇다면 페이징 + 컬렉션 엔티티를 함께 조회하려면 어떻게 해야 될까?
지금부터 코드도 단순하고, 성능 최적화도 보장하는 매우 강력한 방법을 소개하겠다. 대부분의 페이징 + 컬렉션 엔티티 조회 문제는 해당 방법으로 해결할 수 있다. 

• 먼저 ToOne(OneToOne, ManyToOne) 관계를 모두 페치 조인 한다. ToOne 관계는 row수를 증가시키지 않으므로 페이징 쿼리에 영향을 주지 않는다.
• 컬렉션은 지연 로딩으로 조회한다.
• 지연 로딩 성능 최적화를 위해 hibernate.default_batch_fetch_size, @Batch를 사용한.
  • hibernate.default_batch_fetch_size : 글로벌 설정
  • @BatchSize : 개별 최적화
  • 이 옵션을 사용하면 컬렉션이나, 프록시 객체를 한꺼번에 설정한 size만큼 IN 쿼리로 조회한다.

application.yml에 hibernate 하위에 아래 설정을 추가해줍니다.

default_batch_fetch_size: 100

후 findAllWithMemberDelivery를 조회한 후 orderItem을 지연로딩으로 해주면 100개의 데이터를 한번에 갖고 옵니다.

• 장점
  • 쿼리 호출 수가 1+N -> 1+1로 최적화 됩니다. (데이터가 많은 경우에는 더 많이 나가긴합니다.)
  • 조인보다 DB 데이터 전송량이 최적화된다. (Order와 OrderItem을 조인하면 Order가 OrderItem 만큼 중복해서 조회된다. 해당 방법은 각각 조회하므로 전송해야할 중복 데이터가 없다.)
  • 페치 조인 방식과 비교해서 쿼리 호출 수가 약간 증가하지만, DB 데이터 전송량이 감소한다.
  • 컬렉션 페치 조인은 페이징이 불가능 하지만 해당 방법은 페이징이 가능하다.
• 결론
  • ToOne 관계는 페치 조인해도 페이징에 영향을 주지 않는다. 따라서, ToOne관계는 페치조인으로 쿼리 수를 줄이고 해결하고, 나머지는 batch_fetch_size로 최적화하자.

참고
default_batch_fetch_size의 크기는 적당한 사이즈를 골라야 하는데, 100~1000 사이를 선택하는 것을 권장한다. 이 전략을 SQL IN 절을 사용하는데, 데이터 베이스에 따라 IN 절 파라미터를 1000으로 제한하기도 한다. 1000으로 잡으면 한번에 1000개를 DB에서 애플리케이션에 불러오므로 DB에 순간 부하가 증가할 수 있다. 하지만 애플리케이션은 100이든 1000이든 결국 전체 데이터를 로딩해야하므로 메모리 사용량이 같다. 1000으로 설정하는 것이 성능상 가장 좋지만, 결국 DB든 애플리케이션이든 순간 부하를 어디까지 견딜 수 있는지로 결정하면 된다.

ToOne 먼저 받고 페이징 후 지연로딩 전략 코드

OrderApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.OrderService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.*;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
    
    ...

    @GetMapping("/api/v3.1/orders")
    public List<OrderDto> ordersV3_page(
            @RequestParam(value = "offset", defaultValue = "0") int offset,
            @RequestParam(value = "limit", defaultValue = "100") int limit) {
        return orderService.findAllWithMemberDelivery(offset, limit).stream()
                .map(OrderDto::new)
                .collect(toList());
    }

	...
}

OrderRepository 코드 추가

package jpabook.jpashop.repository;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import java.util.*;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.*;

@Repository
@RequiredArgsConstructor
public class OrderRepository {

    ...

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

    ..
}

위와 같이 ToOne에서 페이징을 한 뒤, ToMany의 경우 지연 로딩으로 batch_size를 정해 가져오는 방법을 사용하면 된다.

주문 조회 V4 : JPA에서 DTO 직접 조회

OrderApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.repository.order.query.OrderQueryDto;
import jpabook.jpashop.service.OrderService;
import jpabook.jpashop.service.order.query.OrderQueryService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.*;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
	...
    private final OrderQueryService orderQueryService;

    ...

    @GetMapping("/api/v4/orders")
    public List<OrderQueryDto> ordersV4() {
        return orderQueryService.findOrderQueryDtos();
    }

    ...
}

repository.order.query 패키지 생성 후 OrderQueryDto 생성

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;
import java.util.*;

import java.time.LocalDateTime;

@Data
public class OrderQueryDto {
    private Long orderId;
    private String name;
    private LocalDateTime orderDate;
    private OrderStatus orderStatus;
    private Address address;
    private List<OrderItemQueryDto> orderitems;

    public OrderQueryDto(Long orderId, String name, LocalDateTime orderDate, OrderStatus orderStatus, Address address){
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
    }
}

OrderItemQueryDto 생성

package jpabook.jpashop.repository.order.query;

import lombok.Data;

@Data
public class OrderItemQueryDto {

    private Long orderId;
    private String itemName;
    private int orderPrice;
    private int count;

    public OrderItemQueryDto(Long orderId, String itemName, int orderPrice, int count) {
        this.orderId = orderId;
        this.itemName = itemName;
        this.orderPrice = orderPrice;
        this.count = count;
    }
}

OrderQueryRepository 생성

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.OrderItem;
import lombok.RequiredArgsConstructor;
import java.util.*;
import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    private final EntityManager em;

    /**
     * join해서 갖고온 데이터에 ToMany 데이터를 Dto 로 갖고온다.
     */
    public List<OrderQueryDto> findOrderQueryDtos() {
        List<OrderQueryDto> result = findOrderQueryDto();

        result.forEach(o -> {
            List<OrderItemQueryDto> orderItems = findOrderItems(o.getOrderId());
            o.setOrderitems(orderItems);
        });

        return result;
    }

    /**
     * OrderItemQueryDto.orderItems 필드 값 채우는 메소드
     */
    private List<OrderItemQueryDto> findOrderItems(Long orderId) {
        return em.createQuery(
                "select new jpabook.jpashop.repository.order.query.OrderItemQueryDto(oi.order.id, oi.item.name, oi.orderPirce, oi.count)" +
                        " from OrderItem oi" +
                        " join oi.item i" +
                        " where oi.order.id = :orderId", OrderItemQueryDto.class)
                .setParameter("orderId", orderId)
                .getResultList();
    }

    /**
     * dto로 직접 조회 (ToMany는 따로 담아줘야하기 때문에 ToMany빼고 join해서 한번에 데이터를 갖고온다.)
     */
    public List<OrderQueryDto> findOrderQueryDto() {
        return em.createQuery(
                "select new jpabook.jpashop.repository.order.query.OrderQueryDto(o.id, o.member.name, o.orderDate, o.status, o.delivery.address)" +
                        " from Order o" +
                " join o.member m" +
                " join o.delivery d", OrderQueryDto.class)
                .getResultList();
    }
}

service.order.query 패키지 생성 후 OrderQueryService 생성

package jpabook.jpashop.service.order.query;

import jpabook.jpashop.repository.order.query.OrderQueryDto;
import jpabook.jpashop.repository.order.query.OrderQueryRepository;
import jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class OrderQueryService {
    private final OrderQueryRepository orderQueryRepository;

    public List<OrderQueryDto> findOrderQueryDtos() {
        return orderQueryRepository.findOrderQueryDtos();
    }
}

Controller -> Repository 바로 접근해도 상관없지만, 후에 리팩토링할 때 Service를 하나 두는게 더 좋아보여서 Service를 만들어 주었다.

• Query 루트 1번, 컬렉션 N번 실행
• ToOne(N:1, 1:1) 관계들은 join을 통해 한번의 쿼리로 조회하고, ToMany(1:N) 관계는 각각 별도로 처리했습니다.
  • 이런 방식을 선택한 이유
    1. ToOne 관계는 조인해도 데이터 row 수가 증가하지 않는다.
    2. ToMany 관계는 조인하면 row 수가 증가한다.
• 즉, row 수가 증가하지 않는 ToOne 관계는 조인으로 최적화 하기 쉬우므로 한 번에 조회하고, ToMany 관계는 최적화 하기 어려우므로 별도의 메소드를 통해 조회했다.

주문 조회 V5 : JPA에서 DTO 직접 조회 - 컬렉션 조회 최적화

V4을 실행해서 확인해보면 order 수에 따라서 추가 쿼리가 N개만큼 나가는 것을 확인할 수 있습니다. 이 또한 최적화 시킬 수 있다고합니다. (일명 컬렉션 조회 최적화!)

OrderQueryRepository 코드 추가

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.OrderItem;
import lombok.RequiredArgsConstructor;
import java.util.*;
import java.util.stream.Collectors;

import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    ...

    /**
     * Order 수에 따른 N번에 추가 쿼리를 1번의 쿼리문으로
     */
    public List<OrderQueryDto> findAllByDto_optimization() {
        List<OrderQueryDto> result = findOrderQueryDto();

        List<Long> ordersIds = result.stream()
                .map(o -> o.getOrderId())
                .collect(Collectors.toList());

        List<OrderItemQueryDto> orderItems = em.createQuery(
                        "select new jpabook.jpashop.repository.order.query.OrderItemQueryDto(oi.order.id, oi.item.name, oi.orderPirce, oi.count)" +
                                " from OrderItem oi" +
                                " join oi.item i" +
                                " where oi.order.id in :orderIds", OrderItemQueryDto.class)
                .setParameter("orderIds", ordersIds)
                .getResultList();

        Map<Long, List<OrderItemQueryDto>> orderItempMap = orderItems.stream()
                .collect(Collectors.groupingBy(OrderItemQueryDto -> OrderItemQueryDto.getOrderId()));

        result.forEach(o -> o.setOrderitems(orderItempMap.get(o.getOrderId())));

        return result;
    }
}

해당 result를 받는 Service와 Controller에 코드 추가만 해주면 작동합니다. 실제로  N번의 쿼리문이 1번의 쿼리문으로 바뀐걸 확인할 수 있습니다.

위의 하나의 메소드를 아래와 같이 commant+option+m을 이용해 리팩토링 해주었습니다.

    /**
     * Order 수에 따른 N번에 추가 쿼리를 1번의 쿼리문으로
     */
    public List<OrderQueryDto> findAllByDto_optimization() {
        List<OrderQueryDto> result = findOrderQueryDto();

        Map<Long, List<OrderItemQueryDto>> orderItempMap = findOrderItemMap(toOrderIds(result));

        result.forEach(o -> o.setOrderitems(orderItempMap.get(o.getOrderId())));

        return result;
    }

    private Map<Long, List<OrderItemQueryDto>> findOrderItemMap(List<Long> ordersIds) {
        List<OrderItemQueryDto> orderItems = em.createQuery(
                        "select new jpabook.jpashop.repository.order.query.OrderItemQueryDto(oi.order.id, oi.item.name, oi.orderPirce, oi.count)" +
                                " from OrderItem oi" +
                                " join oi.item i" +
                                " where oi.order.id in :orderIds", OrderItemQueryDto.class)
                .setParameter("orderIds", ordersIds)
                .getResultList();

        Map<Long, List<OrderItemQueryDto>> orderItempMap = orderItems.stream()
                .collect(Collectors.groupingBy(OrderItemQueryDto -> OrderItemQueryDto.getOrderId()));
        return orderItempMap;
    }

    private List<Long> toOrderIds(List<OrderQueryDto> result) {
        List<Long> ordersIds = result.stream()
                .map(o -> o.getOrderId())
                .collect(Collectors.toList());
        return ordersIds;
    }

• Query 루트 1번, 컬렉션 1번
• ToOne 관계들을 먼저 조회하고, 여기서 얻은 식별자 orderId로 ToMany 관계인 OrderItem을 한꺼번에 조회
• Map을 사용해서 매칭 성능 향상(O(1))



주문 조회 V6 : JPA에서 DTO로 직접 조회, 플랫 데이터 최적화

OrderQueryRepository 코드 추가

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.OrderItem;
import lombok.RequiredArgsConstructor;
import java.util.*;
import java.util.stream.Collectors;

import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {

    ...
    
    /**
     * 단 한번의 쿼리문으로 컬렉션까지 조회
     */
    public List<OrderFlatDto> findAllByDto_flat() {
        return em.createQuery(
                "select new" +
                        " jpabook.jpashop.repository.order.query.OrderFlatDto(o.id, m.name, o.orderDate, o.status, d.address, i.name, oi.orderPirce, oi.count)" +
                        " from Order o" +
                        " join o.member m" +
                        " join o.delivery d" +
                        " join o.orderItems oi" +
                        " join oi.item i", OrderFlatDto.class)
                .getResultList();
    }
}

해당 result를 받는 Service와 Controller에 코드 추가만 해주면 작동합니다. 실제로 1번의 쿼리문으로 모든 데이터를 갖고오는 것을 볼 수 있습니다. 페이징도 가능합니다. 하지만, OrderId를 기준으로 페이징을 하고싶은 경우에는 페이징이 불가능합니다. 

orderid 기준으로 페이징이 불가능한 이유는 아래 get 요청에 나온 응답을 보시면 쉽게 알 수 있습니다. orderId 기준으로 index가 증가하는 것이아닌 orderItem 기준으로 Index가 증가하기 때문입니다.

위를 보시면 orderId, member name, address 등 중복된 결과가 많습니다. 이렇게 중복된 결과를 지워낼 수 있는 코드는 아래와 같습니다.

중복된 데이터 제거 방법

OrderApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.repository.order.query.OrderFlatDto;
import jpabook.jpashop.repository.order.query.OrderItemQueryDto;
import jpabook.jpashop.repository.order.query.OrderQueryDto;
import jpabook.jpashop.service.OrderService;
import jpabook.jpashop.service.order.query.OrderQueryService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.*;

@RestController
@RequiredArgsConstructor
public class OrderApiController {
	
    ...

    @GetMapping("/api/v7/orders")
    public List<OrderQueryDto> ordersV7() {
        List<OrderFlatDto> flats = orderQueryService.findAllByDto_flat();
        return flats.stream()
                .collect(groupingBy(o -> new OrderQueryDto(o.getOrderId(),
                                o.getName(), o.getOrderDate(), o.getOrderStatus(), o.getAddress()),
                        mapping(o -> new OrderItemQueryDto(o.getOrderId(),
                                o.getItemName(), o.getOrderPrice(), o.getCount()), toList())
                )).entrySet().stream()
                .map(e -> new OrderQueryDto(e.getKey().getOrderId(),
                        e.getKey().getName(), e.getKey().getOrderDate(), e.getKey().getOrderStatus(), e.getKey().getAddress(), e.getValue()))
                .collect(toList());
    }

    ...
}

중복된 데이터를 분해하고 조립하는 코드입니다. (후에 이해가 필요하면 하기위해 적어둠!)

OrderQueryDto 추가

package jpabook.jpashop.repository.order.query;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.util.*;

import java.time.LocalDateTime;

@Data
@EqualsAndHashCode(of = "orderId")	// orderId 를 기준으로 groupingBy
public class OrderQueryDto {
    
    ...

    public OrderQueryDto(Long orderId, String name, LocalDateTime orderDate,
                        OrderStatus orderStatus, Address address, List<OrderItemQueryDto> orderItems) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
        this.orderitems = orderItems;
    }

}

• Query 1번
• 단점
  • 쿼리는 1번이지만 조인으로 인해 DB에서 애플리케이션에 전달하는 데이터에 중복 데이터가 추가되므로 상황에 따라 V5 보다 더 느릴 수 있다.
  • 애플리케이션에 추가 작업이 크다.
  • 페이징 불가능 (orderItem 기준으로는 페이징 가능)

컬렉션 조회 최적화 정리

• 엔티티 조회
  • 엔티티를 조회해서 그대로 반환 : V1
  • 엔티티 조회 후 DTO로 반환 : V2
  • 페치 조인으로 쿼리 수 최적화 : V3
  • 컬렉션 페이징과 한계 돌파 : V3.1
    • 컬렉션은 페치 조인 시 페이징이 불가능
    • ToOne 관계는 페치 조인으로 쿼리 수 최적화
    • 컬렉션은 페치 조인 대신에 지연 로딩을 유지하고, hibernate.deault_batch_fetch_size, @BatchSize로 최적화
• DTO 직접 조회
  • JPA에서 DTO를 직접 조회 : V4
  • 컬렉션 조회 최적화 - 일대다 관계인 컬렉션은 IN 절을 활용해서 메모리에 미리 조회해서 최적화 : V5
  • 플랫 데이터 최적화 - JOIN 결과를 그대로 조회 후 애플리케이션에서 원하는 모양으로 직접 변환 : V6

권장 순서

1. 엔티티 조회 방식으로 우선 접근
   1. 페치 조인으로 쿼리 수를 최적화
   2. 컬렉션 최적화
      1. 페이징 필요 - hibernate.deault_batch_fetch_size, @BatchSize로 최적화
      2. 페이징 필요 X -> 페치 조인 사용
2. 엔티티 조회 방식으로 해결이 안되면 DTO 조회 방식 사용
3. DTO 조회 방식으로 해결이 안되면 NativeSQL or 스프링 JdbcTemplate

참고
엔티티 조회 방식은 페치 조인이나, hibernate.default_batch_fetch_size, @BatchSize 같이 코드를 거의 수정하지 않고, 옵션만 약간 병경해서, 다양한 성능 최적화를 시도할 수 있다. 반면에 DTO를 직접 조회하는 방식은 성능을 최적화 하거나 성능 최적화 방식을 변경할 때 많은 코드를 변경해야 한다.

캐시를 사용하는 경우 Entity를 캐시하지않고 Entity -> Dto로 바꾸고 Dto를 캐시해야 한다.

참고
개발자는 성능 최적화와 코드 복잡도 사이에서 줄타기를 해야한다. 하상 그런 것은 아니지만, 보통 성능 최적화는 단순한 코드를 복잡한 코드로 몰고간다.
엔티티 조회 방식은 JPA가 많은 부분을 최적화 해주기 때문에, 단순한 코드를 유지하면서, 성능을 최적화 할 수 있다.
반면 DTO 조회 방식은 SQL을 직접 다루는 것과 유사하기 때문에, 둘 사이에 줄타기를 해야 한다.

DTO 조회 방식의 선택지

• DTO로 조회하는 방법도 각각 장단이 있다. V4, V5, V6에서 단순하게 쿼리가 1번 실행된다고 V6가 항상 좋은 방법인 것은 아니다.
• V4는 코드가 단순하다. 특정 주문 한건만 조회하면 이 방식을 사용해도 성능이 잘 나온다. 예를 들어서 조회한 Order 데이터가 1건이면 OrderItem을 찾기 위한 쿼리도 1번만 실행하면 된다.
• V5는 코드가 복잡하다. 여러 주문을 한꺼번에 조회하는 경우에는 V4 대신에 이것을 최적화한 V5 방식을 사용해야 한다. 예를 들어서 조회한 Order 데이터가 1000건인데, V4 방식을 그대로 사용하면, 쿼리가 총 1+1000번 실행된다. 여기서 1은 Order를 조회한 쿼리고, 1000은 조회된 Order의 row 수다. 하지만, V5 방식으로 최적화 하면 쿼리가 총 1+1 번만 실행된다. 상황에 따라 다르겟지만 운영 환경에서 100배 이상의 성능 차이가 날 수 있다.
• V6는 완전히 다른 접근 방식이다. 쿼리 한번으로 최적화 되어서 상당히 좋아보이지만, Order를 기준으로 페이징이 불가능하다. 실무에서는 이정도 데이터면 수백이나 ,수천건의 단위로 페이징 처리가 꼭 필요하므로, 이 경우 선택하기 어려운 방법이다. 그리고 데이터가 많으면 중복 전송이 증가해서 V5와 비교해서 성능 차이도 미비하다.

출처

package jpabook.jpashop.service;

import jpabook.jpashop.domain.Delivery;
import jpabook.jpashop.domain.Item.Item;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.repository.*;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class OrderService {

    ...
    public List<OrderSimpleQueryDto> findOrderDtos() {
        return orderRepository.findOrderDtos();
    }
}

주문 + 배송정보 + 회원을 조회하는 API 구현.

지연 로딩 때문에 발생하는 성능 문제를 단계적으로 해결해봅니다.

참고

실무에서 JPA를 사용하려면 100% 이해해야 할 정도로 중요한 내용입니다. 시간을 날리고 싶지않다면 제대로 이해하라고 하십니다. (정신차리자)

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

api.OrderSimpleApiController 생성

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Order;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.MemberService;
import jpabook.jpashop.service.OrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;

/**
 * XToOne (ManyToOne, OneToOne) 에서의 성능 최적화
 * Order
 * Order -> Member
 * Order -> Delivery
 */
@RestController
@RequiredArgsConstructor
public class OrderSimpleApiController {

    private final OrderService orderService;
    private final MemberService memberService;

    @GetMapping("/api/v1/simple-orders")
    public List<Order> ordersV1() {
        List<Order> orders = orderService.findOrders(new OrderSearch());
        return orders;
    }
}

현재 주문 내역을 조회하는 api를 생성했습니다. 돌려보면 결과가 어떨까요?? 감이 온다면 좋겠지만 전 감이 오지 않았습니다... 결론은 무한루프에 빠지게 됩니다. Member -> Order (ManyToOne)이고 Order -> Member (OneToMany)로 계속 무한루프에 빠지게 되는 것 입니다.

테스트

Entity를 직접 노출시키는 프로젝트라면, 해결책은 JsonIgnore를 해줘야 합니다.

Order와 연관된 엔티티에서 다시 Order로 오는 필드를 JsonIgnore한 뒤 돌려보면

500 에러와 함께 org.hibernate.proxy.pojo.bytebuddy.ByteBuddyInterceptor란 에러가 뜹니다. ByteBuddyInterceptor 클래스는 LAZY.Loading으로 했기때문에 진짜 객체가아닌 프록시 객체를 주는데, 실제로 프록시 객체가 ByteBuddy로 되어있다고 합니다. (프록시는 김영한님 강의 중 기본편에 있는 내용인데, 아래 링크에 정리했으니 잘 모르면 보도록합시다.)

여기서 에러가 작동한 이유는 Order를 조회할 때, Member를 같이 뽑아오려고하는데 Member가 순수한 자바객체가 아닌 다른 ByteBuddy라는 라이브러리로 되어있기 때문에 발생하는 예외입니다.

해결책은 지연 로딩의 경우에 json라이브러리에게 아무런 데이터를 뽑아오지 않도록 해주면 됩니다. Hibernate5Module을 사용해서 해결해줄 수 있다고 합니다. 

build.gradle 추가 

implementation 'com.fasterxml.jackson.datatype:jackson-datatype-hibernate5'

후 Bean으로 hibernate5Module을 추가해주면 됩니다.

JpaShopApplication.java 코드 추가

package jpabook.jpashop;

import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class JpashopApplication {

	...

	@Bean
	Hibernate5Module hibernate5Module() {
		return new Hibernate5Module();
	}
}

하지만, 이전에 말했듯 엔티티에 직접 접근하는 것은 지양해야 한다고 설명했습니다. 그렇기때문에 hibernate5Module을 사용하지 않아도 됩니다..!

테스트

이제야 정상적으로 데이터를 볼 수 있게 됐습니다..!

모든 Lazy.Loading 데이터를 보고 싶다면 아래와 같이 옵션을 바꿔주면됩니다. 

	@Bean
	Hibernate5Module hibernate5Module() {
		Hibernate5Module hibernate5Module = new Hibernate5Module();
		hibernate5Module.configure(Hibernate5Module.Feature.FORCE_LAZY_LOADING, true);
		return hibernate5Module;
	}

테스트

모든 Lazy.Loading 엔티티 데이터들이 나온 것을 볼 수 있습니다. 하지만, 이렇게하는 경우 Lazy로 되어있는 필요하지 않은 Entity도 끌고오게 됩니다. (즉, 쿼리가 한번 더 나갑니다.) 그렇기 때문에 필요한 데이터만 갖고 오는 방법도 있습니다.

OrderSimpleApiController 코드 변경

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Order;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.MemberService;
import jpabook.jpashop.service.OrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;

/**
 * XToOne (ManyToOne, OneToOne) 에서의 성능 최적화
 * Order
 * Order -> Member
 * Order -> Delivery
 */
@RestController
@RequiredArgsConstructor
public class OrderSimpleApiController {

    ...

    @GetMapping("/api/v1/simple-orders")
    public List<Order> ordersV1() {
        List<Order> orders = orderService.findOrders(new OrderSearch());
        for(Order order : orders){
            // getMember까지는 프록시 객체지만, getName()을 가져오면 강제 초기화되서 데이터를 끌고 온다.
            // 이렇게 강제적으로 Entity를 가져오는 방법도 있다.
            order.getMember().getName();
            order.getDelivery().getAddress();
        }
        return orders;
    }
}

강제 초기화로 데이터를 끌고 오는 방법입니다.

테스트

설명한 이유는 이렇게 해라가 아니라 다음에 설명하는 방법이 왜 좋은지 알려주기 위한 설명입니다. 위와 같이 엔티티를 직접 노출시키지 말고 무조건 DTO로 변환합시다!

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

OrderSimpleApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.MemberService;
import jpabook.jpashop.service.OrderService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * XToOne (ManyToOne, OneToOne) 에서의 성능 최적화
 * Order
 * Order -> Member
 * Order -> Delivery
 */
@RestController
@RequiredArgsConstructor
public class OrderSimpleApiController {

    ...

    @GetMapping("/api/v2/simple-orders")
    public List<SimpleOrderDTO> ordersV2() {
        List<Order> orders = orderService.findOrders(new OrderSearch());
        List<SimpleOrderDTO> result = orders.stream()
                .map(o -> new SimpleOrderDTO(o))
                .collect(Collectors.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로 조회했습니다. DTO로 조회해도 해결되지 않는 문제 1가지가 있습니다. 쿼리가 생각보다 많이 나가기 때문입니다. Order, Member, Delivery를 주문 1개당 3개의 쿼리문을 보내서 갖고오기 때문입니다. 

        public SimpleOrderDTO(Order order){
            orderId = order.getId();
            name = order.getMember().getName();     // LAZY 초기화
            orderDate = order.getOrderDate();
            orderStatus = order.getStatus();
            address = order.getDelivery().getAddress();         // LAZY 초기화
        }

이것을 N+1 문제라고 말합니다. 말이 N+1이지 1+N이라고 해도 이상하지 않습니다. 주문(1) 당 N(2)개만큼 쿼리가 추가실행되기 때문입니다. 여기선 1(주문) + N(회원) + 배송(N)이 실행되어 총 5번의 쿼리문이 나갑니다.

간단한 주문 조회 V3 : 엔티티를 DTO로 변환 - fetch join 최적화

OrderSimpleApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.MemberService;
import jpabook.jpashop.service.OrderService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * XToOne (ManyToOne, OneToOne) 에서의 성능 최적화
 * Order
 * Order -> Member
 * Order -> Delivery
 */
@RestController
@RequiredArgsConstructor
public class OrderSimpleApiController {

    ...

    @GetMapping("/api/v3/simple-orders")
    public List<SimpleOrderDTO> ordersV3() {
        List<Order> orders = orderService.findAllWithMemberDelivery();

        List<SimpleOrderDTO> result = orders.stream()
                .map(o -> new SimpleOrderDTO(o))
                .collect(Collectors.toList());
        return result;
    }
}

테스트

fetch join을 사용하여 단 한번의 쿼리로 원하는 모든 데이터를 가져올 수 있습니다...?!! 좋네요..

fetch join으로 order->member, order->delivery를 모두 조회한 상태이기 때문에 지연로딩X

간단한 주문 조회 V4 : JPA에서 DTO로 바로 조회

OrderSimpleQueryDto 생성

package jpabook.jpashop.repository;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderStatus;
import lombok.Data;

import java.time.LocalDateTime;

@Data
public class OrderSimpleQueryDto {
    private Long orderId;
    private String name;
    private LocalDateTime orderDate;
    private OrderStatus orderStatus;
    private Address address;

    public OrderSimpleQueryDto(Long orderId, String name, LocalDateTime orderDate, OrderStatus orderStatus, Address address){
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
    }
}

OrderSimpleApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.repository.OrderSimpleQueryDto;
import jpabook.jpashop.service.MemberService;
import jpabook.jpashop.service.OrderService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * XToOne (ManyToOne, OneToOne) 에서의 성능 최적화
 * Order
 * Order -> Member
 * Order -> Delivery
 */
@RestController
@RequiredArgsConstructor
public class OrderSimpleApiController {

    ...

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

}

OrderService 코드 추가

package jpabook.jpashop.service;

import jpabook.jpashop.domain.Delivery;
import jpabook.jpashop.domain.Item.Item;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;
import jpabook.jpashop.repository.*;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class OrderService {

    ...

    public List<OrderSimpleQueryDto> findOrderDtos() {
        return orderRepository.findOrderDtos();
    }
}

OrderRepository 코드 추가

package jpabook.jpashop.repository;

import jpabook.jpashop.api.OrderSimpleApiController;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import java.util.*;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.*;

@Repository
@RequiredArgsConstructor
public class OrderRepository {

   	...

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

    }
}

쿼리 문자열을 보면 new jpabook.....하며 객체 루트를 다 적어주었습니다. 이유는 엔티티, 임베디드가 아니면 어떤 객체인지 spring에서 알지 못하기 때문입니다. OrderSimpleQueryDto의 경우 @Data로 만들었기 때문에 루트를 다 적어야합니다.

이렇게 DTO로 조회하면 아래 테스트와 같이 컬럼명이 딱 필요한 만큼 가져올 수 있습니다. 하지만, 재사용성이 zero에 가깝기때문에 상황에 맞게 V3와 V4를 잘 조율해가며 사용해야 합니다.

테스트

이전 V3에서 생성된 쿼리문보다 훨씬 줄어든 컬럼양을 확인할 수 있습니다!

그렇다면 V3와 V4의 성능 차이가 많이 날까요??

그렇지 않다고 합니다. 성능을 좌우하는 것은 from절 다음부터입니다. 즉, select 절에 컬럼이 몇개 추가된다고 성능에는 영향이 없다고 봐도 좋습니다. 물론, 데이터 사이즈가 정말 큰 경우에는 문제가 되지만 그렇지 않은경우 V3를 사용하는 것도 좋다고 합니다. 

또한, 현재 OrderRepository에는 V4를 제외하면 Order 엔티티와 관련된 DB 조회만 있습니다. (엔티티명)+repository의 경우 해당 엔티티와 관련된 조회만 있어야합니다. 즉, 현재 V4를 실행하기 위해 OrderSimpleQueryDto를 조회하며 계층이 무너졌습니다. 리팩토링해줍시다.

repository 팩토리 안에 order.simplequery 파일을 만들어 쿼리 최적화를 위한 코드들은 해당 팩토리안에서 관리해줍시다! 이를통해 얻을 수 있는 장점은 유지보수가 편해집니다. 또한, 용도를 보다 명확하게 할 수 있습니다!

출처

현업에서 성능이 너무 나오지 않아 해결하러 가보면, 강의에서 말한 부분에서 모두 해결할 수 있다고 한다. 강의 목적은 현업에서 성능 문제를 해결할 수 있는 API 개발 방법을 배울 수 있을 것 같다..!

API 개발 고급 소개

등록, 수정은 성능 문제가 거의 발생하지 않는다. 하지만, 조회의 경우는 다르다. 사람들이 조회를 많이 하기 때문이다. 그렇기 때문에 강의 목적으로 조회에서의 성능 문제를 해결하는 방법에 대해 자세하게 설명해주는 것 같다.

조회용 샘플 데이터 입력

• userA
  • JPA1 BOOK
  • JPA2 BOOK
• userB
  • SPRING1 BOOK
  • SPRING2 BOOK

jpashop.service.InitDB 추가

package jpabook.jpashop.service;

import jpabook.jpashop.domain.*;
import jpabook.jpashop.domain.Item.Book;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;

/**
 * 총 주문 2개
 * userA
 * * JPA1 BOOK
 * * JPA2 BOOK
 * userB
 * * SPRING1 BOOK
 * * SPRING2 BOOK
 */
@Component
@RequiredArgsConstructor
public class InitDb {
    private final InitService initService;

    @PostConstruct
    public void Init() {
        initService.dbInit1();
        initService.dbInit2();
    }

    @Component
    @Transactional
    @RequiredArgsConstructor
    static class InitService {
        private final EntityManager em;

        public void dbInit1() {
            Member member = createMember("userA", "인천", "남동구", "123");
            em.persist(member);

            Book book1 = createBook("JPA1 BOOK", 10000, 100);
            em.persist(book1);

            Book book2 = createBook("JPA2 BOOK", 20000, 100);
            em.persist(book2);

            OrderItem orderItem1 = OrderItem.createOrderItem(book1, 10000, 1);
            OrderItem orderItem2 = OrderItem.createOrderItem(book2, 20000, 1);

            Delivery delivery = new Delivery();
            delivery.setAddress(member.getAddress());
            Order order = Order.createOrder(member, delivery, orderItem1, orderItem2);
            em.persist(order);
        }

        public void dbInit2() {
            Member member = createMember("userB", "인천", "연수구", "321");
            em.persist(member);

            Book book1 = createBook("SPRING1 BOOK", 10000, 100);
            em.persist(book1);

            Book book2 = createBook("SPRING2 BOOK", 20000, 100);
            em.persist(book2);

            OrderItem orderItem1 = OrderItem.createOrderItem(book1, 10000, 1);
            OrderItem orderItem2 = OrderItem.createOrderItem(book2, 20000, 1);

            Delivery delivery = new Delivery();
            delivery.setAddress(member.getAddress());
            Order order = Order.createOrder(member, delivery, orderItem1, orderItem2);
            em.persist(order);
        }

        private Book createBook(String name, int price, int stockQuantity) {
            Book book1 = new Book();
            book1.setName(name);
            book1.setPrice(price);
            book1.setStockQuantity(stockQuantity);
            return book1;
        }

        private Member createMember(String name, String city, String street, String zipcode) {
            Member member = new Member();
            member.setName(name);
            member.setAddress(new Address(city, street, zipcode));
            return member;
        }
    }
}

테스트

출처

JPA를 사용하며 API를 개발할 때 올바른 방향에 대해 정리할 수 있는 강의

강의에 앞서 postman을 설치하자. 다른 restAPI 툴을 사용해도 됩니다.

회원 등록 API

jpashop.api.memberApiController.java

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.service.MemberService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

@RestController
@RequiredArgsConstructor
public class MemberApiController {
    private final MemberService memberService;

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

    @Data
    static class CreateMemberResponse {
        private Long id;

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

postman에서 api test

파라미터로 데이터를 보내는 것이 아니기때문에 Body에서 raw, JSON 형식으로 바꿔준 후, name을 적어 POST 요청을 보내면 id 값이 1으로 정상적으로 동작하는 것을 볼 수 있습니다. 

현재는 Entity에 아무런 제약조건을 걸지 않았기때문에 데이터를 넣지 않아도 @GeneratedValue를 설정한 PK를 제외한 모든 필드가 NULL로 만들어 집니다.

위와 같이 NULL 값을 포함하지 않게 설정을 하고 싶다면 아래와 같이 @NotEmpty를 추가해주면 됩니다.

@NotEmpty 추가 후 돌리면 name에 값을 설정하지 않았기 때문에 에러가 발생한 것을 볼 수 있습니다.

알아야 할 점은 화면에 보여지는 계층을 presentation 계층이라 합니다. 현재 프레젠테이션 계층에 대한 검증 로직이 Member Entity에 추가가 된 것 입니다. 아무런 문제가 없어보이지만, 여기서 발생하는 문제가 있습니다.

1. 두 개 이상의 api가 있을 때, 하나의 api에서는 @NotEmpty와 같은 검증 로직이 필요하지만 다른 하나의 api에서는 검증 로직이 필요가 없을 수도 있습니다. 
2. Entity의 필드명을 바꿀 때, name으로 사용하고 있던 필드 명을 username으로 어떤 팀이 바꿨다고 가정해봅시다. 기존 api를 사용할 때 name으로 사용하던 코드들이 모두 정상작동하지 않게됩니다. 
   여기서 알아야할 점은 엔티티를 손보았을 때, api 스펙이 자체가 변하는 것이 문제입니다. Entity라는 것은 굉장히 여러 곳에서 사용하기 때문에 바뀔 확률이 높습니다. 그렇기 때문에, Entity를 손보아도 해당 Entity와 연관된 모든 api 스펙에 영향이 가지 않도록 설계하는 것이 중요합니다. 그렇기때문에 DTO 사용하는 습관을 길러야 합니다.

MemberApiController V2 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.service.MemberService;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

@RestController
@RequiredArgsConstructor
public class MemberApiController {
    ...

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

    @Data
    static class CreateMemberRequest{
        private String name;
    }

    ...
}

V2 장점

1. CreateMemberRequest라는 클래스를 만들어 name만 받도록 api를 설계했습니다. 위와 같이 설계하면 presentation 계층과 Entity 계층을 분리하기 때문에 유지보수가 편리해집니다. 
2. V1처럼 Member를 파라미터로 두는 경우 알아서 바인딩되어 데이터가 들어가기 때문에 어떤 값이 들어오는지 알 수 없습니다. 하지만, V2의 경우 필요한 데이터만 필드를 만들기 때문에 들어가는 데이터를 알 수 있습니다.
3. 검증 로직을 Entity에 추가하지 않고 DTO에 추가할 수 있습니다.

회원 수정 API

MemberApiController update 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.service.MemberService;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;

@RestController
@RequiredArgsConstructor
public class MemberApiController {
    
    ...

    @PutMapping("/api/v2/member/{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;
    }

    ...
}

MemberService 코드 추가

package jpabook.jpashop.service;

import jpabook.jpashop.domain.Member;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import jpabook.jpashop.repository.MemberRepository;

import java.util.List;

@Service
@RequiredArgsConstructor            // final로 이루어진 필드로만 생성자를 만들어 줌
@Transactional(readOnly = true) //조회 성능 최적화
public class MemberService {

    ...

    @Transactional
    public void update(Long id, String name){
        Member member = memberRepository.findOne(id);
        member.setName(name);
    }
}

테스트

회원 조회 API

MemberApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.service.MemberService;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.*;

import javax.validation.Valid;

@RestController
@RequiredArgsConstructor
public class MemberApiController {
    ...

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

    ...
}

테스트

문제점

1. 회원에 대한 정보만 조회하려했지만, orders에 대한 정보도 포함되어 있는 것을 볼 수 있다.
   • @JsonIgnore라는 기능을 사용해서 포함시키지 않을 수 있다. 하지만, 위에서 말했듯 Entity는 다양한 api를 통해 호출을 한다. 하나의 api는 orders를 포함시키지 않아야하지만, 다른 하나의 api는 orders를 포함해야될 수 있다. 이러한 상황에서 문제가 생긴다.
2. 만약, 로그인 기능이라 아이디랑 패스워드가 있다면 노출의 우려가 있다.
3. 엔티티가 변경되면 api 스펙이 변경된다.

다시한번 강조하지만, presentation 계층과 Entity 계층을 분리하자!! DTO를 사용하자

MemberApiController 코드 추가

package jpabook.jpashop.api;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.service.MemberService;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import java.util.stream.Collectors;

import javax.validation.Valid;

@RestController
@RequiredArgsConstructor
public class MemberApiController {
    
    ...

    @GetMapping("/api/v2/members")
    public Result memberV2() {
        List<Member> findMembers = memberService.findMembers();
        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;
    }

    ...
}

테스트

이렇게 두번 감싸면 필요한 필드를 추가할 수도 있다. (array가 첫 시작이 아니기때문에 가능합니다.) 예를들어, 조회한 데이터가 몇개인지 추가해봅시다.

MemberApiController 코드 추가

    @GetMapping("/api/v2/members")
    public Result memberV2() {
        List<Member> findMembers = memberService.findMembers();
        List<MemberDTO> collect = findMembers.stream()
                .map(m -> new MemberDTO(m.getName()))
                .collect(Collectors.toList());

        return new Result(collect.size(), collect);
    }

    @Data
    @AllArgsConstructor
    static class Result<T> {
        private int count;
        private T data;
    }

테스트

출처

홈 화면과 레이아웃

HomeContoller

package jpabook.jpashop.controller;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@Slf4j	 // log
public class HomeController {

    @RequestMapping("/")
    public String Home() {
        log.info("home controller");
        return "home";
    }
}

resources/home.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header">
    <title>Hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader" />
    <div class="jumbotron"> <h1>HELLO SHOP</h1>
        <p class="lead">회원 기능</p> <p>
            <a class="btn btn-lg btn-secondary" href="/members/new">회원 가입</a>
            <a class="btn btn-lg btn-secondary" href="/members">회원 목록</a> </p>
        <p class="lead">상품 기능</p> <p>
            <a class="btn btn-lg btn-dark" href="/items/new">상품 등록</a>
            <a class="btn btn-lg btn-dark" href="/items">상품 목록</a> </p>
        <p class="lead">주문 기능</p> <p>
            <a class="btn btn-lg btn-info" href="/order">상품 주문</a>
            <a class="btn btn-lg btn-info" href="/orders">주문 내역</a> </p>
    </div>
    <div th:replace="fragments/footer :: footer" />
</div> <!-- /container -->
</body>
</html>

resources/fragments/bodyHeader.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<div class="header" th:fragment="bodyHeader">
    <ul class="nav nav-pills pull-right">
        <li><a href="/">Home</a></li>
    </ul>
    <a href="/"><h3 class="text-muted">HELLO SHOP</h3></a>
</div>

resources/fragments/footer.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<div class="footer" th:fragment="footer">
    <p>&copy; Hello Shop V2</p>
</div>

resources/fragments/header.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head th:fragment="header">
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-
  to-fit=no">
    <!-- Bootstrap CSS -->
    <link rel="stylesheet" href="/css/bootstrap.min.css" integrity="sha384-
  ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
          crossorigin="anonymous">
    <!-- Custom styles for this template -->
    <link href="/css/jumbotron-narrow.css" rel="stylesheet">
    <title>Hello, world!</title>
</head>

후에 실행해보면 아래와 같은 페이지가 뜬다.

깔끔하게 정리해주기 위해 Bootstrap을 사용해 view 리소스 등록하자.

/* Space out content a bit */
body {
    padding-top: 20px;
    padding-bottom: 20px;
}

/* Everything but the jumbotron gets side spacing for mobile first views */
.header,
.marketing,
.footer {
    padding-left: 15px;
    padding-right: 15px;
}

/* Custom page header */
.header {
    border-bottom: 1px solid #e5e5e5;
}

/* Make the masthead heading the same height as the navigation */
.header h3 {
    margin-top: 0;
    margin-bottom: 0;
    line-height: 40px;
    padding-bottom: 19px;
}

/* Custom page footer */
.footer {
    padding-top: 19px;
    color: #777;

    border-top: 1px solid #e5e5e5;
}

/* Customize container */
@media (min-width: 768px) {
    .container {
        max-width: 730px;
    }
}
.container-narrow > hr {
    margin: 30px 0;
}

/* Main marketing message and sign up button */
.jumbotron {
    text-align: center;
    border-bottom: 1px solid #e5e5e5;
}
.jumbotron .btn {
    font-size: 21px;
    padding: 14px 24px;
}

/* Supporting marketing content */
.marketing {
    margin: 40px 0;
}
.marketing p + h4 {
    margin-top: 28px;
}

/* Responsive: Portrait tablets and up */
@media screen and (min-width: 768px) {

    /* Remove the padding we set earlier */
    .header,
    .marketing,
    .footer {
        padding-left: 0;
        padding-right: 0;

    }

    /* Space out the masthead */
    .header {
        margin-bottom: 30px;
    }

    /* Remove the bottom border on the jumbotron for visual effect */
    .jumbotron {
        border-bottom: 0;
    } 
}

바뀐 페이지

회원 등록

MemberController PostMapping 추가

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.service.MemberService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

import javax.validation.Valid;

@Controller
@RequiredArgsConstructor
public class MemberController {
    private final MemberService memberService;

    // get 요청
    @GetMapping("members/new")
    public String createFrom(Model model){
        // controller -> view 의 로직에서 data를 싫어서 보냄.
        // memberForm에 저장된 데이터를 갖고옴 MemberFrom메 매핑하여
        model.addAttribute("memberForm", new MemberForm());
        return "members/createMemberForm";
    }

    // post 요청
    @PostMapping("members/new")
    public String create(@Valid MemberForm memberForm, BindingResult result){
        // name을 필수로 입력해야하는데, 입력을 하지않아 에러가 존재한다면 다시 회원가입 페이지로 이동
        if(result.hasErrors()){
            return "members/createMemberForm";
        }
        Address address = new Address(memberForm.getCity(), memberForm.getStreet(), memberForm.getZipcode());
        Member member = new Member();
        member.setName(memberForm.getName());
        member.setAddress(address);

        memberService.join(member);
        return "redirect:/";
    }
}

post요청이 있다면, MemberForm에 입력 데이터를 파라미터로 가져옵니다. BindingResult는 에러가 있을경우 에러에대한 내용이 BindingResult로 넘어옵니다. 아래 MemberForm을 보시면 NotEmpty를 사용하여 Empty를 허용하지 않도록 했습니다. 그렇기때문에 이름이 null로 넘어올 경우 에러가 발생합니다. 이렇듯 에러가 발생하면 에러페이지를 띄우는 것이 아닌, 이름은 필수라는 문구와 함께 회원가입 페이지를 다시 띄워줍니다.

MemberForm

package jpabook.jpashop.controller;

import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotEmpty;

@Getter
@Setter
public class MemberForm {
    @NotEmpty(message = "회원 입력은 필수 입니다.")   //필수
    private String name;

    private String city;
    private String street;
    private String zipcode;

}

resources/members/createMemberFrom.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header" />
<style>
    .fieldError {
        border-color: #bd2130;
    } </style>
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader"/>
    <!--th:object="${memberForm}를 통해 MemberForm 클래스와 매핑시켜 줍니다.-->
    <form role="form" action="/members/new" th:object="${memberForm}"
          method="post">
        <div class="form-group">
            <label th:for="name">이름</label>
            <input type="text" th:field="*{name}" class="form-control" placeholder="이름을 입력하세요"
                   th:class="${#fields.hasErrors('name')}? 'form-control fieldError' : 'form-control'">
            <!--에러가 있다면 해당 문구를 띄움-->
            <p th:if="${#fields.hasErrors('name')}"
               th:errors="*{name}">Incorrect date</p>
        </div>
        <div class="form-group">
            <label th:for="city">도시</label>
            <input type="text" th:field="*{city}" class="form-control"

                   placeholder="도시를 입력하세요"> </div>
        <div class="form-group">
            <label th:for="street">거리</label>
            <input type="text" th:field="*{street}" class="form-control" placeholder="거리를 입력하세요">
        </div>
        <div class="form-group">
            <label th:for="zipcode">우편번호</label>
            <input type="text" th:field="*{zipcode}" class="form-control"
                   placeholder="우편번호를 입력하세요"> </div>
        <button type="submit" class="btn btn-primary">Submit</button>
    </form>
    <br/>
    <div th:replace="fragments/footer :: footer" />
</div> <!-- /container -->
</body>
</html>

이름을 입력하지 않는 경우 아래와 같이 회원가입이 되지 않으며, 에러 문구가 나옵니다.

회원 목록 조회

MemberController "members" GetMapping 추가

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.service.MemberService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

import javax.validation.Valid;
import java.util.List;

@Controller
@RequiredArgsConstructor
public class MemberController {
    private final MemberService memberService;

    ...

    @GetMapping("/members")
    public String list(Model model){
        List<Member> members = memberService.findMembers();
        model.addAttribute("members", members);
        return "members/memberList";
    }
}

위는 Member Entity에 있는 데이터들을 모두 사용하기 때문에 Member로 사용했지만, 일부의 데이터만 이용하는 경우 DTO로 만들어서 사용하자.

단, API를 만들 때는 절대로 엔티티를 외부로 반환하면 안된다.

필드가 추가가 되지 않는다면 문제가 되지 않을 수 있겠지만, 필드 수정되는 경우에 문제가 생긴다. 만약, Member에서 password 혹은 주민등록번호와 같은 노출되면 안되는 필드가 생겨버리는 경우에 문제가 생길 수 있다.

resources/members/MemberList.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header" />
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader" />
    <div>
        <table class="table table-striped">
            <thead>
            <tr>
                <th>#</th>
                <th>이름</th> <th>도시</th> <th>주소</th> <th>우편번호</th>
            </tr>
            </thead>
            <tbody>
            <!--GetMapping에서 model에 담았던 members를 아래와 같이 웹페이지에 적용한다.-->
            <tr th:each="member : ${members}">
                <td th:text="${member.id}"></td>
                <td th:text="${member.name}"></td>
                <td th:text="${member.address?.city}"></td>
                <td th:text="${member.address?.street}"></td>
                <td th:text="${member.address?.zipcode}"></td>
            </tr>
            </tbody>

        </table>
    </div>
    <div th:replace="fragments/footer :: footer" />
</div> <!-- /container -->
</body>
</html>

상품 등록

ItemController

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.Item.Book;
import jpabook.jpashop.service.ItemService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
@RequiredArgsConstructor
public class ItemController {

    private final ItemService itemService;

    @GetMapping("/items/new")
    public String createForm(Model model){
        model.addAttribute("form", new BookForm());
        return "items/createItemForm";
    }

    @PostMapping("/items/new")
    public String create(BookForm form){
        Book book = createBook(form);

        itemService.saveItem(book);

        return "redirect:/items";
    }

    private Book createBook(BookForm form) {
        Book book = new Book();
        book.setName(form.getName());
        book.setPrice(form.getPrice());
        book.setStockQuantity(form.getStockQuantity());
        book.setAuthor(form.getAuthor());
        book.setIsbn(form.getIsbn());
        return book;
    }
}

BookForm

package jpabook.jpashop.controller;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class BookForm {

    private Long id;

    private String name;
    private int price;
    private int stockQuantity;

    private String author;
    private String isbn;
}

resources/items/createItemForm.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header" />
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader"/>
    <form th:action="@{/items/new}" th:object="${form}" method="post">
        <div class="form-group">
            <label th:for="name">상품명</label>
            <input type="text" th:field="*{name}" class="form-control"
                   placeholder="이름을 입력하세요"> </div>
        <div class="form-group">
            <label th:for="price">가격</label>
            <input type="number" th:field="*{price}" class="form-control" placeholder="가격을 입력하세요">
        </div>
        <div class="form-group">
            <label th:for="stockQuantity">수량</label>
            <input type="number" th:field="*{stockQuantity}" class="form-
control" placeholder="수량을 입력하세요"> </div>
        <div class="form-group">
            <label th:for="author">저자</label>
            <input type="text" th:field="*{author}" class="form-control"
                   placeholder="저자를 입력하세요"> </div>
        <div class="form-group">
            <label th:for="isbn">ISBN</label>
            <input type="text" th:field="*{isbn}" class="form-control"
                   placeholder="ISBN을 입력하세요"> </div>
        <button type="submit" class="btn btn-primary">Submit</button>
    </form>
    <br/>
    <div th:replace="fragments/footer :: footer" />
</div> <!-- /container -->
</body>
</html>

상품 목록

ItemController GetMapping("/items") 추가

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.Item.Book;
import jpabook.jpashop.domain.Item.Item;
import jpabook.jpashop.service.ItemService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import java.util.*;

@Controller
@RequiredArgsConstructor
public class ItemController {

    ...

    @GetMapping("/items")
    public String list(Model model){
        List<Item> items = itemService.findItems();
        model.addAttribute("items", items);
        return "/items/itemList";
    }

    ...
}

resources/items/itemList.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header" />
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader"/>
    <div>
        <table class="table table-striped">
            <thead> <tr>
                <th>#</th> <th>상품명</th> <th>가격</th> <th>재고수량</th> <th></th>
            </tr>
            </thead>
            <tbody>

            <tr th:each="item : ${items}">
                <td th:text="${item.id}"></td>
                <td th:text="${item.name}"></td>
                <td th:text="${item.price}"></td>
                <td th:text="${item.stockQuantity}"></td>
                <td>
                    <a href="#" th:href="@{/items/{id}/edit (id=${item.id})}" class="btn btn-primary" role="button">수정</a>
                </td> </tr>
            </tbody>
        </table>
    </div>
    <div th:replace="fragments/footer :: footer"/>
</div> <!-- /container -->
</body>
</html>

상품 수정

ItemController 코드 추가

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.Item.Book;
import jpabook.jpashop.domain.Item.Item;
import jpabook.jpashop.service.ItemService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import java.util.*;

@Controller
@RequiredArgsConstructor
public class ItemController {

    ...

    @GetMapping("items/{itemId}/edit")
    public String updateItemForm(@PathVariable("itemId") Long itemId, Model model){
        Book item = (Book) itemService.findOne(itemId);

        BookForm form = new BookForm();
        form.setId(item.getId());
        form.setName(item.getName());
        form.setPrice(item.getPrice());
        form.setStockQuantity(item.getStockQuantity());
        form.setAuthor(item.getAuthor());
        form.setIsbn(item.getIsbn());

        model.addAttribute("form", form);
        return "items/updateItemForm";
    }

    @PostMapping("items/{itemId}/edit")
    public String updateItem(@ModelAttribute("form") BookForm bookForm){
        Book book = new Book();
        book.setName(bookForm.getName());
        book.setId(bookForm.getId());
        book.setPrice(bookForm.getPrice());
        book.setStockQuantity(bookForm.getStockQuantity());
        book.setAuthor(bookForm.getAuthor());
        book.setIsbn(bookForm.getIsbn());

        itemService.saveItem(book);
        return "redirect:/items";
    }

    ...

}

PathVariable은 Mapping에 있는 {}안에 있는 값이 itemId인 곳에 (Long itemId)를 넣는 것을 의미합니다.

updateItemForm.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header" />
<body>
<div class="container">
  <div th:replace="fragments/bodyHeader :: bodyHeader"/>
  <form th:object="${form}" method="post">
    <!-- id -->
    <input type="hidden" th:field="*{id}" />
    <div class="form-group">
      <label th:for="name">상품명</label>
      <input type="text" th:field="*{name}" class="form-control"
             placeholder="이름을 입력하세요" /> </div>
    <div class="form-group">
      <label th:for="price">가격</label>
      <input type="number" th:field="*{price}" class="form-control" placeholder="가격을 입력하세요" />
    </div>
    <div class="form-group">
      <label th:for="stockQuantity">수량</label>
      <input type="number" th:field="*{stockQuantity}" class="form- control" placeholder="수량을 입력하세요" /> </div>
    <div class="form-group">
      <label th:for="author">저자</label>
      <input type="text" th:field="*{author}" class="form-control" placeholder="저자를 입력하세요" />
    </div>
    <div class="form-group">
      <label th:for="isbn">ISBN</label>
      <input type="text" th:field="*{isbn}" class="form-control" placeholder="ISBN을 입력하세요" />
    </div>
    <button type="submit" class="btn btn-primary">Submit</button>
  </form>
  <div th:replace="fragments/footer :: footer" />
</div> <!-- /container -->
</body>
</html>

변경 감지와 병합(merge)

 참고 : 정말 중요한 내용이니 꼭! 완벽하게 이해해야 합니다.

준영속 엔티티란?

영속성 컨텍스트가 더는 관리하지 않는 엔티티를 말한다.
(아래에서는 itemService.saveItem(book)에서 수정을 시도하는 Book 객체이다. Book 객체는 이미 DB에 한번 저장되어서 식별자가 존재한다. 이렇게 임의로 만들어낸 엔티티도 기존 식별자를 가지고 있으면 준영속 엔티티로 볼 수 있다.)

준영속 엔티티를 수정하는 2가지 방법

• 변경 감지 기능 사용 (더티 체킹)
• 병합 (merge) 사용 

변경 감지 기능 사용

package jpabook.jpashop.service;

import jpabook.jpashop.domain.Item.Book;
import jpabook.jpashop.domain.Item.Item;
import jpabook.jpashop.repository.ItemRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;

@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class ItemService {

    ...

    @Transactional
    public void updateItem(Long itemId, Book bookParam) {
        Item findItem = itemRepository.findOne(itemId);
        findItem.setPrice(bookParam.getPrice());
        findItem.setName(bookParam.getName());
        findItem.setStockQuantity(bookParam.getStockQuantity());
    }

    public List<Item> findItems(){
    ...
}

준영속 엔티티라 더티 체킹이 안될 것 같았지만, 해결책이 있었습니다.

트랜잭션 안에서 엔티티를 조회하여 영속 상태인 엔티티의 값을 변경해주면 됩니다. 이렇게하면 영속 상태이기 때문에 트랜잭션 커밋 시점에 변경 감지가 동작하여 update 쿼리문이 날라갑니다.

병합 사용

병합이란? 준영속 상태의 엔티티를 영속 상태로 변경할 때 사용하는 기능입니다.

병학 동작 방식

1. merge()를 실행한다.
2. 파라미터로 넘어온 준영속 엔티티의 식별자 값으로 1차 캐시에서 엔티티를 조회한다.
   1. 만약 1차 캐시에 엔티티가 없으면 데이터베이스에서 엔티티를 조회하고, 1차 캐시에 저장한.
3. 조회한 영속 엔티티(mergeMember)에 member 엔티티의 값을 채워 넣는다. (member 엔티티의 모든 값을 mergeMember에 밀어 넣는다. 이때, mergeMember의 "회원1" 이라는 이름이 "회원명변경"으로 바뀐다.)
4. 영속 상태인 mergeMember를 반환한다.

주의 : 변경 감지 기능을 사용하면 원하는 속성만 선택해서 변경할 수 있지만, 병합을 사용하면 모든 속성이 변경된다.
따라서, 병합시 값이 없으면 null로 업데이트 할 위험도 있다. (병합은 모든 필드를 교체한다.)

결론 : merge는 모든 속성을 변경할 때만 사용하자.. (매우 위험) (되도록이면 변경감지를 사용하자)

엔티티를 변경할 때는 항상 변경 감지를 사용하세요

• 컨트롤러에서 어설프게 엔티티를 생성하지 마세요.
• 트랜잭션이 있는 서비스 계층에 식별자(primaryKey)와 변경할 데이터를 명확하게 전달하세요. 
  • 파라미터 or 데이터가 많다면 DTO를 생성해서 전달해주면 됩니다.
• 트랜잭션이 있는 서비스 게층에서 영속 상태의 엔티티를 조회하고, 엔티티의 데이터를 직접 변경하세요.
• 트랜잭션 커밋시점에서 변경 감지가 실행됩니다.

상품 주문

OrderController

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.Item.Item;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.repository.MemberRepository;
import jpabook.jpashop.service.ItemService;
import jpabook.jpashop.service.MemberService;
import jpabook.jpashop.service.OrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.*;

@Controller
@RequiredArgsConstructor
public class OrderController {
    private final MemberService memberService;
    private final OrderService orderService;
    private final ItemService itemService;

    @GetMapping("/order")
    public String createForm(Model model){
        List<Member> members = memberService.findMembers();
        List<Item> items = itemService.findItems();

        model.addAttribute("members", members);
        model.addAttribute("items", items);

        return "/order/orderForm";
    }

    @PostMapping("/order")
    public String order(@RequestParam("memberId") Long memberId,
                        @RequestParam("itemId") Long itemId,
                        @RequestParam("count") int count) {
        orderService.order(memberId, itemId, count);
        return "redirectL/orders";
    }
}

@RequestParam은 form submit 방식으로 select 에 지정한 name이랑 연관되는 이름 입니다.

resources/order/orderForm.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header" />
<body>
<div class="container">
  <div th:replace="fragments/bodyHeader :: bodyHeader"/>
  <form role="form" action="/order" method="post">
    <div class="form-group">
      <label for="member">주문회원</label>
      <select name="memberId" id="member" class="form-control">
        <option value="">회원선택</option> <option th:each="member : ${members}"
                                               th:value="${member.id}"
                                               th:text="${member.name}" />
      </select>
    </div>
    <div class="form-group">
      <label for="item">상품명</label>
      <select name="itemId" id="item" class="form-control"> <option value="">상품선택</option>
        <option th:each="item : ${items}"
                th:value="${item.id}"
                th:text="${item.name}" />
      </select>
    </div>
    <div class="form-group">
      <label for="count">주문수량</label>
      <input type="number" name="count" class="form-control" id="count"
             placeholder="주문 수량을 입력하세요"> </div>
    <button type="submit" class="btn btn-primary">Submit</button>
  </form>
  <br/>
  <div th:replace="fragments/footer :: footer" />
</div> <!-- /container -->
</body>
</html>

주문 목록 검색, 취소

OrderController

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.Item.Item;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.repository.MemberRepository;
import jpabook.jpashop.repository.OrderSearch;
import jpabook.jpashop.service.ItemService;
import jpabook.jpashop.service.MemberService;
import jpabook.jpashop.service.OrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.*;

@Controller
@RequiredArgsConstructor
public class OrderController {
    ...

    @GetMapping("/orders")
    public String orderList(@ModelAttribute("orderSearch") OrderSearch orderSearch, Model model) {
        List<Order> orders = orderService.findOrders(orderSearch);
        model.addAttribute("orders", orders);

        return "order/orderList";
    }

    @PostMapping("/orders/{orderId}/cancel")
    public String cancelOrder(@PathVariable("orderId") Long orderId){
        orderService.cancelOrder(orderId);
        return "redirect:/orders";
    }
}

OrderList.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header"/>
<body>
<div class="container">
  <div th:replace="fragments/bodyHeader :: bodyHeader"/>
  <div> <div>
    <form th:object="${orderSearch}" class="form-inline">
      <div class="form-group mb-2">
        <input type="text" th:field="*{memberName}" class="form- control" placeholder="회원명"/>
      </div>
      <div class="form-group mx-sm-1 mb-2">
        <select th:field="*{orderStatus}" class="form-control"> <option value="">주문상태</option>
          <option th:each=
                          "status : ${T(jpabook.jpashop.domain.OrderStatus).values()}"
                  th:value="${status}"
                  th:text="${status}">option
          </option>
        </select>
      </div>
      <button type="submit" class="btn btn-primary mb-2">검색</button> </form>
  </div>
    <table class="table table-striped">
      <thead>
      <tr>
        <th>#</th>
        <th>회원명</th> <th>대표상품 이름</th> <th>대표상품 주문가격</th>
        <th>대표상품 주문수량</th> <th>상태</th> <th>일시</th> <th></th>
      </tr>
      </thead>
      <tbody>
      <tr th:each="item : ${orders}">
        <td th:text="${item.id}"></td>
        <td th:text="${item.member.name}"></td>
        <td th:text="${item.orderItems[0].item.name}"></td>
        <td th:text="${item.orderItems[0].item.price}"></td>
        <td th:text="${item.orderItems[0].count}"></td>
        <td th:text="${item.status}"></td>
        <td th:text="${item.orderDate}"></td>
        <td>
        <!--상태가 Order이면 버튼이 노출되도록-->
          <a th:if="${item.status.name() == 'ORDER'}" href="#"
             th:href="'javascript:cancel('+${item.id}+')'"
             class="btn btn-danger">CANCEL</a>
        </td>
      </tr>
      </tbody>
    </table>
  </div>
  <div th:replace="fragments/footer :: footer"/>
</div> <!-- /container -->
</body>
<script>
  function cancel(id) {
    var form = document.createElement("form");
    form.setAttribute("method", "post");
    form.setAttribute("action", "/orders/" + id + "/cancel");
    document.body.appendChild(form);
    form.submit();
  }

</script>
</html>

출처