REFINAR Blog

글 검색

공개된 글의 제목과 본문을 검색합니다.

    닫기 Esc

    6. 다양한 연관관계 매핑

    생성 일시
    2023년 4월 30일 AM 12:30

    1. 다대일#

    1.1. 다대일 단방향 [N:1]#

    java
    @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
    ...
}
    회원 엔티티
    java
    @Entity
public class Team {

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

    private String name;

    //Getter, Setter
    ...
}
    팀 엔티티
    • 해당 연관관계는 단반향 연관관계다.
    • @JoinColumn(name = "TEAM_ID")를 사용해서 Member.team 필드를 TEAM_ID 외래 키와 매핑했다.
      • 따라서 Member.team 필드로 회원 테이블의 TEAM_ID 외래키를 관리한다.

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

    다대일 양방향
    다대일 양방향
    java
    @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);
        }
    }
}
    회원 에
    java
    @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);
        }
    }
    ...
}
    팀엔티티
    • 양방향은 외래 키가 있는 쪽이 연관관계의 주인이다.
      • 일대다와 다대일 연관관계는 항상 다(N)에 외래 키가 있다.
      • JPA는 외래 키를 관리할 때 연관관계의 주인만 사용한다.
    • 양방향 연관관계는 항상 서로를 참조해야 한다.
      • 양방향 연관관계는 항상 서로 참조해야 한다.
      • 어느 한 쪽만 참조하면 양방향 연관관계가 성립하지 않는다.
      • 편의 메소드는 한 곳에만 작성하거나 양쪽 다 작성할 수 있는데, 양쪽에 다 작성하면 무한루프에 빠지므로 주의해야 한다.

    2. 일대다#

    • 일대다 관계는 엔티티를 하나 이상 참조 가능하다.
      • 때문에 자바 컬렉션인 Collection, List, Set, Map 중에 하나를 사용해야 한다.

    2.1. 일대다 단방향 [1:N]#

    • 하나의 팀은 여러 회원을 참조할 수 있는데 이런 관계를 일대다 관계라한다.
    일대다 단방향
    일대다 단방향
    • 특이하게 팀 엔티티도 회원 외래 키를 관리한다.
    • 보통 자신이 매핑한 테이블의 외래 키를 관리하는데, 이 매핑은 반대쪽 테이블에 있는 외래 키를 관리한다.
    • 일대다 단방향 관계를 매핑할 때는 @JoinColumn을 명시해야 한다.
      • 그렇지 않으면 JPA는 연결 테이블을 중간에 두고 연관관계를 관리하는 조인 테이블(JoinTable) 전략을 기본으로 사용해서 매핑한다.

    2.1.1. 일대다 단방향 매핑의 단점#

    • 매핑한 객체가 관리하는 외래 키가 다른 테이블에 있다는 점이다.
    • 본인 테이블에 외래 키가 있으면 엔티티의 저장과 연관관계 처리를 INSERT SQL 한 번으로 끝낼 수 있다.
      • But. 다른 테이블에 외래 키가 있으면 연관관계 처를 위한 UPDATE SQL이 추가로 실행된다.

    2.1.2. 일대다 단방향 매핑보다는 다대일 양방향 매핑을 사용하자#

    • 엔티티를 매핑한 테이블이 아닌 다른 테이블의 외래 키를 관리해야 한다.
      • 이것은 성능 문제도 있지만 관리도 부담스럽다.
    • 문제를 해결하는 좋은 방법은 일대다 단방향 매핑 대신에 다대일 양방향 매핑을 사용하는 것이다.
      • 관리해야 하는 외래 키가 본인 테이블에 있기 때문에 단방향 매핑 같은 문제가 발생하지 않는다.
      • 상황에 따라 다르겠지만 일대다 단방향 매핑보다는 다대일 양방향 매핑은 권장한다.

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

    일대다 양방향
    일대다 양방향
    • 일대다 양방향 매핑은 존재하지 않는다.
      • 대신 다대일 양방향 매핑을 사용해야 한다.
      • 일대다 양방향 = 다대일 양방향
    • 양방향 매핑에서 @OneToMany는 연관관계의 주인이 될 수 없다.
      • Why? 관계형 데이터베이스의 특성상 일대다, 다대일 관계는 항상 다쪽에 외래키가 있기 때문이다.
      • 이런 이유로 @ManyToOne에는 mappedBy 속성이 없다.
    java
    @ManyToOne
