zeomzzz

zeomzzz의 TIL


06강. 다양한 연관관계 매핑


1. 연관관계 매핑시 고려사항 3가지


  • 다중성 : 1 : N
    • N:1 : @ManyToOne
    • 1:N : @OneToMany
    • 1:1 : @OneToOne
    • N:N : @ManyToMany - 실제로는 사용 X

  • 단방향 vs. 양방향

    종류 상세
    테이블 • 외래 키 하나로 양쪽 조인 가능 (-> 사실 방향 개념 X)
    객체 • 참조용 필드가 있는 쪽으로만 참조 가능
    • 한쪽만 참조하면 단방향, 양쪽이 서로 참조하면 양방
    (사실 양방향이 아니라 단방향 두 개 ..)
  • 연관관계의 주인 : 양방향인 경우
    • 테이블은 외래 키 하나로 두 테이블이 연관관계를 맺음

    • 객체 양방향 관계는 A -> B, B -> A처럼 참조가 2군데
      -> 둘 중 테이블의 외래 키를 관리할 곳을 지정해야 함

      구분 상세
      연관관계의 주인 외래 키를 관리하는 참조
      주인의 반대편 단순 조회만 가능 (외래키에 영향 X)



2. N:1 (다대일)


N:1 단방향


  • 가장 많이 사용하는 연관관계
  • 다대일의 반대는 일대다
  • 1:N에서 항상 N쪽에 외래키



N:1 양방향


  • 외래 키가 있는 쪽이 연관관계의 주인
  • 양쪽을 서로 참조하도록 개발

  • Team에서도 members를 바로 조회할 수 있게 List members를 추가
@Entity
public class Member {

    @Id @GeneratedValue
		@Column(name = "MEMBER_ID")
		private Long id;

		@Column(name = "USERNAME")
		private String username;

    @ManyToOne // Member가 Many, Team이 One (Member : Team = N : 1)
    @JoinColumn(name = "TEAM_ID") // Join 해야 하는 Column이 뭔지
    private Team team;

    // 생략

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

}

@Entity
public class Team {

    // 생략

    @OneToMany(mappedBy = "team") // Team이 One, members가 Many, 나의 반대편에 team으로 매핑이 되어 있다
    private List<Member> members = new ArrayList<>();

    // 생략

    public void addMember(Member member) {
        member.setTeam(this);
        members.add(member);
    }

}
  • 연관관계 주인인 Member가 외래키를 관리
    -> List member를 추가해도 테이블에는 영향 X



3. 1:N (일대다)


  • 1 쪽이 연관관계 주인인 경우
  • 권장 X



1:N 단방향


  • 연관관계의 주인 : 1:N의 일(1)
    • 테이블 1:N 관계는 항상 다(N) 쪽에 외래 키 -> 관계가 틀어짐
  • 객체와 테이블의 차이 때문에 반대편 테이블의 외래 키를 관리하는 특이한 구조
  • @JoinColumn을 꼭 사용. 또는 중간에 테이블을 하나 추가하는 조인 테이블 방식 사용
  • 단점
    • 엔티티가 관리하는 외래 키가 다른 테이블에 있음
    • 연관관계 관리를 위해 추가로 UPDATE SQL 실행 (다른 곳에 FK가 있으므로)
      -> 일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자!

  • Team에서 외래키 관리
    • Team에서는 Member 조회, Member에서는 Team 조회 X

    -> Team의 List members 값을 바꿨을 때, Member의 TEAM_ID를 바꿔줘야 함

package hellojpa;

import javax.persistence.*;

@Entity
public class Member { // Member에는 팀 정보 X

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    // getter, setter
    // 생략

}

package hellojpa;

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

@Entity
public class Team { // Team에서는 Member 조회 가능 (List members)

    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;
    private String name;
    @OneToMany
    @JoinColumn(name = "TEAM_ID")
    private List<Member> members = new ArrayList<>();

    // getter, setter
    // 생략

    public void addMember(Member member) {
        members.add(member);
    }

}


public class JpaMain {

    // 생략
    Member member = new Member();
    member.setUsername("member1");

    em.persist(member);

    System.out.println("=============");
    System.out.println(member.getId()); // 1
    System.out.println("=============");

    Team team = new Team();
    team.setName("teamA");
    team.getMembers().add(member); // Team table에 업데이트 될 수 있는 내용이 아님

    em.persist(team);

