[JPA] 연관관계 매핑(다대일, 일대다, 일대일, 다대다)

 

자바 ORM 표준 JPA 프로그래밍(지은이: 김영한)

김영한님의 자바 ORM 표준 JPA 프로그래밍을 읽고 정리한 글입니다. 

 

 

 

1. 엔티티 연관관계 매핑

 

다중성

• 다대일(@ManyToOne)
• 일대다(@OneToMany)
• 일대일(@OneToOne)
• 다대다(@ManyToMany)

 

단방향, 양방향

• 단방향: 객체 관계에서 한쪽만 참조
• 양방향: 객체 관계에서 양쪽이 서로 참조

 

연관관계의 주인

• 두 객체 연관관계 중 외래 키를 관리하는 쪽을 주인이라 함
• 외래 키를 가진 테이블과 매핑한 엔티티를 보통 연관관계의 주인으로 선택
• 주인이 아닌 방향은 외래 키 변경 불가, 읽기만 가능
• 주인이 아닌 쪽은 mappedBy 속성을 사용하여 주인 필드 이름을 값으로 입력

 

 

 

1. 다대일(@ManyToOne)

 

다대일 단방향 [N:1]

 

회원 엔티티

@Entity
public class Member {
    
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;
    
    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;
}

 

• 회원은 Member.team으로 팀 엔티티를 참조 가능
• 팀은 회원 참조 필드 없어서 참조 불가능
• 따라서 회원과 팀은 다대일 단방향 연관관계
• @JoinColumn(name = "TEAM_ID")를 사용해서 Member.team 필드를 TEAM_ID FK와 매핑

 

 

다대일 양방향 [N:1, 1:N]

실선이 연관관계의 주인(Member.team)이고 점선(Team.members)은 주인이 아니다. 

 

회원 엔티티

@Entity
public class Member {

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

    private String username;

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

    public void setTeam(Team team) {
        this.team = team;
        // 무한루프에 빠지지 않도록 체크
        if(!team.getMembers().contains(this)) {

            team.getMembers().add(this)
        }
    }
}

 

팀 엔티티

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

    public void addMember(Member member) {
        this.members.add(member);
        // 무한루프에 빠지지 않도록 체크
        if (member.getTeam() != this) {
            member.setTeam(this);
        }
    }
}

 

• 양방향은 FK가 있는 쪽이 연관관계의 주인
• 1:N, N:1 경우에 항상 N에 FK가 있으므로 N 쪽이 연관관계의 주인
• JPA는 FK를 관리할 때 연관관계의 주인만 사용
• 양방향 연관관계는 항상 서로를 참조해야 함

 

 

 

2. 일대다(@OneToMany)

 

일대다 단방향 [1:N]

 

팀 엔티티

@Entity
public class Team {

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

    private String name;

    @OneToMany(mappedBy = "team")
    @JoinColumn(name = "TEAM_ID")  // MEMBER 테이블의 TEAM_ID (FK)
    private List<Member> members = new ArrayList<Member>();
}

 

회원 엔티티

@Entity
public class Member {

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

    private String username;
}

 

• 1:N 관계에선 N 쪽에 FK가 있기 때문에 팀 엔티티의 Team.members로 회원 테이블의 TEAM_ID FK 관리
• 따라서 1쪽에서 관리하는 FK가 N 쪽의 테이블에 있다는 것이 단점
• 이 경우 엔티티 저장과 연관관계 처리를 위해 insert 이외에 추가로 update sql을 실행해야 함
• 결론 => 일대다 단방향보다는 다대일 양방향 매핑을 사용하자!!!

 

 

일대다 양방향 [1:N, N:1]

1:N, N:1 관계에서 항상 N 쪽에 FK가 있기 때문에 양방향 매핑에서 @OneToMany는 연관관계의 주인이 될 수 없다. 따라서 일이 연관관계의 주인인 일대다 양방향 매핑은 존재하지 않는다. 다만 일대다 단방향 매핑 반대편에 다대일 단방향 매핑을 읽기 전용으로 추가해서 일대다 양방향처럼 보이도록 할 수 있다. 하지만 이 방법도 위에서 설명한 일대다 단방향 매핑의 단점을 그대로 가진다. 

 

 

팀 엔티티

@Entity
public class Team {

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

    private String name;

    @OneToMany(mappedBy = "team")
    @JoinColumn(name = "TEAM_ID")  // MEMBER 테이블의 TEAM_ID (FK)
    private List<Member> members = new ArrayList<Member>();
}

 

