[Spring JPA] 다양한 연관관계 매핑

 

 

안녕하세요. 저번 게시글에서 다대일 단방향 매핑과 양방향 매핑에 대해서 알아보았는데요. 오늘은 다대일, 일대다, 일대일, 다대다 매핑에 대해 알아보려고 합니다. 

 

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

 

 

다대일

다대일 관계의 반대 방향은 일대다 관계고 일대다 관계의 반대 방향은 항상 다대일 관계이다. 데이터베이스 테이블의 일, 다 관계에서 외래 키는 항상 다쪽에 있다. 

따라서 겍채 양방향 관계에서 연관관계 주인은 항상 다쪽이다. 회원과 팀 관계에서 연관관계 주인은 회원이다. 

 

다대일 단방향

다대일 단뱡향 관계의 코드이다. 

@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으로 팀 엔티티를 참조할 수 있지만 팀에는 회원을 참조하는 필드가 없다. 

 

 

다대일 양방향

회원을 참조하는 필드를 추가하려면 양방향 연관관계 설정을 해주어야한다. 양방향은 외래 키가 있는 쪽이 연관관계 주인이다. 연관관계 주인이 아닌 쪽은 mappedBy로 연관관계 주인이 아님을 밝혀야한다. 

 

양방향 연관관계를 설정한 뒤, 서로를 참조하는 메서드를 추가해주었다. 

@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")
    List<Member> members = new ArrayList<>();
    
    public void addMember(Member member) {
    	this.members.add(member);
        if (member.getTeam() != this) {
            member.setTeam(this);
        }	
    }
}

 

 

일대다

일대다 관계는 다대일 관계의 반대 방향이다. 일대다 관계는 엔티티를 하나 이상 참조할 수 있으므로 자바 컬렉션인 Collection, List, Set, Map 중에 하나를 사용해야 한다. 

 

일대다 단방향

일대다 단방향 관계는 약간 특이한데 팀 엔티티의 Team.members로 회원 테이블의 TEAM_ID 외래 키를 관리한다. 보통 자신이 매핑한 테이블의 외래 키를 관리하는데, 이 매핑의 경우 반대쪽 테이블에 있는 외래 키를 관리한다. 

@Entity
public class Team {
	
    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;
    
    private String name;
    
    @OneToMany
    @JoinColumn(name = "TEAM_ID") // member 테이블의 TEAM_ID
    private List<Member> members = new ArrayList<>();
}

@Entity
public class Member {
	
    @Id @GeneratedValue
    @Column(name = "MEMBER_ID")
    private Long id;
    
    private String username;
}

일대다 단방향 관계를 매핑할 때는 @JoinColumn을 명시해야한다. 그렇지 않으면 JPA는 연결 테이블을 중간에 두고 연관관계를 관리하는 조인 테이블 전략을 기본으로 사용해서 매핑한다. 

 

일대다 단방향 매핑의 단점은 매핑한 객체가 관리하는 외래 키가 다른 테이블에 있다는 점이다. 본인 테이블에 외래 키가 있다면 엔티티의 저장과 연관관계 처리를 insert 쿼리로 한 번으로 끝낼 수 있지만, 다른 테이블에 외래 키가 있으면 연관관계 처리를 위해 update 쿼리를 추가로 실행해야 한다. 

public void testSave() {
	
    Member member1 = new Member("member1");
    Member member2 = new Member("member2");
    
    Team team1 = new Team("team1");
    team1.getMembers().add(member1);
    team1.getMembers().add(member2);
    
    em.persist(member1); // insert query (member1)
    em.persist(member2); // insert query (member2)
    em.persist(team1)l // insert query (team1) update query (member1) update query (member2)
    
    transaction.commit();
}

Member 엔티티는 Team 엔티티를 모른다. 연관관계에 대한 정보는 Team 엔티티의 members가 관리한다. 따라서 Member 엔티티를 저장할 때는 Member 테이블의 TEAM_ID 외래 키에 아무 것도 저장되지 않는다. 대신 Team 엔티티를 저장할 때 Team.members의 참조 값을 확인하여 회원 테이블의 TEAM_ID 외래 키를 업데이트한다. 

 

