스프링 부트와 JPA 활용1

📌 도메인 분석 설계

0️⃣ 요구사항 분석

  - 실제 동작하는 화면 확인

  - 기능 목록 확인

 

1️⃣ 도메인 모델과 테이블 설계

 

- 다대다 관계(ex. 상품과 주문)는 일대다(ex. 주문과 주문상품), 다대일(ex. 주문상품과 상품) 관계로 풀기

- 카테고리는 parent, child로 부모, 자식 카테고리를 구현할 수 있음!

- 외래키를 관리(소유)하고 있으면 연관관계의 주인임

- 일대다 관계에서 '다'가 보통 외래키를 가지고 있음!

 

2️⃣ 엔티티 클래스 개발

- 이론적으론 Getter, Setter 모두 제공하지 않고, 꼭 필요한 별도의 메서드를 제공하는게 가장 이상적!

- but 실무에서는 Getter를 모두 열어두고 Setter 대신에 변경 지점이 명확하도록 변경을 위한 비즈니스 메서드를 별도로 제공

@Entity
@Getter @Setter
public class Member {

    @Id @GeneratedValue
    @Column(name = "member_id")
    private Long id;
    
    private String name;
    
    @Embedded
    private Address address;
    
    @OneToMany(mappedBy = "member")
    private List<Order> orders = new ArrayList<>(); //컬렉션은 필드에서 초기화
}

- 컬렉션은 필드에서 초기화

@Entity
@Table(name = "orders")
@Getter @Setter
public class Order {

    @Id @GeneratedValue
    @Column(name = "order_id")
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY) //데이터를 조회할 때, 필요한 시점에 연관된 데이터만 가져옴!
    @JoinColumn(name = "member_id") 
    private Member member; //주문 회원
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderItem> orderItems = new ArrayList<>();
    
    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) 
    @JoinColumn(name = "delivery_id")
    private Delivery delivery; //배송정보

    private LocalDateTime orderDate; //주문시간 
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status; //주문상태 [ORDER, CANCEL]
    
    //==연관관계 메서드==//
    public void setMember(Member member) {
        this.member = member;
        member.getOrders().add(this);
    }
    
    public void addOrderItem(OrderItem orderItem) {
        orderItems.add(orderItem);
        orderItem.setOrder(this);
    }
    
    public void setDelivery(Delivery delivery) {
        this.delivery = delivery;
        delivery.setOrder(this);
    }
    
    //==생성 메서드==//
    public static Order createOrder(Member member, Delivery delivery,
    OrderItem... orderItems) {
        Order order = new Order();
        order.setMember(member);
        order.setDelivery(delivery);
        for (OrderItem orderItem : orderItems) {
            order.addOrderItem(orderItem);
        }
        order.setStatus(OrderStatus.ORDER);
        order.setOrderDate(LocalDateTime.now());
        return order;
    }
    
    //==비즈니스 로직==//
    /** 주문 취소 */
    public void cancel() {
        if (delivery.getStatus() == DeliveryStatus.COMP) {
            throw new IllegalStateException("이미 배송완료된 상품은 취소가 불가능합니다."); 
        }
        
        this.setStatus(OrderStatus.CANCEL);
        for (OrderItem orderItem : orderItems) {
            orderItem.cancel();
        }
    }

    //==조회 로직==//
    /**전체 주문 가격 조회*/ 
    public int getTotalPrice() {
        int totalPrice = 0;
        for (OrderItem orderItem : orderItems) {
            totalPrice += orderItem.getTotalPrice();
        }
        return totalPrice;
    }
}

- 모든 연관관계는 지연로딩으로 설정(fetch = FetchType.LAZY)

- cascade = CascadeType.ALL로 하면 연관관계에 있는 엔티티를 모두 persist(영속)해줌

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "dtype")
@Getter @Setter
public abstract class Item {

    @Id @GeneratedValue
    @Column(name = "item_id")
    private Long id;
    
    private String name;
    private int price;
    private int stockQuantity;
    
    @ManyToMany(mappedBy = "items") 
    private List<Category> categories = new ArrayList<Category>();
    
    //==비즈니스 로직==//
    public void addStock(int quantity) {
        this.stockQuantity += quantity;
    }
    
    public void removeStock(int quantity) {
        int restStock = this.stockQuantity - quantity;
        if (restStock < 0) {
            throw new NotEnoughStockException("need more stock");
        }
        this.stockQuantity = restStock;
    }
}

