hyot

두고두고 기억하고픈 내 경험

Updated:

다중성과 단방향, 양방향을 고려한 가능한 모든 연관관계를 하나씩 알아보자
참고로 다중성은 왼쪽을 연관관계의 주인으로 정했다. 예를 들어 다대일 양방향이라 하면 다(N)가 연관관계의 주인이다.

  • 다대일: 단방향, 양방향
  • 일대다: 단방향, 양방향
  • 일대일: 주 테이블 단방향, 양방향
  • 일대일: 대상 테이블 단방향, 양방향
  • 다대다: 단방향, 양방향

1. 다대일

1-1. 다대일 단방향 [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;
    
    // Getter, Setter ...
}

@Entity
public class Team {
    
    @Id @GeneratedValue
    @Column(name = "TEAM_ID")
    private Long id;
    
    private String name;
    
    // Getter, Setter ...
}

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

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

양방향은 외래 키가 있는 쪽이 연관관계의 주인이다.
양방향 연관관계는 항상 서로를 참조해야 한다.
연관관계 편의 메소드를 양쪽에 다 작성하면 무한루프에 빠지므로 주의해야 한다.

2. 일대다

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

2-1. 일대다 단방향 [1:N]

일대다 단방향 관계는 JPA 2.0부터 지원한다.

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

    // Getter, Setter ...
}

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

    // Getter, Setter ...
}

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

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-member1
    em.persist(member2); // INSERT-member2
    em.persist(team1); // INSERT-team1, UPDATE-member1.fk, UPDATE-member2.fk
}

Member 엔티티를 저장할 때는 MEMBER 테이블의 TEAM_ID 외래 키에 아무 값도 저장되지 않는다.
대신 Team 엔티티를 저장할 때 Team.members의 참조 값을 확인해서 회원 테이블에 있는 TEAM_ID 외래 키를 업데이트한다.
이것은 성능 문제도 있지만 관리도 부담스러우므로, 일대다 단방향 매핑보다는 다대일 양방향 매핑을 권장한다.

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

일대다 양방향 매핑은 존재하지 않는다. 대신 다대일 양방향 매핑을 사용해야 한다.
일대다 양방향과 다대일 양방향은 사실 똑같은 말이나, 왼쪽을 연관관계의 주인으로 가정하게 되면 양방향 매핑에서 @OneToMany는 연관관계의 주인이 될 수 없다.
왜냐하면 관계형 데이터베이스의 특성상 일대다, 다대일 관계는 항상 다 쪽에 외래 키가 있기 때문이다.
이런 이유로 @ManyToOne에는 mappedBy 속성이 없다.

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

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

    // Getter, Setter ...
}

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

    // Getter, Setter ...
}

이 방법은 일대다 양방향 매핑이라기보다는 일대다 단방향 매핑 반대편에 다대일 단방향 매핑을 읽기 전용으로 추가해서 일대다 양방향처럼 보이도록 하는 방법이다.
따라서 일대다 단방향 매핑이 가지는 단점을 그대로 가진다. 될 수 있으면 다대일 양방향 매핑을 사용하자

3. 일대일 [1:1]

일대일 관계는 양쪽이 서로 하나의 관계만 가진다. 예를 들어 회원은 하나의 사물함만 사용하고 사물함도 하나의 회원에 의해서만 사용된다.
일대일 관계는 다음과 같은 특징이 있다.

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

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

3-1. 주 테이블에 외래 키

일대일 관계를 구성할 때 객체지향 개발자들은 주 테이블에 외래 키가 있는 것을 선호한다.
JPA도 주 테이블에 외래 키가 있으면 좀 더 편리하게 매핑할 수 있다.

3-1-1. 단방향

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

3-1-2. 양방향

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

3-2. 대상 테이블에 외래 키

3-2-1. 단방향

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

3-2-2. 양방향

@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개로 다대다 관계를 표현할 수 없다.
그래서 보통 다대다 관계를 일대다, 다대일 관계로 풀어내는 연결 테이블을 사용한다.
그런데 객체는 테이블과 다르게 객체 2개로 다대다 관계를 만들 수 있다.
@ManyToMany를 사용하면 다대다 관계를 편리하게 매핑할 수 있다.

4-1. 다대다: 단방향

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

회원 엔티티와 상품 엔티티를 @ManyToMany로 매핑했다. 여기서 중요한 점은 @ManyToMany와 @JoinTable을 사용해서 연결 테이블을 바로 매핑한 것이다.
따라서 회원과 상품을 연결하는 회원_상품(Member_Product) 엔티티 없이 매핑을 완료할 수 있다.
MEMBER_PRODUCT 테이블은 다대다 관계를 일대다, 다대일 관계로 풀어내기 위해 필요한 열결 테이블일 뿐이므로, 이 연결 테이블을 신경 쓰지 않아도 된다.

