다양한 연관관계 매핑

July 27, 2021

6. 다양한 연관관계 매핑

연관관계 매핑시 다음 3가지를 고려해야 한다.
- 다중성
- 단방향, 양방향
- 연관관계의 주인
연관관계의 주인
- 데이터베이스는 외래 키 하나로 두 테이블이 연관관계를 맺는다.
- 엔티티는 양방향일 경우 A->B, B->A 두 개의 연관관계가 있다.
- 엔티티의 두 관계중 외래 키를 관리하는 쪽이 연관관계의 주인이다.
- 외래 키를 가진 테이블과 매핑한 엔티티를 보통 연관관계의 주인으로 선택한다.

6.1 다대일

데이터베이스의 외래 키는 항상 다쪽 테이블에 있다.
연관관계의 주인은 다쪽 이다.

6.1.1 다대일 단방향 [N:1]

연관관계의 주인은 Member.team 이다.

@Entity
public class Member {

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

    private String username;

    @ManyToOne
    @JoinColumn(name = "team_id") // team 필드를 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 생략
}

6.2.2 다대일 양방향 [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) {
        // 기존 팀 관계 제거
        if (this.team != null) {
            this.team.getMembers().remove(this);
        }

        this.team = team;

        if (team != null) {
            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<>();

    public void addMember(Member member) {
        // 기존 팀 관계 제거
        if (member.getTeam() != null) {
            member.getTeam().getMembers().remove(member);
        }
        members.add(member);
        member.setTeam(this);
    }
}

6.2 일대다

6.2.1 일대다 단방향[1:N]

Team.members 로 외래 키를 관리한다.
일대다 관계는 반대쪽 테이블에 있는 외래 키를 관리한다. 일대다 관계에서 외래 키는 항상 다쪽 테이블에 있기 때문이다.
일대다 단방향 관계를 매핑할 때는 @JoinColumn을 명시해야 한다. 그렇지 않으면 JPA가 조인 테이블 전략을 사용해서 매핑한다.
UPDATE SQL이 추가로 실행된다.
일다대 단방향 매핑을 사용하면 엔티티를 매핑한 테이블이 아닌 다른 테이블의 외래 키를 관리해야 한다. 즉 Team.members 를 변경할 경우 Member 의 외래 키가 업데이트 된다. 따라서 다대일 양방향 매핑을 사용하는 것을 권장한다.

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

    public void addMember(Member member) {
        members.add(member);
    }
    // Getter, Setter 생략
}

@Entity
public class Member {

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

    private String username;

    // Getter, Setter 생략
}

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

@ManyToOne 은 항상 연관관계의 주인이다. 따라서 @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<>();

    public void addMember(Member member) {
        members.add(member);
    }
    // Getter, Setter 생략
}

@Entity
public class Member {

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

    private String username;

    @ManyToOne
    @JoinColumn(name = "team_id", updatable = false, insertable = false)
    private Team team;
    // Getter, Setter 생략
}

6.3 일대일[1:1]

일대일 관계는 그 반대도 일대일 관계이다.
일대일 관계는 외래 키가 둘 중 어느곳에도 위치할 수 있다.
주 테이블에 외래 키
- 주 객체가 대상 객체를 참조하고 주 테이블에 외래 키를 둔다. 객체지향 개발자들이 선호한다.
대상 테이블에 외래 키
- 테이블 관계를 일대일에서 일대다로 변경할 때 테이블 구조를 그대로 유지할 수 있다.

6.3.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;
    // Getter, Setter 생략
}

@Entity
public class Locker {

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

    private String name;
    // Getter, Setter 생략
}

양방향

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;
    // Getter, Setter 생략
}

@Entity
public class Locker {

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

    private String name;

    @OneToOne(mappedBy = "locker")
    private Member member;
    // Getter, Setter 생략
}

6.3.2 대상 테이블에 외래 키

단방향

일대일 관계 중 대상 테이블에 외래 키가 있는 단방향 관계는 JPA에서 지원하지 않는다.
JPA 2.0 부터 일대다 단방향 관계에서 대상 테이블에 외래 키가 있는 매핑은 허용하지만 일대일 단방향은 허용하지 않는다.

양방향

Locker.member 가 연관관계의 주인이다.
Member.locker 는 연관관계의 주인이 아니므로 mappedBy 속성을 설정한다.

@Entity
public class Member {

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

    private String username;

    @OneToOne(mappedBy = "member")
    private Locker locker;
    // Getter, Setter 생략
}

@Entity
public class Locker {

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

    private String name;

    @OneToOne
    @JoinColumn(name = "member_id")
    private Member member;
    // Getter, Setter 생략
}