@JoinColumn(name = "TEAM_ID", insertable = false, updatable = false)
private Team team;
    • 둘 다 같은 키를 관리하면 문제가 발생할 수 있기 때문에 반대편인 다대일 쪽은 insertable = false, updatable = false로 설정해서 읽기만 가능하게 했다.

    3. 일대일#

    • 일대일 관계는 양쪽이 서로 하나의 관계만 가진다.
    • 일대일 관계는 다음과 같은 특징이 있다.
      • 일대일 관계는 그 반대도 일대일 관계다.
      • 테이블 관계에서 일대다, 다대일은 항상 다(N)쪽이 외래 키를 가진다.
        • 반면에 일대일 관계는 주 테이블이나 대상 테이블 둘 중 어느 곳이나 외래 키를 가질 수 있다.
    • 테이블은 주 테이블이든 대상 테이블이든 외래 키 하나만 있으면 양쪽으로 조회할 수 있다.
    • 일대일 관계는 주 테이블이나 대상 테이블 중에 누가 외래 키를 가질지 선택해야 한다.
    • 주 테이블에 외래 키
      • 주 객체가 대상 객체를 참조하는 것처럼 주 테이블에 외래 키를 두고 대상 테이블을 참조한다.
      • 외래 키를 객체 참조와 비슷하게 사용할 수 있어서 객체지향 개발자들이 선호한다.
      • 이 방법의 장점은 주 테이블이 외래 키를 가지고 있으므로 주 테이블만 확인해도 대상 테이블과 연관관계가 있는지 알 수 있다.
    • 대상 테이블에 외래 키
      • 전통적인 데이터베이스 개발자들은 보통 대상 테이블에 외래 키를 두는 것을 선호한다.
      • 이 방법의 장점은 테이블 관계를 일대일에서 일대다로 변경할 때 테이블 구조를 그대로 유지할 수 있다.

    3.1. 주 테이블에 외래 키#

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

    3.1.1. 단방향#

    일대일 주 테이블에 외래 키, 단방향
    일대일 주 테이블에 외래 키, 단방향
    java
    @Entity
public class Member {

    @Id @GenertaedValue
    @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을 사용했고 데이터베이스에는 LOCKER_ID 외래 키에 유니크 제약 조건을 추가했다.
      • 참고로 이 관계는 다대일 단방향(@ManyToOne)과 거의 비슷하다.

    3.1.2. 양방향#

    일대일 주 테이블에 외래 키, 양방향
    일대일 주 테이블에 외래 키, 양방향
    java
    @Entity
public class Member {

    @Id @GenertaedValue
    @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를 연관관계의 주인으로 설정해야 한다.
    • JPA 2.0 부터 일대다 단방향 관계에서 대상 테이블에 외래 키가 있는 매핑을 허용했다.
      • 하지만 일대일 단방향은 이런 매핑을 허용하지 않는다.

    3.2.2. 양방향#

    일대일 대상 테이블에 외래 키, 양방향
    일대일 대상 테이블에 외래 키, 양방향
    java
    @Entity
public class Member {

    @Id @GenertaedValue
    @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;
    @JoinColumn(name = "MEMBER_ID")
    private Member member;
    ...
}
    • 일대일 매핑에서 대상 테이블에 외래 키를 두고 싶으면 이렇게 양방향으로 매핑한다.
    • 주의
      • 프록시를 사용할 때 외래 키를 직접 관리하지 않는 일대일 관계는 지연 로딩으로 설정해도 즉시 로딩된다.
      • 이것은 프록시의 한계 때문에 발생하는 문제인데 프록시 대신에 bytecode instrumentation을 사용하면 해결할 수 있다.

    4. 다대다#

    • 관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없다.
    • 그래서 보통 다대다 관계를 일대다, 다대일 관계로 풀어내는 연결 테이블을 사용한다.
    • 따라서 회원 테이블과 상품 테이블만으로는 이 관계를 표현할 수 없다.
    • 이처럼 중간 연결 테이블을 추가해 일대다, 다대일 관계로 풀어낼 수 있다.
    • 그런데 객체는 테이블과 다르게 객체 2개로 다대다 관계를 만들 수 있다.
    • @ManyToMany를 사용하면 아래 그림처럼 이런 다대다 관계를 편리하게 매핑할 수 있다.

    4.1. 다대다: 단방향#

    java
    @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>();
    ...
}
    java
    @Entity
public class Product {

    @Id @Column(name = "PRODUCT_ID")
    private String id;
    
    private String name;
    ...
}
    • 회원 엔티티와 상품 엔티티를 @ManyToMany로 매핑했다.
    • 여기서 중요한 점은 @ManyToMany와 @JoinTable을 사용해서 연결 테이블로 바로 매핑한 것이다.
      • 따라서 회원과 상품을 연결하는 Member_Product엔티티 없이 매핑을 완료할 수 있다.
    • @JoinTable.inverseJoinColumns : 반대 방향은 상품과 매핑할 조인 컬럼 정보를 지정한다. PRODUCT_ID로 지정했다.
    • MEMBER_PRODUCT 테이블은 다대다 관계를 일대다, 다대일 관계로 풀어내기 위해 필요한 연결 테이블일 뿐이다.

