JPA 실전 예제2 - 연관관계 매핑 시작

실전 예제1에서 했던 내용을 연관관계 매핑을 사용해서 다시 구현해보기

테이블 구조는 이전과 같지만 이번에는 연관 매핑이 생겼다. 

• Member에서 order의 정보를 저장해 놓는 orders : List를 통해 가짜 매핑하는 부분을 만들었다. Members에서 Orders를 관리하도록 만든 것이다. 하지만 실제에서는 유저에서 Order를 찾는 일이 별로 없다고 한다.
• Order부분에서 member : Member가 Member를 진짜 매핑하는 부분이다. 이것은 왜래키이기 때문에 이곳이 진짜 매핑이다. Member를 만든 후 Order.setMember(Member)를 통해 Order에서 member를 저장 할 수 있다.
• Order 부분에 OrterItems를 알 수 있는 List를 구현한다. List는 양방향 매핑을 위해 만들었다.
• OrderItem은 item과 order 모두 외래키로 존재하기 때문에 진짜 매핑 부분이다.

Member

package jpabook.jpashop.domain;

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

@Entity
@SequenceGenerator(
        name = "MEMBER_SEQ_GENERATOR",
        sequenceName = "MEMBER_SEQ", //매핑할 데이터베이스 시퀀스 이름
        initialValue = 1, allocationSize = 50)
public class Member {

    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "MEMBER_SEQ_GENERATOR")
    @Column(name = "MEMBER_ID")
    private Long id;
    private String name;
    private String city;
    private String zipcode;

    @OneToMany(mappedBy = "member")// ORDER애 ORDER_ID가 주인이다.
    private List<Order> orders = new ArrayList<>(); //양방향 매핑을 위해 필요
    ...Getter,Setter

ORDER

package jpabook.jpashop.domain;

import javax.persistence.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Entity
@SequenceGenerator(
        name = "ORDER_SEQ_GENERATOR",
        sequenceName = "ORDER_SEQ", //매핑할 데이터베이스 시퀀스 이름
        initialValue = 1, allocationSize = 50)
@Table(name = "ORDERS")
public class Order {


    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ORDER_SEQ_GENERATOR")
    @Column(name = "ORDER_ID")
    private Long id;

    @ManyToOne
    @JoinColumn(name = "MEMBER_ID") //주인
    private Member member;
    private LocalDateTime orderDate;
    @Enumerated(EnumType.STRING)
    private OrderStatus status;

    @OneToMany(mappedBy = "order")
    private List<OrderItem> orderItems = new ArrayList<>();
    ...Getter/Setter

ORDERITEM

package jpabook.jpashop.domain;

import javax.persistence.*;

@Entity
@SequenceGenerator(
        name = "ORDERITEM_SEQ_GENERATOR",
        sequenceName = "ORDERITEM_SEQ", //매핑할 데이터베이스 시퀀스 이름
        initialValue = 1, allocationSize = 50)
public class OrderItem {

    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ORDERITEM_SEQ_GENERATOR")
    @Column(name = "ORDER_ITEM_ID")
    private Long id;

    @ManyToOne
    @JoinColumn(name = "ORDER_ID") //주인
    private Order order;

    @ManyToOne
    @JoinColumn(name = "ITEM_ID") //주인
    private Item item;
    private int orderPrice;
    private int count;
    ..GETTER/SETTER

 

JPAMAIN

package jpabook.jpashop;

import jpabook.jpashop.domain.Item;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderItem;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.List;

public class JpaMain {

    public static void main(String[] args) {
        EntityManagerFactory enf = Persistence.createEntityManagerFactory("hello");
        EntityManager em = enf.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        try {
            //멤버 ENTITY 생성
            Member member = new Member();
            member.setName("Park");
            member.setCity("Inchon");
            member.setZipcode("12");
            em.persist(member);
            
	    //ORDER ENTITY 생성
            Order order = new Order();
            order.setMember(member);
            em.persist(order);
			
            //ORDERITEM ENTITY 생성
            OrderItem orderItem = new OrderItem();
            orderItem.setOrder(order);
			
            //ITEM ENTITY 생성
            Item item = new Item();
            item.setName("컴퓨터");
            item.setPrice(10000);
            item.setStockQuantity(5);
            em.persist(item);
			
            orderItem.setItem(item);
            orderItem.setCount(2);
            orderItem.setOrderPrice(item.getPrice());
            em.persist(orderItem);

            order.addOrderItems(orderItem);
             em.flush();
            em.clear();

            OrderItem findOrderItem = em.find(OrderItem.class, order.getId());
            List<OrderItem> orderItems = findOrderItem.getOrder().getOrderItems();
			
            //주문한 order의 ID 출력해보기 
            System.out.println("=================");
            for (OrderItem o : orderItems) {
                System.out.println("OrderItem : " + o.getId());
            }
            
            
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }
        enf.close();
    }
}

실행결과 

OrderItem에 있는 진짜 매핑인 ITEM과 ORDER은 각각의 아이템 테이블과 order테이블의 번호인 것을 알 수 있다.

각각 테이블마다 sequence를 만들어 번호를 각각 지정해주었다. 이걸로 JDBC로 테이블을 짤때보다 손쉽게 객체를 사용하여 쉽게 매핑을 할 수 있는 것 같다.

 

강의 출처 : https://www.inflearn.com/course/ORM-JPA-Basic

자바 ORM 표준 JPA 프로그래밍 - 기본편 - 인프런 | 강의