양방향 관계에서 외래 키를 직접 관리하지 않는 관계는 지연 로딩으로 설정해도 즉시 로딩된다. 예를 들면, 대상 테이블의 외래 키 양방향 관계에서 Locker.member 는 지연 로딩되지만 Member.locker 는 무조건 즉시 로딩된다. 왜냐하면 Member 조회시, JPA는 Member.locker 의 값을 null 또는 프록시 객체로 설정해야 하는데 둘 다 모두 LOCKER 테이블의 MEMBER.ID 외래 키를 검색하여 판단할 수 밖에 없다. 결과적으로 무조건 Locker 테이블을 조회해야 하므로 즉시 로딩으로 값을 설정해준다.

6.4 다대다[N:N]

관계형 데이터베이스는 정규화된 테이블 2개로 다대다 관계를 표현할 수 없다.

다대다 관계를 일대다, 다대일 관계로 풀어내는 연결 테이블을 사용한다.

6.4.1 다대다: 단방향

@ManyToMany, @JoinTable 을 사용해서 매핑한다.
다대다 관계를 일대다, 다대일 관계로 풀어내는 중간 테이블을 자동으로 생성해준다.
@JoinTable.name: 연결 테이블 지정
@JoinTable.joinColumns: 현재 방향인 회원과 매핑할 조인 컬럼 정보를 지정한다. (MEMBER_ID)
@JoinTable.inverseJoinColumns: 반대 방향인 상품과 매핑할 조인 컬럼 정보를 지정한다. (PRODUCT_ID)

@Entity
public class Member {

    @Id
    @GeneratedValue
    @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<>();
    // Getter, Setter 생략
}

@Entity
public class Product {

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

    private String name;
    // Getter, Setter 생략
}

Product product1 = new Product();
product1.setName("product1");
em.persist(product1);

Product product2 = new Product();
product2.setName("product2");
em.persist(product2);

Member member1 = new Member();
member1.setUsername("member1");
member1.getProducts().add(product1);
member1.getProducts().add(product2);
em.persist(member1);

em.flush();
em.clear();

System.out.println("==============");

Member foundMember = em.find(Member.class, member1.getId());
for (Product product : foundMember.getProducts()) {
    System.out.println("product = " + product);
}

insert into Product (name, product_id) values (?, ?)
insert into Product (name, product_id) values (?, ?)
insert into Member (username, member_id) values (?, ?)
insert into member_product (member_id, product_id) values (?, ?)
insert into member_product (member_id, product_id) values (?, ?)

select m.member_id, m.username
from Member m 
where m.member_id=?

select mp.member_id, mp.product_id, p.product_id, p.name 
from member_product mp 
inner join Product p on mp.product_id = p.product_id 
where mp.member_id=?

6.4.2 다대다: 양방향

    @Id
    @GeneratedValue
    @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<>();
    // Getter, Setter 생략

@Entity
public class Product {

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

    private String name;

    @ManyToMany(mappedBy = "products")
    private List<Member> members = new ArrayList<>();
    // Getter, Setter 생략
}

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

@ManyToMany를 사용하면 연결 테이블을 자동으로 처리해준다.
@ManyToMany로 추가되는 연결 테이블에는 새로운 컬럼을 추가할 수 없다.
실무에서는 MEMBER_ID와 PRODUCT_ID 외에도 ORDERAMOUNT, ORDERDATE 같은 컬럼이 필요할 수 있다.
따라서 연결 엔티티를 만들어 테이블로 매핑하여 사용해야 한다.

연결 엔티티

@Entity
public class Member {

    @Id
    @Column(name = "member_id")
    private String id;

    private String username;

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

@Entity
public class Product {

    @Id
    @Column(name = "product_id")
    private String id;

    private String name;
    // Getter, Setter 생략
}

@Entity
public class Product {

    @Id
    @Column(name = "product_id")
    private String id;

    private String name;
    // Getter, Setter 생략
}

@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;
    // Getter, Setter 생략
}

public class MemberProductId implements Serializable {

    private String member;
    private String product;

    // Getter, Setter 생략

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MemberProductId that = (MemberProductId) o;
        return Objects.equals(member, that.member) && Objects.equals(product, that.product);
    }

    @Override
    public int hashCode() {
        return Objects.hash(member, product);
    }
}

