• 목표

  • 객체와 테이블 연관관계의 차이를 이해
  • 객체의 참조와 테이블의 외래키 매핑
  • 용어
    • 방향 : 단방향, 양방향
    • 다중성 : 1:1, 1:N, N:1, N:M
    • 💋연관관계의 주인 : 객체 양방향 연관관계는 관리 주인이 필요

• 예제

  • 회원과 팀
  • 회원은 하나의 팀에만 소속 가능
  • 회원과 팀은 다대일 관계

• 💥객체를 테이블에 맞추어 모델링(연관관계 x) → 안좋다!!!!

  

  • 멤버

    package hellojpa;
    
    import javax.persistence.*;
    
    @Entity
    public class Member {
    
        @Id
        @GeneratedValue
        @Column(name = "member_id")
        private Long id;
    
        @Column(name = "username")
        private String username;
    
        @Column(name = "team_id")
        private Long teamId;
    }

  • 팀

    @Entity
    public class Team {
    
        @Id
        @GeneratedValue
        @Column(name = "team_id")
        private Long id;
        private String name;
    }

  • JpaMain ⇒ 외래키 식별자를 직접 다루고 조회 시에도 객체 지향적이지 않다.

    try {
    
                //팀 저장
                Team team = new Team();
                team.setName("TeamA");
                em.persist(team);
    
                //회원 저장
                Member member = new Member();
                member.setUsername("member1");
                member.setTeamId(team.getId());
                em.persist(member);
    
                //조회
                Member findMember = em.find(Member.class, member.getId());
                Long findTeamId = findMember.getId();
                Team findTeam = em.find(Team.class, findTeamId);
    
                tx.commit();
            }

• 💥문제점 : 연관관계 성립 X

  • 테이블은 외래키로 조인을 사용하여 연관된 테이블을 찾는다.
  • 객체는 참조를 사용해서 연관된 객체를 찾는다.

---

단방향 연관관계

• 객체 지향 모델링 (객체 연관관계 사용)

  

  • 멤버

    @Entity
    public class Member {
    
        @Id
        @GeneratedValue
        @Column(name = "member_id")
        private Long id;
    
        @Column(name = "username")
        private String username;
    
    /*    @Column(name = "team_id")
        private Long teamId;*/
    
        @ManyToOne
        @JoinColumn(name = "team_id")
        private Team team;
    }

  • JpaMain ⇒ 객체 그래프 탐색

    try {
    
            //팀 저장
            Team team = new Team();
            team.setName("TeamA");
            em.persist(team);
    
            //회원 저장
            Member member = new Member();
            member.setUsername("member1");
            member.setTeam(team);
            em.persist(member);
    
            //조회
            Member findMember = em.find(Member.class, member.getId());
    
            //참조를 사용한 연관관계 조회
            Team findTeam = findMember.getTeam();
            System.out.println("findTeam = " + findTeam.getName());
    
            tx.commit();
        }

---

양방향 연관관계, 주인 - 1. 기본

• 양방향 매핑

  • ✨사실상, 테이블의 연관관계에서는 방향이 중요치 않다.(Why? FK 하나로 연관관계 확인 가능하다.)

    

  • Team

    @Entity
    public class Team {
    
        @Id
        @GeneratedValue
        @Column(name = "team_id")
        private Long id;
        private String name;
    
        @OneToMany(mappedBy = "team")
        private List<Member> members = new ArrayList<>();
    }

  • JpaMain ⇒ 객체 그래프 탐색

    try {
    
                //팀 저장
                Team team = new Team();
                team.setName("TeamA");
                em.persist(team);
    
                //회원 저장
                Member member = new Member();
                member.setUsername("member1");
                member.setTeam(team);
                em.persist(member);
    
                //영속성 컨텍스트 내용 DB로 저장하고 비우기
                em.flush();
                em.clear();
    
                /**
                 * pk를 통해 찾고 싶은 멤버를 조회하고,
                 * 그 멤버의 팀에 속한 멤버들을 조회하고자 한다.
                 */
                Member findMember = em.find(Member.class, member.getId());
                List<Member> members = findMember.getTeam().getMembers();
    
                for (Member m : members) {
                    System.out.println("m = " + m.getUsername());
                }
                tx.commit();
            }

• mappedBy ⇒ 객체와 테이블이 관계를 맺는 차이에 대해 이해해보자

  • 객체 연관관계 = 2개

    • 회원 → 팀 1개 (단방향)

    • 팀 → 회원 1개 (단방향)

    • 🔔객체의 양방향 관계

      • 객체의 양방향 관계는 사실 서로 다른 단방향 관계 2개(=단방향 연관관계 2개를 만들어야 한다.)

        

  • 테이블 연관관계 = 1개

    • 회원 ←→ 팀 1개 (양방향)

    • 🔔테이블의 양방향 관계

      • 외래 키 하나로 양방향 관계 성립 (JOIN)

        SELECT *
        FROM MEMBER M
        JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID
        
        SELECT *
        FROM TEAM T
        JOIN MEMBER M ON T.TEAM_ID = M.TEAM_ID

  • 딜레마

    

    • 멤버의 팀 값을 변경하나? 팀의 멤버스 값을 변경하나??
    • 연관관계의 주인을 설정하자.