- 비즈니스 로직을 엔티티에 위임!(= 도메인 모델 패턴, 객체 지향의 특성↑)

@Entity
@DiscriminatorValue("B")
@Getter @Setter
public class Book extends Item {

    private String author;
    private String isbn;
    
}

@Entity
@Getter @Setter
public class Category {
    
    @Id @GeneratedValue
    @Column(name = "category_id")
    private Long id;
    
    private String name;
    
    @ManyToMany
    @JoinTable(name = "category_item",
            joinColumns = @JoinColumn(name = "category_id"),
            inverseJoinColumns = @JoinColumn(name = "item_id"))
    private List<Item> items = new ArrayList<>();
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    private Category parent;
    
    @OneToMany(mappedBy = "parent")
    private List<Category> child = new ArrayList<>();
    
    //==연관관계 메서드==//
    public void addChildCategory(Category child) {
        this.child.add(child);
        child.setParent(this);
    }
}

- 실무에서는 @ManyToMany를 사용하지 말자!

@Embeddable
@Getter
public class Address {
    
    private String city;
    private String street;
    private String zipcode;
    
    protected Address() {
    }
    
    public Address(String city, String street, String zipcode) {
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    } 
}

- 값 타입은 변경 불가능하게 설계!

- @Setter를 삭제하고 자바 기본 생성자를 protected로 설정!

 

 

📌 애플리케이션 구현 준비

0️⃣ 구현 요구사항 분석

1️⃣ 애플리케이션 아키텍처 설계

계층형 구조

- controller: 웹 계층

- service: 비즈니스 로직, 트랜잭션 처리

- repository: JPA를 직접 사용, 엔티티 매니저 사용

- domain: 엔티티가 모여 있는 계층, 모든 계층에서 사용

 

패키지 구조

- jpabook.jpashop

        - domain

        - exception

        - repository

        - service

        - controller(web)

 

❗도메인 개발 → 서비스, 리포지토리 계층 개발 → 테스트 케이스 작성 및 검증 → 웹 계층(컨트롤러) 적용!

 

2️⃣ 리포지토리 개발

@Repository
public class MemberRepository {
    
    @PersistenceContext
    private EntityManager em;
    
    public void save(Member member) {
        em.persist(member);
    }
    
    public Member findOne(Long id) {
        return em.find(Member.class, id);
    }
    
    public List<Member> findAll() {
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
    }
    
    public List<Member> findByName(String name) {
        return em.createQuery("select m from Member m where m.name = :name", Member.class)
                .setParameter("name", name)
                .getResultList();
    }
}

- 스프링 데이터 JPA를 사용하면 ↓ 이렇게 변경 가능!

@Repository
@RequiredArgsConstructor
public class MemberRepository {
    private final EntityManager em;
    ... 
}

 

3️⃣ 서비스 개발