따라서 일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하는 것이 좋다. 

 

일대다 양방향

일대다 양방향 매핑은 존재하지 않는다. 대신 다대일 양방향 매핑을 사용한다. 

더 정확히 얘기하면 양방향 매핑에서 @OneToMany는 연관관계 주인이 될 수 없다. 관계형 데이터베이스 특성상 일대다, 다대일 관계는 항상 다 쪽에 외래 키가 있기 때문이다. 

 

그렇다고 불가한 것은 아니다. 일대다 단방향 매핑 반대편에 같은 외래 키를 사용하는 다대일 단방향 매핑을 읽기 전용으로 하나 추가하면 된다. 

@Entity
public class Team {
	
    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;
    
    private String name;
    
    @OneToMany
    @JoinColumn(name = "TEAM_ID") // member 테이블의 TEAM_ID
    private List<Member> members = new ArrayList<>();
}

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

이 방법은 일대다 양방향 매핑이라기보다는 일대다 단방향 매핑 반대편에 다대일 단방향 매핑을 읽기 전용으로 추가해서 일대다 양방향처럼 보이기 하는 방법이며, 일대다 단방향이 갖는 단점을 그대로 가진다. 

 

 

일대일

일대일 관계는 양쪽이 서로 하나의 관계만 가진다. 

예를 들어 회원은 하나의 사물함만 사용하고 사물함도 하나의 회원에 의해서만 사용된다. 

 

일대일 관계 특징

일대일 관계는 그 반대도 일대일이다. 

테이블 관계에서 일대다, 다대일은 항상 다쪽이 외래 키를 갖는다. 반면에 일대일 관계는 주 테이블이나 대상 테이블 둘 중 어느 곳이나 외래 키를 가질 수 있다. 

 

일대일 관계는 주 테이블이나 대상 테이블 중에 누가 외래 키를 가질지 선택해야 한다. 

 

주테이블에 외래키 - 단방향

Member가 주 테이블이고, Locker가 대상 테이블이다. 

일대일 관계이므로 객체 매핑에 @OneToOne을 사용했고, 데이터베이스에는 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;
}

 

주테이블에 외래키 - 양방향

양방향이므로 연관관계 주인을 정해야한다. Member 테이블이 외래 키를 갖고 있으므로 Member 엔티티에 있는 Member.locker가 연관관계 주인이 된다. 따라서 Locker.member는 mappedBy를 선언해서 연관관계 주인이 아님을 밝혔다. 

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

 

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

일대일 관계 중 대상 테이블에 외래 키가 있는 단방향 관계는 JPA에서 지원하지 않는다. 그리고 이런 모양으로 매핑할 수 있는 방법도 없다. 이 때는 단방향 관계는 Locker에서 Member 방향으로 수정하거나, 양방향 관계로 만들고 Locker를 연관관계 주인으로 설정해야한다. 

 

JPA2.0부터는 일대다 단방향 관계에서 대상 테이블에 외래 키가 있는 매핑을 허용했지만 일대일 단방향에서는 허용하지 않는다. 

 

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

일대일 매핑에서 대상 테이블에 외래 키를 두고 싶으면 이렇게 양방향으로 매핑한다. 주 엔티티인 Member 엔티티 대신에 대상 엔티티인 Locker를 연관관계의 주인으로 만들어서 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;
}

 

 

다대다

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

 

예를 들어 회원들은 상품을 주문한다. 반대로 상품들은 회원들에 의해 주문된다. 둘은 다대다 관계이다. 이 관계는 회원 테이블과 상품 테이블만으로는 이 관계를 표현할 수 없다. 

 

그래서 아래 그림과 같이 연결 테이블을 추가해야 한다. 

 

그런데 객체는 테이블과 다르게 객체 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<Prodect> products = new ArrayList<>();
}

@Entity
public class Product {
	
    @Id @Column(name = "PRODUCT_ID")
    private String id;
    
    private String name;
}

@ManyToMany와 @JoinTable을 사용해서 연결 테이블을 바로 매핑했다. 

따라서 회원과 상품을 연결하는 회원_상품 엔티티 없이 매핑을 완료할 수 있다. 

 