    4.2. 다대다: 양방향#

    java
    @Entity
public class Product {
    
    @Id
    private String id;
    
    @ManyToMany(mappedBy = "products")  // 역방향 추가
    private List<Member> members;
    ...
}
    • 다대다 매핑이므로 역방향 @ManyToMany를 사용한다.
      • 그리고 양쪽 중 원하는 곳에 mappedBy로 연관관계의 주인을 지정한다.
    java
    member.getProducts().add(product);
members.getMembers().add(member);
    다대다 양방향 연관관계 설정
    java
    public void findInverse() {

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

    4.3. 다대다: 매핑의 한계와 극복, 연결 엔티티 사용#

    • @ManyToMany를 사용하면 연결 테이블을 자동으로 처리해주므로 도메인 모델이 단순해지고 여러 가지로 편리하다.
    • 하지만 이 매핑을 실무에서 사용하기에는 한계가 있다.
      • 예를 들어 회원이 상품을 주문하면 연결 테이블에 단순히 주문한 회원 아이디와 상품 아이디만 담고 끝나지 않는다.
      • 보통은 연결 테이블에 주문 수량 컬럼이나 주문한 날짜 같은 컬럼이 더 필요하다.
    java
    @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;
    
    ...
}
    회원상품 엔티티 코드
    java
    public class MemberProductId implements Serializable {

    private String member;   // MemberProduct.member와 연결
    private String product;  // MemberProduct.product와 연결
    
    // hashCode and equals
    
    @Override
    public boolean equals(Object o) {...}
    
    @Override
    public int hashCode() {...}
}
    회원상품 식별자 클래스
    • MemberProduct 엔티티를 보면 기본 키를 매핑하는 @Id와 외래 키를 매핑하는 @JoinColumn을 동시에 사용해서 기본 키 + 외래 키를 한번에 매핑하고 @IdClass를 사용해 복합 기본 키를 매핑했다.

    4.3.1. 복합 기본 키#

    • JPA에서 복합 키를 사용하려면 별도의 식별자 클래스를 만들어야 한다.
    • 그리고 엔티티에 @IdClass를 사용해서 식별자 클래스를 지정하면 된다.
    • 복합 키를 위한 식별자 클래스는 다음과 같은 특징이 있다.
      • 복합 키는 별도의 식별자 클래스로 만들어야 한다.
      • Serializable을 구현해야 한다.
      • equals와 hashCode 메소드를 구현해야 한다.
      • 기본 생성자가 있어야 한다.
      • 식별자 클래스는 public이어야 한다.
      • @IdClass를 사용하는 방법 외에 @EmbeddedId를 사용하는 방법도 있다.

    4.3.2. 식별 관계#

    • 회원상품은 회원과 상품의 기본 키를 받아서 자신의 기본 키로 사용한다.
    • 이렇게 부모 테이블의 기본 키를 받아서 자신의 기본 키 + 외래 키로 사용하는 것을 데이터베이스 용어로 식별 관계라 한다.
    • MemberProduct은 회원의 기본 키를 받아서 자신의 기본 키로 사용함과 동시에 회원과의 관계를 위한 외래 키로 사용한다.
    java
    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);
}
    저장하는 코드
    java
    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();
    
    System.out.println("member = " + member.getUserName());
    System.out.println("product = " + product.getName());
    System.out.println("orderAmount = " + memberProduct.getOrderAmount());
    
}
    조회하는 코드
    • 복합 키를 사용하는 방법은 복잡하다.
    • 단순히 컬럼 하나만 기본 키를 사용하는 것과 비교해서 복합 키를 사용하면 ORM 매핑에서 처리할 일이 상당히 많아진다.

    4.4. 다대다: 새로운 기본 키 사용#

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

    4.5. 다대다 연관관계 정리#

    • 다대다 관계를 일대다 다대일 관계로 풀어내기 위해 연결 테이블을 만들 때 식별자를 어떻게 구성할지 선택해야 한다.
      • 식별 관계 : 받아온 식별자를 기본 키 + 외래 키로 사용한다.
        • 데이터베이스 설계에서는 부모 테이블의 기본 키를 받아서 자식 테이블의 기본 키 + 외래 키로 사용하는 것을 식별 관계라 한다
      • 비식별 관계 : 받아온 식별자는 외래 키로만 사용하고 새로운 식별자를 추가한다.
        • 단순히 외래키로만 사용하는 것을 비식별 관계라고 한다.
    • 객체 입장에서 보면 비식별 관계를 사용하는 것이 복합 키를 위한 식별자 클래스를 만들지 않아도 되므로 단순하고 편리하게 ORM 매핑을 할 수 있다.
      • 이런 이유로 식별 관계보다는 비식별 관계를 추천한다.
    전체 글 둘러보기