@Service
@Transactional(readOnly = true
@RequiredArgsConstructor
public class MemberService {
    
    private final MemberRepository memberRepository;
    
    /**
     * 회원가입
     */
    @Transactional //변경
    public Long join(Member member) { 
    
        validateDuplicateMember(member); //중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }
      
    private void validateDuplicateMember(Member member) {
        List<Member> findMembers = memberRepository.findByName(member.getName());
        if (!findMembers.isEmpty()) {
            throw new IllegalStateException("이미 존재하는 회원입니다."); 
        }
    }
    
    /**
     * 전체 회원 조회
     */
    public List<Member> findMembers() {
        return memberRepository.findAll();
    }
    
    public Member findOne(Long memberId) {
        return memberRepository.findOne(memberId);
    }
}

- 스프링 필드 주입 보다는 생성자 주입을 사용하자!

 

4️⃣ 기능 테스트

@RunWith(SpringRunner.class) //스프링과 테스트 통합
@SpringBootTest //스프링 부트를 띄우고 테스트
@Transactional //각각의 테스트를 실행할 때마다 트랜잭션을 시작하고 테스트가 끝나면 트랜잭션을 강제로 롤백 
public class MemberServiceTest {
    
    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;

    @Test
    public void 회원가입() throws Exception {
    
        //Given
        Member member = new Member();
        member.setName("kim");
        
        //When
        Long saveId = memberService.join(member);
        
        //Then
        assertEquals(member, memberRepository.findOne(saveId));
    }
    
    @Test(expected = IllegalStateException.class) 
    public void 중복_회원_예외() throws Exception {
        //Given
        Member member1 = new Member();
        member1.setName("kim");
        
        Member member2 = new Member();
        member2.setName("kim");

        //When
        memberService.join(member1); 
        memberService.join(member2); //예외가 발생해야 한다.
    
        //Then
        fail("예외가 발생해야 한다."); 
    }
}

- 테스트 케이스를 위한 스프링 환경과 애플리케이션을 실행하는 환경은 보통 다르므로 설정 파일을 다르게 사용하자! (test/resources/application.yml)

 

✔️ 주문 검색 기능 개발(동적 쿼리)

1️⃣ JPQL

2️⃣ JPA Criteria

3️⃣ Querydsl

 

 

📌 웹 계층 개발

❗폼 객체를 사용해서 화면 계층과 서비스 계층을 명확하게 분리!

  - 실무에서 엔티티는 핵심 비즈니스 로직만 가지고 있고, 화면을 위한 로직은 없어야 함! 화면이나 API에 맞는 폼 객체나 DTO를 사용하자! 그래서 화면이나 API 요구사항을 이것들로 처리하고, 엔티티는 최대한 순수하게 유지하자!

@Getter @Setter
public class MemberForm {
    
    @NotEmpty(message = "회원 이름은 필수 입니다") 
    private String name;
    
    private String city;
    private String street;
    private String zipcode;
}

0️⃣ 컨트롤러 개발

@Controller
@RequiredArgsConstructor
public class MemberController {
    
    private final MemberService memberService;
    
    @GetMapping(value = "/members/new")
    public String createForm(Model model) {
        model.addAttribute("memberForm", new MemberForm());
        return "members/createMemberForm";
    }
    
    @PostMapping(value = "/members/new")
    public String create(@Valid MemberForm form, BindingResult result) {
        
        if (result.hasErrors()) {
            return "members/createMemberForm";
        }
        
        Address address = new Address(form.getCity(), form.getStreet(), form.getZipcode());
        Member member = new Member();
        member.setName(form.getName());
        member.setAddress(address);
        
        memberService.join(member);
        return "redirect:/";
    }
    
    @GetMapping(value = "/members") 
    public String list(Model model) {
        List<Member> members = memberService.findMembers();
        model.addAttribute("members", members);
        return "members/memberList";
    }
}

 

 

📌 변경 감지와 병합(merge)

🙋🏻‍♀️ 준영속 엔티티?

: 영속성 컨텍스트(entity manager)가 더는 관리하지 않는 엔티티. 데이터를 수정해도 변경 감지 기능 동작X

  따라서, 1️⃣ 변경 감지 기능을 사용하거나 2️⃣ 병합(merge)을 사용해서 준영속 엔티티를 수정

 

 1️⃣ 변경 감지

@Transactional
void update(Item itemParam) { //itemParam: 파리미터로 넘어온 준영속 상태의 엔티티
    Item findItem = em.find(Item.class, itemParam.getId()); //같은 엔티티 조회
    findItem.setPrice(itemParam.getPrice()); //데이터 수정
}

- 영속성 컨텍스트에서 엔티티를  다시 조회한 후에 데이터를 수정

 

2️⃣ 병합(merge)

@Transactional
void update(Item itemParam) { //itemParam: 파리미터로 넘어온 준영속 상태의 엔티티 
    Item mergeItem = em.merge(itemParam);
}

❗병합 시 모든 속성이 변경됨, 값이 없으면 null로 업데이트 (← 병합을 사용하지 말아야 하는 이유)

@Repository
public class ItemRepository {
    @PersistenceContext
    EntityManager em;
        
    public void save(Item item) {
        if (item.getId() == null) {
            em.persist(item);
        } else {
            em.merge(item);
        }
    }
    //...
}

↑ 새로운 엔티티 저장과 준영속 엔티티 병합을 편리하게 한번에 처리! (그래도 병합은 사용하지 말자...)

 

✔️ 컨트롤러에서 어설프게 엔티티 생성X

✔️ 서비스 계층에 식별자(id)와 변경할 데이터를 명확하게 전달(파라미터 or DTO)

✔️ 서비스 계층에서 영속 상태의 엔티티를 조화하고 엔티티의 데이터를 직접 변경! (서비스 계층에 트랜잭션이 있기때문!)

✔️ 트랜잭션 커밋 시점에 변경 감지가 실행