회원 엔티티

@Entity
public class Member {

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

    private String username;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID", insertable = false, updatable = false)  // 읽기 전용
    private Team team;
}

 

 

 

3. 일대일 [1:1]

 

주 테이블에 FK

• 주 테이블에 FK를 두고 대상 테이블 참조
• FK를 객체 참조와 비슷하게 사용할 수 있음
• 주 테이블만 확인해도 대상 테이블과 연관관계가 있는지 확인 가능

 

단방향

회원 MEMBER가 주 테이블이고 사물함 LOCKER가 대상 테이블인 예시

회원, 사물함 엔티티

@Entity
public class Member {

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

    private String username;

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

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

 

양방향

MEMBER 테이블이 FK로 LOCKER_ID를 가진다고 가정한다. 

 

회원, 사물함 엔티티

@Entity
public class Member {

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

    private String username;

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

 

• MEMBER 테이블이 FK를 가지고 있으므로 Member.locker가 연관관계의 주인
• 따라서 Locker.member는 mappedBy를 선언해서 연관관계의 주인이 아니라고 설정

 

 

 

대상 테이블에 FK

• 테이블 관계를 1:1에서 1:N으로 쉽게 변경 가능

 

단방향

1:1 관계에서 대상 테이블에 FK가 있는 단방향 관계는 JPA에서 지원하지 않는다. 

 

양방향

회원 MEMBER가 주 테이블이고 사물함 LOCKER가 대상 테이블인 예시

회원, 사물함 엔티티

@Entity
public class Member {

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

    private String username;

    @OneToOne(mappedBy = "member")
    private Locker locker;
}

@Entity
public class Locker {

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

    private String name;

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

 

 

 

4. 다대다 [N:N]

 

관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없다. 그래서 보통 다대다 관계를 일대다, 다대일 관계로 풀어내는 연결 테이블을 사용한다. 

 

예시로 회원과 상품 테이블을 생각해보면, 회원들은 여러 상품을 주문할 수 있고 상품들은 여러 회원에 의해 주문될 수 있는 다대다 관계이다. 이 경우 회원 테이블과 상품 테이블만으로 이 관계를 표현할 수 없고 Member_Product와 같은 연결 테이블을 이용해 관계를 표현해야 한다. 

 

하지만 객체는 테이블과 다르게 객체 2개로 다대다 관계를 만들 수 있다. @ManyToMany를 이용하여 다음 그림처럼 다대다 관계를 매핑할 수 있다. 

 

 

단방향

회원, 상품 엔티티

@Entity
public class Member {

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

    private String username;

    @ManyToMany
    @JoinTable(name = "MEMBER_PRODUCT", 
            joinColumns = @JoinColumn(name = "MEMBER_ID"), 
            inverseJoinColumns = @JoinColumn(name = "PRODUCT_ID"))
    private List<Product> products = new ArrayList<Product>();
}

@Entity
public class Product {

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

    private String name;
}

 

 

양방향

회원 엔티티에 addProduct, 상품 엔티티에 역방향 매핑 추가

@Entity
public class Member {

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

    private String username;

    @ManyToMany
    @JoinTable(name = "MEMBER_PRODUCT",
            joinColumns = @JoinColumn(name = "MEMBER_ID"),
            inverseJoinColumns = @JoinColumn(name = "PRODUCT_ID"))
    private List<Product> products = new ArrayList<Product>();
    
    public void addProduct(Product product) {
        // 생략
        products.add(product);
        product.getMembers().add(this);
    }
}

@Entity
public class Product {

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

    private String name;
    
    @ManyToMany(mappedBy = "products")
    private List<Member> members;
}

 

@ManyToMany를 사용해서 연결 테이블을 처리할 경우 연결 테이블에 컬럼을 추가할 수 없다. 따라서 이 경우에는 연결 엔티티를 만들고 이곳에 추가한 컬럼들을 매핑해야 한다. 

 

예를 들어, Member_Product 테이블에 주문 수량과 주문 날짜 컬럼을 추가해야 한다면 다음과 같이 연관관계를 설정할 수 있다. 이 경우 MemberProduct 엔티티는 (MEMBER_ID, PRODUCT_ID)를 복합키로 가지게 된다. 

 

 

 

 

 

 

참고: 자바 ORM 표준 JPA 프로그래밍(지은이: 김영한)