    tx.commit();
    // 생략
}

실행 결과 : team만 수정했는데 member도 수정된 것으로 보여서 의문 발생 가능성 / 운영 어려워짐

Hibernate: 
    call next value for hibernate_sequence
=============
1 // member persist해서 member 객체에도 id 세팅됨
=============
Hibernate: 
    call next value for hibernate_sequence
Hibernate: 
    /* insert hellojpa.Member
        */ insert 
        into
            Member
            (USERNAME, MEMBER_ID) 
        values
            (?, ?)
Hibernate: 
    /* insert hellojpa.Team
        */ insert 
        into
            Team
            (name, TEAM_ID) 
        values
            (?, ?)
Hibernate: 
    /* create one-to-many row hellojpa.Team.members */ update
        Member  // Member에 FK인 TEAM_ID 세팅을 해줘야 함 (성능상 단점이 될 수 있음)
    set
        TEAM_ID=?
    where
        MEMBER_ID=?



일대다 양방향


  • 이런 매핑은 공식적으로 존재X
  • 읽기 전용 필드를 사용해서 양방향처럼 사용 : @JoinColumn(insertable=false, updatable=false)
  • 결론 : 다대일 양방향을 사용하자 ^^


@Entity
public class Member {

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID", insertable = false, updatable = false) // 여기가 중요!! 매핑은 되어있는데 읽기 전용
    private Team team;

    // getter, setter
    // 생략

}

@Entity
public class Team {

    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;
    private String name;

    @OneToMany
    @JoinColumn(name = "TEAM_ID")
    private List<Member> members = new ArrayList<>();

    // getter, setter
    // 생략

    public void addMember(Member member) {
        members.add(member);
    }

}



4. 1:1 (일대일)


일대일 관계


  • 일대일 관계는 그 반대도 일대일
  • 주 테이블에 외래 키, 대상 테이블에 외래 키
  • 외래 키에 데이터베이스 유니크(UNI) 제약조건 추가
구분 상세
주 테이블에 외래 키
(주테이블 : 주로 access하는 테이블)		 - 주 객체가 대상 객체의 참조를 가지는 것 처럼 주 테이블에 외래 키를 두고 대상 테이블을 찾음
- 객체지향 개발자 선호
- JPA 매핑 편리
- 장점: 주 테이블만 조회해도 대상 테이블에 데이터가 있는지 확인 가능
- 단점: 값이 없으면 외래 키에 null 허용 (-> DB 입장에서 별로..)
대상 테이블에 외래 키 - 대상 테이블에 외래 키가 존재
- 전통적인 데이터베이스 개발자 선호
- 장점: 주 테이블과 대상 테이블을 일대일에서 일대다 관계로 변경할 때 테이블 구조 유지
- 단점: 프록시 기능의 한계로 지연 로딩으로 설정해도 항상 즉시 로딩됨(프록시는 뒤에서 설명) (이게 치명적….)



일대일: 주 테이블에 외래 키 단방향


  • 다대일(@ManyToOne) 단방향 매핑과 유사
  • Member가 주 엔티티라고 가정할 때,

  • UNIQUE 제약조건은 Member 또는 Locker 어디에든 넣어도 됨



일대일: 주 테이블에 외래 키 양방향


  • 다대일 양방향 매핑처럼 외래 키가 있는 곳이 연관관계의 주인
  • 반대편은 mappedBy 적용

@Entity
public class Member { // 주 엔티티

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID", insertable = false, updatable = false)
    private Team team;

    @OneToOne
    @JoinColumn(name = "LOCKER_ID") // 이걸 넣지 않으면 자동으로 값이 들어가는데, 직관적이지 않음
    private Locker locker;

    // getter, setter

}

@Entity
public class Locker {

    @Id @GeneratedValue
    private Long id;

    private String name;

    @OneToOne(mappedBy = "locker") // 양방향 매핑. 읽기 전용
    private Member member;

}



일대일: 대상 테이블에 외래 키 단방향


  • 지원도 되지 않고 구현도 불가능
  • 양방향 관계는 지원



일대일: 대상 테이블에 외래 키 양방향


  • 일대일 주 테이블에 외래 키
  • 양방향과 매핑 방법은 같음



5. N:M (다대다)


N:M


쓰면 안된다!

  • 관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없음
  • 연결 테이블을 추가해서 일대다, 다대일 관계로 풀어내야함