public class JpaMain {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");

        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {
            System.out.println("==== SAVE ====");
            Member member1 = new Member();
            member1.setId("member1");
            member1.setUsername("member1");
            em.persist(member1);

            Product product1 = new Product();
            product1.setId("product1");
            product1.setName("product1");
            em.persist(product1);

            MemberProduct memberProduct = new MemberProduct();
            memberProduct.setMember(member1);
            memberProduct.setProduct(product1);
            memberProduct.setOrderAmount(2);
            em.persist(memberProduct);

            em.flush();
            em.clear();

            System.out.println("==== FIND ====");

            MemberProductId memberProductId = new MemberProductId();
            memberProductId.setMember("member1");
            memberProductId.setProduct("product1");

            MemberProduct foundMemberProduct = em.find(MemberProduct.class, memberProductId);
            Member foundMember = foundMemberProduct.getMember();
            Product foundProduct = foundMemberProduct.getProduct();

            System.out.println("foundMember.getUsername() = " + foundMember.getUsername());
            System.out.println("foundProduct.getName() = " + foundProduct.getName());
            System.out.println("foundMemberProduct.getOrderAmount() = " + foundMemberProduct.getOrderAmount());
            
            tx.commit();
        }
        catch (Exception e) {
            tx.rollback();
            e.printStackTrace();
        }
        finally {
            em.close();
        }

        emf.close();
    }
}

복합 기본 키
- MemberProduct 엔티티는 MEMBER_ID와 PRODUCT_ID로 이루어진 복합 기본 키를 사용한다.
- @IdClass를 사용해서 복합 키 식별자 클래스를 지정한다.
복합 키 식별자 클래스
- 복합 키는 별도의 식별자 클래스로 만들어야 한다.
- Serializable을 구현해야 한다.
- equals, hashCode 메소드를 구현해야 한다.
- 기본 생성자가 있어야 한다.
- 식별자 클래스는 public이어야 한다.
- @IdClass를 사용하는 방법 외에 @EmbeddedId를 사용하는 방법도 있다.

6.4.4 다대다: 새로운 기본 키 사용

중간 테이블인 ORDER의 기본 키로 복합 키가 아닌 대리 키를 사용한다.

@Entity
@Table(name = "orders")
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;
    private LocalDateTime orderDate;
    // Getter, Setter 생략
}

@Entity
public class Member {

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

    private String username;

    @OneToMany(mappedBy = "member")
    private List<Order> orders = new ArrayList<>();
    // Getter, Setter 생략
}

@Entity
public class Product {

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

    private String name;
    // Getter, Setter 생략
}

public class JpaMain {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("hello");

        EntityManager em = emf.createEntityManager();

        EntityTransaction tx = em.getTransaction();
        tx.begin();

        try {
            System.out.println("==== SAVE ====");
            Member member1 = new Member();
            member1.setUsername("member1");
            em.persist(member1);

            Product product1 = new Product();
            product1.setName("product1");
            em.persist(product1);

            Order order = new Order();
            order.setMember(member1);
            order.setProduct(product1);
            order.setOrderAmount(2);
            order.setOrderDate(LocalDateTime.now());
            em.persist(order);

            em.flush();
            em.clear();

            System.out.println("==== FIND ====");

            Order foundOrder = em.find(Order.class, order.getId());
            Member foundMember = foundOrder.getMember();
            Product foundProduct = foundOrder.getProduct();

            System.out.println("foundMember.getUsername() = " + foundMember.getUsername());
            System.out.println("foundProduct.getName() = " + foundProduct.getName());
            System.out.println("foundOrder.getOrderAmount() = " + foundOrder.getOrderAmount());
            System.out.println("foundOrder.getOrderDate() = " + foundOrder.getOrderDate());

            tx.commit();
        }
        catch (Exception e) {
            tx.rollback();
            e.printStackTrace();
        }
        finally {
            em.close();
        }

        emf.close();
    }
}

6.4.5 다대다 연관관계 정리

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

Share on

Twitter Facebook LinkedIn

nefertiri

다양한 연관관계 매핑

6. 다양한 연관관계 매핑

6.1 다대일

6.1.1 다대일 단방향 [N:1]

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

6.2 일대다

6.2.1 일대다 단방향[1:N]

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

6.3 일대일[1:1]

6.3.1 주 테이블에 외래 키

단방향

양방향

6.3.2 대상 테이블에 외래 키

단방향

양방향

6.4 다대다[N:N]

6.4.1 다대다: 단방향

6.4.2 다대다: 양방향

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

6.4.4 다대다: 새로운 기본 키 사용

6.4.5 다대다 연관관계 정리

Share on

Leave a comment

You may also enjoy

2021년 회고

생활코딩 머신러닝1

웹 애플리케이션 제작

객체지향 쿼리 언어 - 네이티브 SQL, 객체지향 쿼리 심화