[JPA] #9 연관관계 매핑(3) - 다중성 (ManyToOne, ManyToOne, OneToOne, ManyToMany)

🗺 RoadMap/Jpa

[JPA] #9 연관관계 매핑(3) - 다중성 (ManyToOne, ManyToOne, OneToOne, ManyToMany)

an2z 2022. 10. 11. 00:10

본 포스팅은 인프런 - 자바 ORM 표준 JPA 프로그래밍 (기본편) 을 강의를 바탕으로 공부하고 정리한 글입니다.

연관관계 매핑시 고려사항

다중성
- 다대일 : @ManyToOne
- 일대다 : @OneToMany
- 일대일 : @OneToOne
- 다대다 : @ManyToMany
단방향, 양방향
- 테이블
  - 외래 키 하나로 양쪽에 조인이 가능하다.
  - 테이블은 사실 방향이라는 개념이 없다.
- 객체
  - 참조용 필드가 있는 쪽으로만 참조가 가능하다.
  - 한쪽만 참조하면 단방향
  - 양쪽이 서로 참조하면 양방향 → 하지만 사실 이 양방향도 2개의 단방향이 있는 것이다.
연관관계 주인
- 테이블은 외래 키 하나로 두 테이블이 연관관계를 맺지만,
- 객체의 양방향 관계는 A → B, B → A 처럼 2군데에 참조를 가진다.
- 따라서 둘 중 테이블의 외래 키를 관리할 곳을 정해야 한다.
  - 연관관계 주인 : 외래 키를 관리하는 참조
  - 주인의 반대편 : 외래 키에 영향을 주지 않으며, 단순 조회의 용도이다.

이 중 다중성에 대해 알아보자.

다대일 [N:1]

다대일 단방향

테이블 상 항상 다(N)쪽에 외래 키가 있어야 한다.
가장 많이 사용하는 연관관계
다대일의 반대는 일대다

@Entity
public class Member {
    @Id
    @GeneratedValue
    @Column(name = "member_id")
    private Long id;

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

    @ManyToOne
    @JoinColumn(name = "team_id")
    private Team team;
}

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

    private String name;
}

다대일 양방향

외래 키가 있는 쪽이 연관관계 주인이다.
양쪽을 서로 참조하도록 개발한다.
양방향 매핑의 경우 연관관계 편의 메소드가 필요하다.

@Entity
public class Member {
    @Id
    @GeneratedValue
    @Column(name = "member_id")
    private Long id;

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

    @ManyToOne
    @JoinColumn(name = "team_id")
    private Team team;
    
    /**
     * 연관관계 편의 메소드
     */
    public void changeTeam(Team team) {
        this.team = team;
        team.getMembers().add(this);
    }
}

양방향 매핑일 경우 연관관계 편의 메소드 생성이 필요하며, 다(N)쪽이 연관관계의 주인이 된다.

@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<>();
}

주인의 반대편에서는 mappedBy로 주인을 지정해준다.

일대다 [1:N]

일대다 단방향

일대다 단방향은 일대다(1:N)에서 일(1)이 연관관계의 주인이다.
테이블 일대다 관계는 항상 다(N)쪽에 외래 키가 있다.
객체와 테이블의 차이 때문에 반대편 테이블의 외래 키를 관리하는 특이한 구조이다.
@JoinColumn을 꼭 사용해야한다. 그렇지 않으면 조인 테이블 방식을 사용한다. (중간에 테이블을 하나 추가함)
- 중간에 테이블 하나가 추가되므로 성능상 애매하고 운영하기가 쉽지가 않다.

💡 일대다 단방향 매핑의 단점

엔티티가 관리하는 외래 키가 다른 테이블에 있음
연관관계 관리를 위해 추가로 UPDATE SQL을 실행함
결론적으로 일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하도록 하는 것을 권장한다.

💻 DDL

Hibernate: 
   
    create table Team_Member (
       Team_team_id bigint not null,
        members_member_id bigint not null
    )

@Entity
public class Member {
    @Id
    @GeneratedValue
    @Column(name = "member_id")
    private Long id;

    @Column(name = "user_name")
    private String username;
}

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

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

일대다 양방향

이러한 매핑은JPA 공식적으로 존재하지는 않는다.
@JoinColumn(name = "", insertable = false, updatable = false)
- insertable, updatable을 false로 두면 읽기 전용으로 지정된다.
읽기 전용 필드를 사용해서 양방향 처럼 사용하는 방법이다.
일대다 양방향을 사용하기보다 다대일 양방향을 사용하도록 하자.