@JoinTable.name : 연결 테이블을 지정한다. 여기서는 MEMBER_PRODECT 테이블을 선택했다.

@JoinTable.joinColumns : 현재 방향인 회원과 매핑할 조인 컬럼 정보를 지정한다. 이를 MEMBER_ID로 지정했다.

@JoinTable.inverseJoinColumns : 반대 방향인 상품과 매핑할 조인 컬럼 정보를 지정한다. PRODUCT_ID로 지정했다. 

 

여기서 MEMBER_PRODUCT 테이블은 다대다 관계를 일대다, 다대일 관계로 풀어내기 위해 필요한 연결 테이블일 뿐이다.

 

아래는 다대다 관계를 저장하는 예제이다.

public void save() {
	
    Product productA = new Product();
    productA.setId("productA");
    productA.setName("상품A");
    em.persist(productA);
    
    Member member1 = new Member();
    member1.setId("member1");
    member1.setUsername("회원1");
    member1.getProducts().add(productA); // 연관관계 설정
    em.persist(member1);
}

 

이 코드를 실행하면 아래와 같은 SQL이 실행된다. 

INSERT INTO PRODUCT ...
INSERT INTO MEMBER ...
INSERT INTO MEMBER_PRODUCT ...

 

순서대로 저장한 후에 탐색해보면 저장해두었던 상품1이 조회된다. 

public void find() {
	
    Member member = em.find(Member.class, "member1");
    List<Product> products = member.getProducts();
    for (Product product : products) {
    	System.out.println("product.name = " + product.getName());
    }
}

 

이 때 아래의 SQL이 실행된다. 

연결 테이블인 member_product와 상품 테이블을 조인해서 연관된 상품을 조회한다. 

SELECT * FROM MEMBER_PRODUCT MP
INNER JOIN PRODUCT P ON MP.PRODUCT_ID = P.PRODUCT_ID
WHERE MP.MEMBER_ID=?

 

다대다 양방향

다대다 매핑이므로 역방향도 @ManyToMany를 사용한다. 그리고 양쪽 중 원하는 곳에 mappedBy로 연관관계 주인을 지정한다. 

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

 

다대다의 양방향 연관관계 설정을 편의 메서드로 회원 엔티티에 추가하자. 

public void addProduct(Product product) {
	
    products.add(product);
    product.getMembers().add(this);
}

 

양방향 연관관계를 만들었으므로 product.getMembers()를 사용해서 역방향으로 객체 그래프를 탐색할 수 있다. 

public void find() {
	
    Product product = em.find(Product.class, "productA");
    List<Member> members = product.getMembers();
    for (Member member : members) {
    	System.out.println("member = " + member.getUsername());
    }
}

 

 

@ManyToMany를 사용하면 연결 테이블을 자동으로 처리해주므로 도메인 모델이 단순해지고 여러가지로 편리하다. 하지만 이 매핑을 실무에서 사용하기에는 한계가 있다. 

예를 들어 회원이 상품을 주문하면 연결 테이블에 단순히 주문한 회원 아이디와 상품 아이디만 담고 끝나지 않는다. 보통은 연결 테이블에 주문 수량 컬럼이나 주문한 날짜와 같은 컬럼이 필요한다. 

 

 

다대다 양방향 복합 키 사용

이제 연결 테이블에 주문 날짜와 주문 수량 컬럼을 추가했다. 

 

회원과 회원 상품은 양방향 관계를 만들었다. 회원 상품 엔티티 쪽이 외래 키를 갖고 있으므로 연관관계의 주인이 돤다. 

@Entity
public class Member {
	
    @Id @Column(name = "MEMBER_ID")
    private String id;
    
    @OneToMany(mappedBy = "member")
    private List<MemberProduct> memberProducts;
}

 

상품 엔티티에서 회원 상품 엔티티로 객체 그래프 탐색이 필요하지 않다고 생각하여 연관관계를 만들지 않았다. 

@Entity
public class Product {
	
    @Id @Column(name = "PRODUCT_ID")
    private String id;
    
    private Strign name;
}

 

회원 상품 엔티티와 회원 상품 식별자 클래스이다. 