ex. 하나의 멤버가 여러 개의 상품을 선택할 수 있는 경우

  -> Member에 대한 Product도 여러 개, Product에 대한 Member도 여러 개

  • 객체는 컬렉션을 사용해서 객체 2개로 다대다 관계 가능

  • @ManyToMany 사용
  • @JoinTable로 연결 테이블 지정
  • 다대다 매핑: 단방향, 양방향 가능
@Entity
public class Member {

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID", insertable = false, updatable = false)
    private Team team;

    @OneToOne
    @JoinColumn(name = "LOCKER_ID")
    private Locker locker;

    @ManyToMany
    @JoinTable(name = "MEMBER_PRODUCT") // name으로 연결 테이블이 생성됨
    private List<Product> products = new ArrayList<>();

	// getter, setter

}

@Entity
public class Product {

    @Id @GeneratedValue
    private Long id;

    private String name;

		@ManyToMany(mappedBy = "products")
		private List<Member> members = new ArrayList<>();

		// getter, setter

}
  • 한계
    • 편리해 보이지만 실무에서 사용X
    • 연결 테이블이 단순히 연결만 하고 끝나지 않음 : 중간 테이블이 숨겨져 있어서 예상 밖의 쿼리가 나갈 수 있음

  • 한계 극복
    • 연결 테이블을 엔티티로 승격하여 엔티티 추가

    • @ManyToMany -> @OneToMany, @ManyToOne

@Entity
public class Member {

    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name = "USERNAME")
    private String username;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID", insertable = false, updatable = false)
    private Team team;

    @OneToOne
    @JoinColumn(name = "LOCKER_ID")
    private Locker locker;

    @OneToMany(mappedBy = "member")
		private List<MemberProduct> memberProducts = new ArrayLists<>();

}

@Entity
public class Product {

    @Id @GeneratedValue
    private Long id;

    private String name;

    @OneToMany(mappedBy = "products")
    private List<MemberProduct> members = new ArrayList<>();

}

@Entity
public class MemberProduct {

    @Id @GeneratedValue
    private Long id;

    @ManyToOne
    @JoinColumn(name = "MEMBER_ID")
    private Member member;

    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID")
    private Product product;

}



N:M 관계는 1:N, N:1로


  • 테이블의 N:M 관계는 중간 테이블을 이용해서 1:N, N:1
  • 실전에서는 @ManyToMany 사용X
    • 실제로는 중간 테이블이 단순 X
    • @ManyToMany는 제약 : 필드 추가X, 엔티티 테이블 불일치



@JoinColumn


  • 외래 키를 매핑할 때 사용
속성 설명 기본값
name - 매핑할 외래 키 이름 필드명 + _ + 참조하는 테이블의 기본 키 컬럼명
referencedColumnName - 외래 키가 참조하는 대상 테이블의 컬럼명
- 컬럼명이 달라질 때		 참조하는 테이블의 기본키 컬럼명
foreignKey(DDL) - 외래 키 제약조건을 직접 지정할 수 있음
- 이 속성은 테이블을 생성할 때만 사용		  
unique
nullable
insertable
updatable
columnDefinition
table		 - @Column의 속성과 같음  



@ManyToOne - 주요 속성


  • 다대일 관계 매핑
속성 설명 기본값
optional - false로 설정하면 연관된 엔티티가 항상 있어야 함 TRUE
fetch - 글로벌 페치 전략을 설정 @ManyToOne=FetchType.EAGER
@OneToMany=FetchType.LAZY    
cascade - 영속성 전이 기능을 사용  
targetEntity - 연관된 엔티티의 타입 정보를 설정
- 이 기능은 거의 사용 X
- 컬렉션을 사용해도 제네릭으로 타입 정보를 알 수 있음		  



@OneToMany - 주요 속성


  • 일대다 관계 매핑
속성 설명 기본값
mappedBy - 연관관계의 주인 필드를 선택  
fetch - 글로벌 페치 전략을 설정 @ManyToOne=FetchType.EAGER
@OneToMany=FetchType.LAZY    
cascade - 영속성 전이 기능을 사용  
targetEntity - 연관된 엔티티의 타입 정보를 설정
- 이 기능은 거의 사용 X
- 컬렉션을 사용해도 제네릭으로 타입 정보를 알 수 있음		  
  • 일대다는 mappedBy 있는데, 다대일은 없음



Leave a comment

You may also enjoy