@JoinTable 속성

  • @JoinTable.name
    • 연결 테이블을 지정한다
    • 여기서는 MEMBER_PRODUCT 테이블을 선택했다
  • @JoinTable.joinColumns
    • 현재 방향인 회원과 매핑할 조인 컬럼 정보를 지정한다.
    • MEMBER_ID로 지정했다
  • @JoinTable.inverseJoinColumns
    • 반대 방향인 상품과 매핑할 조인 컬럼 정보를 지정한다
    • PRODUCT_ID로 지정했다

다대다 관계를 저장하는 예제를 보자

public void save() {
    
    Proudct 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 ...

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

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

member.getProducts()를 호출해서 상품 이름을 출력하면 다음 SQL이 실행된다.

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

4-2. 다대다: 양방향

역방향도 @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);
}

4-3. 다대다: 매핑의 한계와 극복, 연결 엔티티 사용

회원이 상품을 주문하면 보통 연결 테이블에 주문 수량 컬럼이나 주문한 날짜 같은 컬럼이 필요하다.
이렇게 컬럼을 추가하면 더는 @ManyToMany를 사용할 수 없다.
왜냐하면 주문 엔티티나 상품 엔티티에는 추가한 컬럼들을 매핑할 수 없기 때문이다.
결국 회원상품(MemberProduct) 엔티티를 추가하고 일대다, 다대일 관계로 풀어야 한다.

@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 String name;
    ...
}

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

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

회원 상품(MemberProduct) 엔티티를 보면 기본 키를 매핑하는 @Id와 외래 키를 매핑하는 @JoinColumn을 동시에 사용해서
기본 키 + 외래 키를 한번에 매핑했다. 그리고 @IdClass를 사용해서 복합 기본 키를 매핑했다.
복합 키를 위한 식별자 클래스는 다음과 같은 특징이 있다.

  • 복합 키는 별도의 식별자 클래스로 만들어야 한다
  • Serializable을 구현해야 한다
  • equals와 hashCode 메소드를 구현해야 한다
  • 기본 생성자가 있어야 한다
  • 식별자 클래스는 public이어야 한다
  • @IdClass를 사용하는 방법 외에 @EmbeddedId를 사용하는 방법도 있다

회원 상품은 회원과 상품의 기본 키를 받아서 자신의 기본 키로 사용한다.
이렇게 부모 테이블의 기본 키를 받아서 자신의 기본 키 + 외래 키로 사용하는 것을 데이터베이스 용어로 식별 관계(Identifying Relationship)라 한다. 이제는 저장하는 예제를 살펴보자

public void save() {
    
    // 회원 저장
    Member member1 = new Member();
    member1.setId("member1");
    member1.setUsername("회원1");
    em.persist(member1);
    
    // 상품 저장
    Product productA = new Product();
    productA.setId("productA");
    productA.setName("상품1");
    em.persist(productA);
    
    // 회원 상품 저장
    MemberProduct memberProduct = new MemberProduct();
    memberProduct.setMember(member1); // 주문 회원 - 연관관계 설정
    memberProduct.setProduct(productA); // 주문 상품 - 연관관계 설정
    memberProduct.setOrderAmount(2); // 주문 수량
  
    em.persist(memberProduct);
}

다음으로 조회하는 예제를 보자

public void find() {
    
    // 기본 키 값 생성
    MemberProductId memberProductId = new MemberProductId();
    memberProductId.setMember("member1");
    memberProductId.setProduct("productA");
    
    MemberProduct memberProduct = em.find(MemberProduct.class, memberProductId);
    
    Member member = memberProduct.getMember();
    Product product = memberProduct.getProduct();
}

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

4-4. 다대다: 새로운 기본 키 사용

추천하는 기본 키 생성 전략은 데이터베이스에서 자동으로 생성해주는 대리 키를 Long 값으로 사용하는 것이다.
이것의 장점은 간편하고 거의 영구히 쓸 수 있으며 비즈니스에 의존하지 않는다.
그리고 ORM 매핑 시에 복합 키를 만들지 않아도 되므로 간단히 매핑을 완성할 수 있다.

회원상품(MemberProduct) 보다는 주문(Order)이라는 이름이 더 어울리므로 변경한다.
회원 엔티티와 상품 엔티티는 변경사항이 없다.

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

다음으로 조회하는 예제를 보자
식별자 클래스를 사용하지 않아서 코드가 한결 단순해졌다.

public void find() {
    
    Long orderId = 1L;
    Order order = em.find(Order.class, orderId);
    
    Member member = order.getMember();
    Product product = order.getProduct();
}

4-5. 다대다 연관관계 정리

식별 관계보다는 단순하고 편리하게 ORM 매핑할 수 있는 비식별 관계를 추천한다.

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

Leave a comment

You may also enjoy