회원 상품 엔티티를 보면 기본 키를 매핑하는 @Id와 외래 키를 매핑하는 @JoinColumn을 동시에 사용해서 기본 키 + 외래 키를 한 번에 매핑했다. 그리고 @IdClass를 사용해서 복합 기본 키를 매핑했다. 

@Entity
@IdClass(MemberProductId.class)
public class MemberProduct {
	
    @Id
    @ManyToOne
    @JoinColumn(name = "MEMBER_ID")
    private Member member;
    
    @Id
    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID")
    private Product product;
    
    private int orderAmount;
}

 

JPA에서 복합 키를 사용하려면 별도의 식별자 클래스를 만들어야한다. 그리고 엔티티에 @IdClass를 사용해서 식별자 클래스를 지정하면 된다. 

public class MemberProductId implements Serializable {
	
    private String member; // MemberProduct.member와 연결
    private String product; // MemberProduct.product와 연결
    
    // hashCode and equeals
}

 

복합 키를 위한 식별자 클래스 특징

복합 키는 별도의 식별자 클래스로 만들어야 한다.

Serializable을 구현해야 한다.

equals와 hashCode 메서드를 구현해야 한다.

기본 생성자가 있어야한다.

식별자 클래스는 public 이어야 한다.

@IdClass를 사용하는 방법 외에 @EmbeddedId를 사용하는 방법도 있다. 

 

이렇게 다른 테이블의 기본 키를 가져와서 자신의 기본 키로 사용하는 것을 데이터베이스 용어로 식별 관계라고 한다. 

 

 

정리해보면 회원 상품은 회원의 기본 키를 받아와서 자신의 기본 키로 사용함과 동시에 회원과의 관계를 위한 외래 키로 사용한다. 그리고 상품의 기본 키도 받아서 자신의 기본 키로 사용함과 동시에 상품과의 관계를 위한 외래 키로 사용한다. 또한 MemberProductId 식별자 클래스로 두 기본 키를 묶어서 복합 기본 키로 사용한다. 

 

 

이렇게 복합 키를 이용하는 것은 사실 복잡하다. 단순히 칼럼 하나만 기본 키로 사용하는 것과 비교해서 복합 키를 사용하면 ORM 매핑에서 처리할 일이 상당히 많아진다. 

복합 키를 위한 식별자 클래스도 만들어야하고 @IdClass 또는 @EmbeddedId도 사용해야한다. 그리고 식별자 클래스에 equals, hashCode도 구현해야한다. 

 

 

다대다 새로운 기본 키 사용

회원 상품 엔티티의 기본 키를 데이터베이스에서 자동으로 생성해주는 대리 키를 Long 값으로 사용한다. 

회원 상품이라는 이름보다는 주문이라는 이름이 더 어울려서 바꿔주었다. 

주문 엔티티에 ORDER_ID 라는 새로운 기본 키를 하나 만들고 MEMBER_ID와 PRODUCT_ID를 외래 키로 사용한다. 대리 키를 사용함으로써 이전에 보았던 식별 관계에 복합 키를 사용하는 것보다 매핑이 단순하고 이해하기 쉽다. 

@Entity
public class Order {
	
    @Id @GeneratedValue
    @Column(name = "ORDER_ID")
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "MEMBER_ID")
    private Member member;
    
    @ManyToOne
    @JoinColumn(name = "PRODUCT_ID")
    private Product product;
    
    private int orderAmount;
}

 

회원 엔티티와 상품 엔티티는 변경 사항이 없다. 

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

@Entity
public class Product {
	
    @Id @Column(name = "PRODUCT_ID")
    private String id;
    
    private String name;
}

 

 

다대다 연관관계 정리

다대다 관계를 일대다 다대일 관계로 풀어내기 위해 연결 테이블을 만들 때 식별자를 어떻게 구성할 지 선택해야 한다.

 

식별 관계 : 받아온 식별자를 기본 키 + 외래 키로 사용하낟. 

비식별 관계 : 받아온 식별자는 외래 키로만 사용하고 새로운 식별자를 추가한다. 

 

식별 관계보다는 비식별 관계를 추천한다.