@Entity
public class Member {
    @Id
    @GeneratedValue
    @Column(name = "member_id")
    private Long id;

    @Column(name = "user_name")
    private String username;
    
    @ManyToOne
    @JoinColumn(name = "team_id", insertable = false, updatable = false)
    private Team team;
}

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

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

일대일 [1:1]

일대일 연관관계는 주 테이블이나 대상 테이블 중에 아무곳이나 외래 키 선택이 가능하다.
- 주 테이블에 외래 키
  - 주 객체가 대상 객체의 참조를 가지는 것처럼 주 테이블에 외래 키를 두고 대상 테이블을 찾는다.
  - 객체지향 개발자가 선호하는 방식이다.
  - JPA 매핑이 편리하다.
  - 장점 : 주 테이블만 조회해도 대상 테이블에 데이터가 있는지 확인이 가능하다.
  - 단점 : 값이 없으면 외래 키에 null을 허용해야 한다.
- 대상 테이블에 외래키
  - 대상 테이블에 외래 키가 존재하는 방식이다.
  - 전통적인 데이터베이스 개발자가 선호한다.
  - 장점 : 주 테이블과 대상 테이블을 일대일에서 일대다 관계로 변경할 때 테이블 구조가 유지된다.
  - 단점 : 프록시 기능의 한계로 지연 로딩으로 설정해도 항상 즉시 로딩된다.
외래 키에 데이터베이스 유니크(UNI) 제약 조건 추가

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

주 테이블(MEMBER)에 외래 키 단방향

이는 다대일(@ManyToOne) 단방향 매핑과 유사하다.

@Entity
public class Member {
    @Id
    @GeneratedValue
    @Column(name = "member_id")
    private Long id;

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

    @ManyToOne
    @JoinColumn(name = "team_id")
    private Team team;

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

@Entity
public class Locker {
    @Id
    @GeneratedValue
    @Column(name = "locker_id")
    private Long id;

    private String name;
}

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

대상 테이블(LOCKER)에 외래 키 단방향

이러한 단방향 관계는 JPA가 지원하지 않는다.
양방향 관계는 지원

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

주 테이블에 외래 키 양방향

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

@Entity
public class Member {
    @Id
    @GeneratedValue
    @Column(name = "member_id")
    private Long id;

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

    @ManyToOne
    @JoinColumn(name = "team_id")
    private Team team;

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

@Entity
public class Locker {
    @Id
    @GeneratedValue
    @Column(name = "locker_id")
    private Long id;

    private String name;
    
    @OneToOne(mappedBy = "locker")
    private Member member;
}

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

대상 테이블(LOCKER)에 외래 키 양방향

일대일 주 테이블에 외래 키 양방향과 매핑 방법은 동일하다.

다대다 [N:M]

관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없다.
따라서 중간에 연결 테이블을 추가해서 일대다, 다대일 관계로 풀어내야 한다.
객체는 컬렉션을 사용해 객체 2개로 다대다 관계가 가능하다.

@Entity
public class Member {
    @ManyToMany
    @JoinTable(name = "member_product") // 중간 테이블 생성
    private List<Product> products = new ArrayList<>();
}

@JoinTable을 통해 중간 테이블의 이름을 지정해줄 수 있다.

@Entity
public class Product {
    @ManyToMany(mappedBy = "products")
    private List<Member> members = new ArrayList<>();
}

다대다 매핑 한계

편리해보이지만 실무에서는 사용할 수 없다.
연결 테이블이 단순히 연결만 하고 끝나지 않는다.
중간 테이블에 매핑 정보만 들어가고 추가 데이터(주문시간, 수량 )를 더 넣는 것이 불가능하다.

다대다 매핑 한계 극복

연결 테이블용 엔티티를 추가한다. (연결 테이블을 엔티티로 승격)
@ManyToMany → @OneToMany + @ManyToOne으로 풀어내자.

@Entity
public class Member {
   ...

    @OneToMany(mappedBy = "member")
    private List<MemberProduct> memberProducts = 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;
}

@Entity
public class Product {
    @Id
    @GeneratedValue
    private Long id;

    private String name;

    @OneToMany(mappedBy = "product")
    private List<MemberProduct> memberProducts = new ArrayList<>();
}