• 연관관계의 주인(Owner)

  • 양방향 매핑 규칙

    • 객체의 두 관계중 하나를 연관관계의 주인으로 지정
    • 연관관계의 주인만이 외래 키를 관리(등록, 수정)
    • 주인이 아닌쪽은 읽기만 가능
    • 주인은 mappedBy 사용 불가
    • 주인이 아니면 mappedBy 속성으로 주인 지정

  • 💋누구를 주인으로?? (중요)

    • 테이블 상 외래 키가 있는 곳을 주인으로 정해라 (⇒ Member.team이 연관관계의 주인)

      

---

양방향 연관관계, 주인 - 2. 주의점 및 정리

• 양방향 매핑시 가장 많이 하는 실수

  • ⇒ 연관관계의 주인에 값을 입력하지 않음

    try {
    
                //팀 저장
                Team team = new Team();
                team.setName("TeamA");
                em.persist(team);
    
                //회원 저장
                Member member = new Member();
                member.setUsername("member1");
    
                //역방향 관계 설정
                team.getMembers().add(member);
                **//member.setTeam(team); ****
                em.persist(member);
    
                //영속성 컨텍스트 내용 DB로 저장하고 비우기
                em.flush();
                em.clear();
    
                tx.commit();
            }

  • DB 결과

    

    • Why? 읽기 전용으로 쓰인 가짜 매핑 mappedBy가 가리키는 team.getMembers().add(member) 구문때문이다. 주인인 Member.Team에 연관관계를 설정해야 한다. (⇒ 주석 처리된 member.setTeam(team);이 필요)

      

• 💥실습 시, 주의할 점

  • 1) 순수 객체 상태를 고려해서 항상 양쪽에 값을 설정하자

    • If, team.getMembers().add(member)를 삭제한다면? 2가지 문제가 발생할 수 있다. (물론, 없이도 member.setTeam(team)에 의해 팀에 속한 멤버들을 출력할 수는 있다.)
      • 문제 1) em.flush()와 em.clear()도 없을 때, 영속성 컨텍스트(1차 캐시)에만 데이터가 담긴다. DB에 값이 없다.
      • 문제 2) TC 작성 시, 문제가 발생할 수 있다.
    • 결론 : member.setTeam(team) + team.getMembers().add(member) (= 양방향 둘 다 매핑해주자)

  • 2) 연관관계 편의 메소드를 생성하자 (Member의 .setTeam())

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

    • 편의 메소드를 통해 member.changeTeam(team) 하나의 구문으로 양방향 연관관계 설정

  • 3) 양방향 매핑시 무한 루프를 조심하자.

    • 예) toString(), lombok, JSON 라이브러리(Controller에서 Entitiy를 절대 직접 반환하면 안 된다.)

• 양방향 매핑 정리

  • 단방향 매핑만으로도 이미 연관관계 매핑은 완료
  • 양방향 매핑은 반대 방향으로 조회(객체 그래프 탐색) 기능이 추가된 것 뿐
  • JPQL에서 역방향으로 탐색할 일이 많음
  • 단방향 매핑을 잘하고 양방향은 필요할 때 추가해도 됨(위의 예제로 따지면 mappedBy는 필요할 때 사용하자)

• 연관관계 주인 정하는 기준

  • 비즈니스 로직? → 💋연관관계 주인은 외래키의 위치를 기준으로 정해야한다.

---

예제 2) 연관관계 매핑 시작

• 테이블 구조

  

• 객체 구조

  

• 💋단방향 연관관계만 설정해도 되지만 양방향 연관관계를 설정하는 이유는 개발 편의상의 이유 또는 조회를 하기 위해서이다. (필요시, 역방향 조회)

• 멤버 (getter, setter 생략)

  @Entity
  public class Member {
  
      @Id
      @GeneratedValue
      @Column(name = "MEMBER_ID")
      private Long id;
  
      private String name;
      private String city;
      private String street;
      private String zipcode;
  
      @OneToMany(mappedBy = "member")
      private List<Order> orders = new ArrayList<>();
  }

• 주문

  @Entity
  @Table(name = "ORDERS")
  public class Order {
  
      @Id
      @GeneratedValue
      @Column(name = "ORDER_ID")
      private Long id;
  
      private LocalDateTime orderDate;
  
      @Enumerated(EnumType.STRING)
      private OrderStatus status;
  
      @ManyToOne
      @JoinColumn(name = "MEMBER_ID")
      private Member member;
  
      @OneToMany(mappedBy = "order")
      private List<OrderItem> orderItems = new ArrayList<>();
  
  		public void addOrderItem(OrderItem orderItem) {
          orderItems.add(orderItem);
          orderItem.setOrder(this);
      }
  }

• 주문 상품

  @Entity
  public class OrderItem {
  
      @Id
      @GeneratedValue
      @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;
  }

• 상품은 그대로.